Skip to main content

rigspark_cli/
tui_lifecycle.rs

1use crossterm::event::{Event, KeyCode, KeyEventKind, KeyModifiers};
2use futures_util::{Stream, StreamExt, stream};
3use ratatui::{
4    Frame, Terminal,
5    backend::Backend,
6    layout::{Constraint, Layout},
7    style::{Color, Modifier, Style},
8    widgets::{Paragraph, Wrap},
9};
10use rigspark_core::reports::strip_control;
11use rigspark_runtime::{
12    adapters::BackendError,
13    application::events::{
14        DiagnosticObserver, DiagnosticSnapshot, EVENT_CAPACITY, LifecycleEvent, LifecycleScope,
15        LifecycleStage, LifecycleStatus,
16    },
17};
18use serde_json::Value;
19use std::{
20    collections::VecDeque,
21    future::Future,
22    io::{self, Write},
23    time::Duration,
24};
25use tokio::sync::mpsc::Receiver;
26use tokio_util::sync::CancellationToken;
27
28type RuntimeResult = Result<(Value, String), BackendError>;
29
30#[derive(Clone, Copy, Debug, PartialEq, Eq)]
31enum Phase {
32    Running,
33    Event(LifecycleEvent),
34    Redraw(i16),
35    Cancelling,
36    Restore,
37    Completed,
38    Failed,
39}
40
41enum Control {
42    Cancel(u8),
43    Redraw(i16),
44    Resize { eligible: bool },
45}
46
47pub struct Outcome {
48    pub result: RuntimeResult,
49    pub exit_code: u8,
50    pub presentation_error: Option<String>,
51    pub presentation_restored: bool,
52    pub diagnostics: Option<DiagnosticSnapshot>,
53}
54
55async fn drive(
56    operation: impl Future<Output = RuntimeResult>,
57    cancel: &CancellationToken,
58    controls: impl Stream<Item = io::Result<Control>>,
59    events: Option<Receiver<LifecycleEvent>>,
60    present: impl FnMut(Phase) -> io::Result<()>,
61) -> io::Result<Outcome> {
62    drive_with_redraw(
63        operation,
64        cancel,
65        controls,
66        events,
67        present,
68        stream::pending(),
69    )
70    .await
71}
72
73async fn drive_with_redraw(
74    operation: impl Future<Output = RuntimeResult>,
75    cancel: &CancellationToken,
76    controls: impl Stream<Item = io::Result<Control>>,
77    events: Option<Receiver<LifecycleEvent>>,
78    present: impl FnMut(Phase) -> io::Result<()>,
79    redraw: impl Stream<Item = ()>,
80) -> io::Result<Outcome> {
81    drive_with_deadline(
82        operation,
83        cancel,
84        controls,
85        events,
86        present,
87        redraw,
88        Duration::from_millis(crate::cancellation::CLEANUP_TIMEOUT_MS),
89    )
90    .await
91}
92
93async fn drive_with_deadline(
94    operation: impl Future<Output = RuntimeResult>,
95    cancel: &CancellationToken,
96    controls: impl Stream<Item = io::Result<Control>>,
97    mut events: Option<Receiver<LifecycleEvent>>,
98    mut present: impl FnMut(Phase) -> io::Result<()>,
99    redraw: impl Stream<Item = ()>,
100    cleanup_timeout: Duration,
101) -> io::Result<Outcome> {
102    present(Phase::Running)?;
103    let deadline = async {
104        cancel.cancelled().await;
105        tokio::time::sleep(cleanup_timeout).await;
106    };
107    tokio::pin!(deadline);
108    tokio::pin!(operation, controls, redraw);
109    let mut exit_code = 0;
110    let mut presentation_error = None;
111    let mut controls_done = false;
112    let mut output_failed = false;
113    let mut restored = false;
114    let mut resize_deadline = None;
115    let result = loop {
116        tokio::select! {
117            biased;
118            _ = &mut deadline, if !restored => {
119                restored = true;
120                if let Err(error) = present(Phase::Restore) {
121                    presentation_error.get_or_insert_with(|| error.to_string());
122                }
123                output_failed = true;
124            }
125            _ = async {
126                if let Some(deadline) = resize_deadline {
127                    tokio::time::sleep_until(deadline).await;
128                } else { std::future::pending::<()>().await; }
129            }, if !restored && !cancel.is_cancelled() => {
130                restored = true;
131                resize_deadline = None;
132                if let Err(error) = present(Phase::Restore) {
133                    presentation_error.get_or_insert_with(|| error.to_string());
134                }
135                output_failed = true;
136            }
137            control = controls.next(), if !controls_done => {
138                if let Some(Ok(Control::Resize { eligible })) = control {
139                    if !restored {
140                        resize_deadline = (!eligible).then(||
141                            tokio::time::Instant::now() + Duration::from_millis(50));
142                    }
143                    continue;
144                }
145                if let Some(Ok(Control::Redraw(scroll))) = control {
146                    if !output_failed && let Err(error) = present(Phase::Redraw(scroll)) {
147                        output_failed = true;
148                        presentation_error.get_or_insert_with(|| error.to_string());
149                        exit_code = 1;
150                        cancel.cancel();
151                    }
152                    continue;
153                }
154                controls_done = true;
155                match control {
156                    Some(Ok(Control::Cancel(code))) => exit_code = code,
157                    failure => {
158                        exit_code = 1;
159                        presentation_error.get_or_insert_with(|| match failure {
160                            Some(Err(error)) => error.to_string(),
161                            _ => "lifecycle control input ended".into(),
162                        });
163                    }
164                }
165                cancel.cancel();
166                if !output_failed && let Err(error) = present(Phase::Cancelling) {
167                    output_failed = true;
168                    presentation_error.get_or_insert_with(|| error.to_string());
169                }
170            }
171            result = &mut operation => break result,
172            event = async {
173                match &mut events {
174                    Some(receiver) => receiver.recv().await,
175                    None => std::future::pending().await,
176                }
177            }, if events.is_some() => {
178                match event {
179                    Some(event) if !output_failed => {
180                        if let Err(error) = present(Phase::Event(event)) {
181                            output_failed = true;
182                            presentation_error.get_or_insert_with(|| error.to_string());
183                            if exit_code == 0 {
184                                exit_code = 1;
185                            }
186                            cancel.cancel();
187                        }
188                    }
189                    Some(_) => (),
190                    None => events = None,
191                }
192            }
193            Some(()) = redraw.next(), if !output_failed => {
194                if let Err(error) = present(Phase::Redraw(0)) {
195                    output_failed = true;
196                    presentation_error.get_or_insert_with(|| error.to_string());
197                    if exit_code == 0 { exit_code = 1; }
198                    cancel.cancel();
199                }
200            }
201        }
202    };
203    if let Some(receiver) = &mut events {
204        receiver.close();
205        while let Ok(event) = receiver.try_recv() {
206            if !output_failed && let Err(error) = present(Phase::Event(event)) {
207                output_failed = true;
208                presentation_error.get_or_insert_with(|| error.to_string());
209                cancel.cancel();
210            }
211        }
212    }
213    if presentation_error.is_some() && exit_code == 0 {
214        exit_code = 1;
215    }
216    if result.is_err() && exit_code == 0 {
217        exit_code = 1;
218    }
219    if !output_failed
220        && let Err(error) = present(if result.is_ok() {
221            Phase::Completed
222        } else {
223            Phase::Failed
224        })
225    {
226        presentation_error.get_or_insert_with(|| error.to_string());
227        if exit_code == 0 {
228            exit_code = 1;
229        }
230    }
231    Ok(Outcome {
232        result,
233        exit_code,
234        presentation_error,
235        presentation_restored: restored,
236        diagnostics: None,
237    })
238}
239
240pub async fn interruption() -> io::Result<u8> {
241    crate::cancellation::TerminalSignals::new()?.recv().await
242}
243
244pub async fn run(
245    command: &str,
246    target: &str,
247    operation: impl Future<Output = RuntimeResult>,
248    cancel: &CancellationToken,
249    interactive: bool,
250) -> io::Result<Outcome> {
251    run_observed(command, target, operation, cancel, interactive, None).await
252}
253
254pub async fn run_observed(
255    command: &str,
256    target: &str,
257    operation: impl Future<Output = RuntimeResult>,
258    cancel: &CancellationToken,
259    interactive: bool,
260    events: Option<Receiver<LifecycleEvent>>,
261) -> io::Result<Outcome> {
262    let mut signals = crate::cancellation::TerminalSignals::new()?;
263    let controls = stream::once(async { signals.recv().await.map(Control::Cancel) });
264    let sizes = resize_controls(interactive);
265    let mut output = io::stderr();
266    drive(
267        operation,
268        cancel,
269        stream::select(controls, sizes),
270        events,
271        |phase| {
272            if !interactive {
273                return Ok(());
274            }
275            write_phase(&mut output, command, target, phase)
276        },
277    )
278    .await
279}
280
281pub async fn run_visual(
282    command: &str,
283    target: &str,
284    operation: impl Future<Output = RuntimeResult>,
285    cancel: &CancellationToken,
286    color: bool,
287    events: Receiver<LifecycleEvent>,
288    diagnostics: DiagnosticObserver,
289) -> io::Result<Outcome> {
290    let mut terminal_signals = crate::cancellation::TerminalSignals::new()?;
291    let (mut terminal, restore) = crate::tui_view::enter_terminal()?;
292    let mut restore = Some(restore);
293    let mut view = LifecycleView::new(command, target, color);
294    let input_owner = std::sync::Arc::new(std::sync::Mutex::new(Some(
295        crate::terminal_events::terminal_events(),
296    )));
297    let input = visual_input(input_owner.clone());
298    let signals = stream::once(async { terminal_signals.recv().await.map(Control::Cancel) });
299    drive_visual(
300        (&mut terminal, || {
301            input_owner
302                .lock()
303                .unwrap_or_else(|error| error.into_inner())
304                .take();
305            drop(restore.take());
306        }),
307        &mut view,
308        operation,
309        cancel,
310        stream::select(signals, input),
311        events,
312        &diagnostics,
313    )
314    .await
315}
316
317fn visual_input<Events>(
318    owner: std::sync::Arc<std::sync::Mutex<Option<Events>>>,
319) -> impl Stream<Item = io::Result<Control>>
320where
321    Events: Stream<Item = io::Result<Event>> + Unpin,
322{
323    stream::poll_fn(move |context| {
324        let mut owner = owner.lock().unwrap_or_else(|error| error.into_inner());
325        let Some(events) = owner.as_mut() else {
326            return std::task::Poll::Ready(None);
327        };
328        match std::pin::Pin::new(events).poll_next(context) {
329            std::task::Poll::Ready(Some(event)) => {
330                std::task::Poll::Ready(Some(event.map(visual_control)))
331            }
332            std::task::Poll::Ready(None) => {
333                owner.take();
334                std::task::Poll::Ready(Some(Err(io::Error::other("terminal input ended"))))
335            }
336            std::task::Poll::Pending => std::task::Poll::Pending,
337        }
338    })
339}
340
341fn resize_control(columns: u16, rows: u16, accessible: bool) -> Control {
342    let (minimum_columns, minimum_rows) = if accessible { (40, 10) } else { (60, 16) };
343    Control::Resize {
344        eligible: columns >= minimum_columns && rows >= minimum_rows,
345    }
346}
347
348fn resize_controls(enabled: bool) -> impl Stream<Item = io::Result<Control>> {
349    let timer = tokio::time::interval(Duration::from_millis(50));
350    stream::unfold((timer, None), move |(mut timer, mut previous)| async move {
351        if !enabled {
352            return std::future::pending().await;
353        }
354        loop {
355            timer.tick().await;
356            let size = crossterm::terminal::size().unwrap_or((0, 0));
357            if previous != Some(size) {
358                previous = Some(size);
359                return Some((Ok(resize_control(size.0, size.1, true)), (timer, previous)));
360            }
361        }
362    })
363}
364
365fn visual_control(event: Event) -> Control {
366    if let Event::Resize(columns, rows) = event {
367        return resize_control(columns, rows, false);
368    }
369    if let Event::Key(key) = event
370        && key.kind != KeyEventKind::Release
371    {
372        if key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c') {
373            return Control::Cancel(130);
374        }
375        return match key.code {
376            KeyCode::Esc | KeyCode::Char('q') => Control::Cancel(130),
377            KeyCode::Up => Control::Redraw(-1),
378            KeyCode::Down => Control::Redraw(1),
379            KeyCode::PageUp => Control::Redraw(-10),
380            KeyCode::PageDown => Control::Redraw(10),
381            _ => Control::Redraw(0),
382        };
383    }
384    Control::Redraw(0)
385}
386
387async fn drive_visual<B: Backend>(
388    terminal: (&mut Terminal<B>, impl FnMut()),
389    view: &mut LifecycleView,
390    operation: impl Future<Output = RuntimeResult>,
391    cancel: &CancellationToken,
392    controls: impl Stream<Item = io::Result<Control>>,
393    events: Receiver<LifecycleEvent>,
394    diagnostics: &DiagnosticObserver,
395) -> io::Result<Outcome> {
396    let (terminal, mut restore) = terminal;
397    let period = Duration::from_millis(100);
398    let mut timer = tokio::time::interval_at(tokio::time::Instant::now() + period, period);
399    timer.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
400    let redraw = stream::unfold(timer, |mut timer| async {
401        timer.tick().await;
402        Some(((), timer))
403    });
404    let mut outcome = drive_with_redraw(
405        operation,
406        cancel,
407        controls,
408        Some(events),
409        |phase| {
410            if phase == Phase::Restore {
411                restore();
412                return Ok(());
413            }
414            view.update(phase);
415            terminal
416                .draw(|frame| view.render(frame, &diagnostics.snapshot()))
417                .map(|_| ())
418                .map_err(|error| io::Error::other(error.to_string()))
419        },
420        redraw,
421    )
422    .await?;
423    outcome.diagnostics = Some(diagnostics.snapshot());
424    Ok(outcome)
425}
426
427struct LifecycleView {
428    title: String,
429    phase: Phase,
430    history: VecDeque<LifecycleEvent>,
431    omitted_events: usize,
432    scroll: u16,
433    color: bool,
434}
435
436impl LifecycleView {
437    fn new(command: &str, target: &str, color: bool) -> Self {
438        let label = |text: &str| {
439            strip_control(&text.chars().take(1024).collect::<String>())
440                .chars()
441                .take(256)
442                .collect::<String>()
443        };
444        Self {
445            title: format!("{} / {}", label(command), label(target)),
446            phase: Phase::Running,
447            history: VecDeque::new(),
448            omitted_events: 0,
449            scroll: 0,
450            color,
451        }
452    }
453
454    fn update(&mut self, phase: Phase) {
455        match phase {
456            Phase::Event(event) => {
457                if self.history.len() == EVENT_CAPACITY {
458                    self.history.pop_front();
459                    self.omitted_events = self.omitted_events.saturating_add(1);
460                }
461                self.history.push_back(event);
462            }
463            Phase::Redraw(scroll) => self.scroll = self.scroll.saturating_add_signed(scroll),
464            phase => self.phase = phase,
465        }
466    }
467
468    fn render(&mut self, frame: &mut Frame<'_>, diagnostics: &DiagnosticSnapshot) {
469        let [header, status, current, body, footer] = Layout::vertical([
470            Constraint::Length(1),
471            Constraint::Length(2),
472            Constraint::Length(2),
473            Constraint::Min(0),
474            Constraint::Length(2),
475        ])
476        .areas(frame.area());
477        let accent = if self.color {
478            Style::default().fg(Color::Cyan)
479        } else {
480            Style::default()
481        };
482        frame.render_widget(
483            Paragraph::new(self.title.as_str()).style(accent.add_modifier(Modifier::BOLD)),
484            header,
485        );
486        let status_text = match self.phase {
487            Phase::Cancelling => {
488                "Cancellation requested. Waiting for runtime cleanup; effects not yet known."
489            }
490            Phase::Completed => "Runtime returned success. Final evidence follows.",
491            Phase::Failed => "Runtime returned an error. Cleanup success is not confirmed.",
492            _ => "Running. Observed stages are best-effort and may be incomplete.",
493        };
494        frame.render_widget(
495            Paragraph::new(status_text).wrap(Wrap { trim: false }),
496            status,
497        );
498        let latest = self
499            .history
500            .back()
501            .copied()
502            .map(event_text)
503            .unwrap_or_else(|| "No stage observed yet.".into());
504        frame.render_widget(Paragraph::new(latest).wrap(Wrap { trim: false }), current);
505        let mut text = diagnostics.text();
506        if self.omitted_events > 0 {
507            text.push_str(&format!(
508                "{} earlier stage observations omitted\n",
509                self.omitted_events
510            ));
511        }
512        text.push_str("Observed stages (newest first):\n");
513        for event in self.history.iter().rev() {
514            text.push_str(&event_text(*event));
515            text.push('\n');
516        }
517        let lines: Vec<_> = text
518            .lines()
519            .flat_map(|line| {
520                line.as_bytes()
521                    .chunks(usize::from(body.width.max(1)))
522                    .map(|chunk| String::from_utf8_lossy(chunk).into_owned())
523            })
524            .collect();
525        let maximum = lines.len().saturating_sub(usize::from(body.height));
526        self.scroll = self.scroll.min(u16::try_from(maximum).unwrap_or(u16::MAX));
527        frame.render_widget(
528            Paragraph::new(lines.join("\n")).scroll((self.scroll, 0)),
529            body,
530        );
531        frame.render_widget(Paragraph::new("Final result is authoritative, not stage completion.\nCtrl-C / Esc / q cancel; Up/Down scroll").style(accent), footer);
532    }
533}
534
535fn event_text(event: LifecycleEvent) -> String {
536    let scope = match event.scope {
537        LifecycleScope::Runtime => "Runtime",
538        LifecycleScope::AcquisitionDaemon => "Acquisition daemon",
539    };
540    let stage = match event.stage {
541        LifecycleStage::Acquisition => "Acquisition",
542        LifecycleStage::Verification => "Verification",
543        LifecycleStage::AcquisitionVerification => "Acquisition and verification",
544        LifecycleStage::Start => "Start/serve (may reuse a server)",
545        LifecycleStage::Attach => "Attach",
546        LifecycleStage::Activation => "Activation",
547        LifecycleStage::Readiness => "Readiness",
548        LifecycleStage::Stop => "Stop",
549    };
550    let status = match event.status {
551        LifecycleStatus::Started => "started",
552        LifecycleStatus::Completed => "completed",
553        LifecycleStatus::Failed => "failed",
554    };
555    format!("{scope} / {stage}: {status}")
556}
557
558fn write_phase(
559    output: &mut impl Write,
560    command: &str,
561    target: &str,
562    phase: Phase,
563) -> io::Result<()> {
564    match phase {
565        Phase::Running => writeln!(
566            output,
567            "{} / {}\nRunning. Observed stages are best-effort and may be incomplete.\nStage completion does not confirm command success or saved state; the final result is authoritative.\nCtrl-C cancels and waits for runtime cleanup.",
568            strip_control(command),
569            strip_control(target)
570        ),
571        Phase::Event(event) => writeln!(output, "{}", event_text(event)),
572        Phase::Redraw(_) => return Ok(()),
573        Phase::Cancelling => writeln!(
574            output,
575            "Cancellation requested. Waiting for the runtime to return; effects are not yet known."
576        ),
577        Phase::Restore => writeln!(
578            output,
579            "Terminal presentation ended; waiting for the runtime result."
580        ),
581        Phase::Completed => writeln!(output, "Runtime returned success. Final evidence follows."),
582        Phase::Failed => writeln!(output, "Runtime returned an error. Final evidence follows."),
583    }?;
584    output.flush()
585}
586
587pub fn evidence(outcome: &Outcome) -> String {
588    let mut text = match &outcome.result {
589        Ok((report, text)) => {
590            let mut lines: Vec<_> = text.lines().map(strip_control).collect();
591            for (field, label) in [
592                ("type", "Result"),
593                ("backend", "Backend"),
594                ("endpoint", "Endpoint"),
595                ("ownership", "Ownership"),
596                ("integrity", "Integrity"),
597            ] {
598                if let Some(value) = report.get(field).and_then(Value::as_str) {
599                    lines.push(format!("{label}: {}", strip_control(value)));
600                }
601            }
602            format!("{}\n", lines.join("\n"))
603        }
604        Err(error) => format!(
605            "Runtime error: {}\nEffects are unknown; rollback or cleanup success is not confirmed.\nInspect `llmup-native ls` and `llmup-native doctor` before deciding whether to retry.\nNo automatic retry or bypass was performed.\n",
606            strip_control(&error.to_string()),
607        ),
608    };
609    if [129, 130, 143].contains(&outcome.exit_code) {
610        text.push_str("\nCancellation was requested; the runtime result above is authoritative.\n");
611    }
612    if let Some(error) = &outcome.presentation_error {
613        text.push_str(&format!("\nPresentation error: {}\n", strip_control(error)));
614    }
615    if let Some(diagnostics) = &outcome.diagnostics {
616        let diagnostics = diagnostics.text();
617        if !diagnostics.is_empty() {
618            text.push_str("\nRuntime diagnostics:\n");
619            text.push_str(&diagnostics);
620        }
621    }
622    text
623}
624
625#[cfg(test)]
626mod tests {
627    use super::*;
628    use futures_util::stream;
629    use serde_json::json;
630    use std::cell::Cell;
631
632    #[tokio::test]
633    async fn visual_input_owner_drops_without_another_poll_and_eof_is_not_silenced() {
634        use std::sync::{
635            Arc, Mutex,
636            atomic::{AtomicBool, Ordering},
637        };
638        struct Input(Arc<AtomicBool>);
639        impl Stream for Input {
640            type Item = io::Result<Event>;
641            fn poll_next(
642                self: std::pin::Pin<&mut Self>,
643                _context: &mut std::task::Context<'_>,
644            ) -> std::task::Poll<Option<Self::Item>> {
645                std::task::Poll::Pending
646            }
647        }
648        impl Drop for Input {
649            fn drop(&mut self) {
650                self.0.store(true, Ordering::SeqCst);
651            }
652        }
653        let dropped = Arc::new(AtomicBool::new(false));
654        let owner = Arc::new(Mutex::new(Some(Input(dropped.clone()))));
655        let mut input = visual_input(owner.clone());
656        assert!(futures_util::poll!(input.next()).is_pending());
657        owner.lock().unwrap().take();
658        assert!(dropped.load(Ordering::SeqCst));
659        assert!(input.next().await.is_none());
660
661        let owner = Arc::new(Mutex::new(Some(stream::empty::<io::Result<Event>>())));
662        let mut input = visual_input(owner.clone());
663        assert!(matches!(input.next().await, Some(Err(_))));
664        assert!(owner.lock().unwrap().is_none());
665        assert!(input.next().await.is_none());
666    }
667
668    #[test]
669    fn resize_thresholds_preserve_visual_and_accessible_boundaries() {
670        for (accessible, width, height) in [(false, 60, 16), (true, 40, 10)] {
671            assert!(matches!(
672                resize_control(width, height, accessible),
673                Control::Resize { eligible: true }
674            ));
675            assert!(matches!(
676                resize_control(width - 1, height, accessible),
677                Control::Resize { eligible: false }
678            ));
679            assert!(matches!(
680                resize_control(width, height - 1, accessible),
681                Control::Resize { eligible: false }
682            ));
683        }
684    }
685
686    #[tokio::test]
687    async fn cleanup_deadline_restores_presentation_without_dropping_runtime() {
688        let cancel = CancellationToken::new();
689        let restored = Cell::new(false);
690        let finished = Cell::new(false);
691        let (release, released) = tokio::sync::oneshot::channel();
692        let mut release = Some(release);
693        let outcome = tokio::time::timeout(
694            Duration::from_secs(2),
695            drive_with_deadline(
696                async {
697                    cancel.cancelled().await;
698                    released.await.unwrap();
699                    assert!(restored.get());
700                    finished.set(true);
701                    Err(BackendError(
702                        "cleanup failed after terminal restoration".into(),
703                    ))
704                },
705                &cancel,
706                stream::iter([Ok(Control::Cancel(129))]),
707                None,
708                |phase| {
709                    if phase == Phase::Restore {
710                        assert!(!restored.replace(true));
711                        assert!(!finished.get());
712                        release.take().unwrap().send(()).unwrap();
713                    } else {
714                        assert!(!restored.get(), "redraw after restoration");
715                    }
716                    Ok(())
717                },
718                stream::pending(),
719                Duration::from_millis(5),
720            ),
721        )
722        .await
723        .unwrap()
724        .unwrap();
725        assert!(finished.get());
726        assert_eq!(outcome.exit_code, 129);
727        assert!(evidence(&outcome).contains("cleanup failed after terminal restoration"));
728    }
729
730    #[tokio::test]
731    async fn resize_fallback_is_debounced_and_does_not_cancel_runtime() {
732        let cancel = CancellationToken::new();
733        let (release, released) = tokio::sync::oneshot::channel();
734        let mut release = Some(release);
735        let controls = stream::iter([
736            Ok(resize_control(70, 20, false)),
737            Ok(resize_control(59, 20, false)),
738        ])
739        .chain(stream::pending());
740        let started = tokio::time::Instant::now();
741        let outcome = tokio::time::timeout(
742            Duration::from_secs(2),
743            drive(
744                async {
745                    released.await.unwrap();
746                    Ok((json!({}), "completed".into()))
747                },
748                &cancel,
749                controls,
750                None,
751                |phase| {
752                    if phase == Phase::Restore {
753                        assert!(!cancel.is_cancelled());
754                        assert!(started.elapsed() >= Duration::from_millis(50));
755                        release.take().unwrap().send(()).unwrap();
756                    }
757                    Ok(())
758                },
759            ),
760        )
761        .await
762        .unwrap()
763        .unwrap();
764        assert_eq!(outcome.exit_code, 0);
765        assert!(!cancel.is_cancelled());
766        assert!(outcome.presentation_restored);
767    }
768
769    #[tokio::test]
770    async fn recovered_size_cancels_pending_fallback_for_both_modes() {
771        for accessible in [false, true] {
772            let cancel = CancellationToken::new();
773            let controls = stream::iter([
774                Ok(resize_control(1, 1, accessible)),
775                Ok(resize_control(80, 24, accessible)),
776            ])
777            .chain(stream::pending());
778            let outcome = drive(
779                async {
780                    tokio::time::sleep(Duration::from_millis(65)).await;
781                    Ok((json!({}), String::new()))
782                },
783                &cancel,
784                controls,
785                None,
786                |phase| {
787                    assert_ne!(phase, Phase::Restore);
788                    Ok(())
789                },
790            )
791            .await
792            .unwrap();
793            assert!(!outcome.presentation_restored);
794            assert!(!cancel.is_cancelled());
795            assert_eq!(outcome.exit_code, 0);
796        }
797    }
798
799    #[tokio::test]
800    async fn signal_after_resize_restoration_still_cancels_without_second_restore() {
801        let cancel = CancellationToken::new();
802        let (notify, restored) = tokio::sync::oneshot::channel();
803        let mut notify = Some(notify);
804        let mut restoration_count = 0;
805        let controls =
806            stream::once(async { Ok(resize_control(1, 1, false)) }).chain(stream::once(async {
807                restored.await.unwrap();
808                Ok(Control::Cancel(143))
809            }));
810        let outcome = tokio::time::timeout(
811            Duration::from_secs(2),
812            drive(
813                async {
814                    cancel.cancelled().await;
815                    Err(BackendError("runtime cancelled after fallback".into()))
816                },
817                &cancel,
818                controls,
819                None,
820                |phase| {
821                    if phase == Phase::Restore {
822                        restoration_count += 1;
823                        notify.take().unwrap().send(()).unwrap();
824                    } else {
825                        assert_eq!(restoration_count, 0, "presentation after fallback");
826                    }
827                    Ok(())
828                },
829            ),
830        )
831        .await
832        .unwrap()
833        .unwrap();
834        assert_eq!(restoration_count, 1);
835        assert_eq!(outcome.exit_code, 143);
836        assert!(outcome.presentation_restored);
837        assert!(evidence(&outcome).contains("runtime cancelled after fallback"));
838    }
839
840    #[tokio::test]
841    async fn resize_during_cancellation_cannot_skip_cleanup_deadline() {
842        let cancel = CancellationToken::new();
843        let (release, released) = tokio::sync::oneshot::channel();
844        let mut release = Some(release);
845        let started = tokio::time::Instant::now();
846        let outcome = drive_with_deadline(
847            async {
848                released.await.unwrap();
849                Err(BackendError("cleanup result".into()))
850            },
851            &cancel,
852            stream::iter([Ok(Control::Cancel(143)), Ok(resize_control(1, 1, false))]),
853            None,
854            |phase| {
855                if phase == Phase::Restore {
856                    assert!(started.elapsed() >= Duration::from_millis(80));
857                    release.take().unwrap().send(()).unwrap();
858                }
859                Ok(())
860            },
861            stream::pending(),
862            Duration::from_millis(80),
863        )
864        .await
865        .unwrap();
866        assert_eq!(outcome.exit_code, 143);
867        assert!(outcome.presentation_restored);
868    }
869
870    #[tokio::test]
871    async fn visual_resize_releases_owner_and_retains_runtime_evidence() {
872        let cancel = CancellationToken::new();
873        let restored = Cell::new(false);
874        let (release, released) = tokio::sync::oneshot::channel();
875        let mut release = Some(release);
876        let (_sender, events) = tokio::sync::mpsc::channel(1);
877        let mut terminal = Terminal::new(ratatui::backend::TestBackend::new(80, 24)).unwrap();
878        let mut view = LifecycleView::new("up", "fixture", false);
879        let outcome = drive_visual(
880            (&mut terminal, || {
881                assert!(!restored.replace(true));
882                release.take().unwrap().send(()).unwrap();
883            }),
884            &mut view,
885            async {
886                released.await.unwrap();
887                assert!(!cancel.is_cancelled());
888                Ok((json!({"model":"fixture"}), "runtime complete".into()))
889            },
890            &cancel,
891            stream::once(async { Ok(resize_control(1, 1, false)) }).chain(stream::pending()),
892            events,
893            &DiagnosticObserver::default(),
894        )
895        .await
896        .unwrap();
897        assert!(restored.get());
898        assert!(outcome.presentation_restored);
899        assert_eq!(outcome.exit_code, 0);
900        assert!(evidence(&outcome).contains("runtime complete"));
901    }
902
903    #[tokio::test]
904    async fn fallback_notification_failure_keeps_runtime_alive_and_is_not_retried() {
905        let cancel = CancellationToken::new();
906        let (release, released) = tokio::sync::oneshot::channel();
907        let mut release = Some(release);
908        let outcome = drive(
909            async {
910                released.await.unwrap();
911                Ok((json!({}), "complete".into()))
912            },
913            &cancel,
914            stream::once(async { Ok(resize_control(1, 1, false)) }).chain(stream::pending()),
915            None,
916            |phase| {
917                if phase == Phase::Restore {
918                    release.take().unwrap().send(()).unwrap();
919                    return Err(io::Error::other("fallback output failed"));
920                }
921                Ok(())
922            },
923        )
924        .await
925        .unwrap();
926        assert!(!cancel.is_cancelled());
927        assert!(outcome.result.is_ok());
928        assert!(outcome.presentation_restored);
929        assert_eq!(
930            outcome.presentation_error.as_deref(),
931            Some("fallback output failed")
932        );
933    }
934
935    #[test]
936    fn visual_render_uses_only_observed_stages_and_bounds_history() {
937        let mut view = LifecycleView::new("up\u{1b}[31m", "model\nname", false);
938        let diagnostics = rigspark_runtime::application::events::DiagnosticObserver::default();
939        for _ in 0..100 {
940            view.update(Phase::Event(LifecycleEvent {
941                scope: LifecycleScope::AcquisitionDaemon,
942                stage: LifecycleStage::Stop,
943                status: LifecycleStatus::Failed,
944            }));
945        }
946        view.update(Phase::Cancelling);
947        assert_eq!(view.history.len(), 64);
948        assert_eq!(view.omitted_events, 36);
949        for (width, height) in [(100, 28), (24, 8), (1, 1)] {
950            let mut terminal =
951                ratatui::Terminal::new(ratatui::backend::TestBackend::new(width, height)).unwrap();
952            terminal
953                .draw(|frame| view.render(frame, &diagnostics.snapshot()))
954                .unwrap();
955            let text: String = terminal
956                .backend()
957                .buffer()
958                .content
959                .iter()
960                .map(|cell| cell.symbol())
961                .collect();
962            assert!(!text.contains("Readiness"));
963            assert!(!text.contains("100%"));
964            assert!(!text.contains("cleanup complete"));
965            assert!(!text.contains('\u{1b}'));
966            if width == 100 {
967                assert!(text.contains("Cancellation requested"));
968                assert!(text.contains("Acquisition daemon / Stop: failed"));
969                assert!(text.contains("36 earlier stage observations omitted"));
970            }
971        }
972    }
973
974    #[tokio::test]
975    async fn visual_redraw_and_scroll_do_not_cancel_and_cleanup_is_awaited() {
976        let cancel = CancellationToken::new();
977        let cleaned = Cell::new(false);
978        let mut phases = Vec::new();
979        let outcome = drive(
980            async {
981                cancel.cancelled().await;
982                tokio::task::yield_now().await;
983                cleaned.set(true);
984                Err(BackendError("cleanup failed".into()))
985            },
986            &cancel,
987            stream::iter([Ok(Control::Redraw(1)), Ok(Control::Cancel(130))]),
988            None,
989            |phase| {
990                if matches!(phase, Phase::Redraw(_)) {
991                    assert!(!cancel.is_cancelled());
992                }
993                phases.push(phase);
994                Ok(())
995            },
996        )
997        .await
998        .unwrap();
999        assert!(cleaned.get());
1000        assert_eq!(outcome.exit_code, 130);
1001        assert_eq!(
1002            phases,
1003            [
1004                Phase::Running,
1005                Phase::Redraw(1),
1006                Phase::Cancelling,
1007                Phase::Failed
1008            ]
1009        );
1010        assert!(evidence(&outcome).contains("cleanup failed"));
1011    }
1012
1013    #[tokio::test]
1014    async fn hangup_cancels_once_waits_for_cleanup_and_normal_completion_does_not_abort() {
1015        let cancel = CancellationToken::new();
1016        let cleaned = Cell::new(false);
1017        let mut cancellations = 0;
1018        let outcome = drive(
1019            async {
1020                cancel.cancelled().await;
1021                tokio::task::yield_now().await;
1022                cleaned.set(true);
1023                Err(BackendError("cancelled after cleanup".into()))
1024            },
1025            &cancel,
1026            stream::iter([Ok(Control::Cancel(129)), Ok(Control::Cancel(143))]),
1027            None,
1028            |phase| {
1029                if phase == Phase::Cancelling {
1030                    cancellations += 1;
1031                }
1032                if phase == Phase::Failed {
1033                    assert!(cleaned.get());
1034                }
1035                Ok(())
1036            },
1037        )
1038        .await
1039        .unwrap();
1040        assert!(cleaned.get());
1041        assert_eq!(cancellations, 1);
1042        assert_eq!(outcome.exit_code, 129);
1043        assert!(evidence(&outcome).contains("Cancellation was requested"));
1044
1045        let cancel = CancellationToken::new();
1046        let outcome = drive(
1047            async { Ok((serde_json::json!({}), String::new())) },
1048            &cancel,
1049            stream::pending(),
1050            None,
1051            |_| Ok(()),
1052        )
1053        .await
1054        .unwrap();
1055        assert_eq!(outcome.exit_code, 0);
1056        assert!(!cancel.is_cancelled());
1057    }
1058
1059    #[tokio::test]
1060    async fn visual_cleanup_redraw_failure_preserves_signal_and_awaits_result() {
1061        let cancel = CancellationToken::new();
1062        let cleaned = Cell::new(false);
1063        let (acknowledge, acknowledged) = tokio::sync::oneshot::channel();
1064        let mut acknowledge = Some(acknowledge);
1065        let outcome = drive_with_redraw(
1066            async {
1067                acknowledged.await.unwrap();
1068                assert!(cancel.is_cancelled());
1069                cleaned.set(true);
1070                Err(BackendError("cleanup failed".into()))
1071            },
1072            &cancel,
1073            stream::iter([Ok(Control::Cancel(143))]),
1074            None,
1075            |phase| {
1076                if phase == Phase::Redraw(0) {
1077                    acknowledge.take().unwrap().send(()).unwrap();
1078                    Err(io::Error::other("redraw failed"))
1079                } else {
1080                    Ok(())
1081                }
1082            },
1083            stream::once(async { cancel.cancelled().await }),
1084        )
1085        .await
1086        .unwrap();
1087        assert!(cleaned.get());
1088        assert_eq!(outcome.exit_code, 143);
1089        assert!(evidence(&outcome).contains("cleanup failed"));
1090        assert!(evidence(&outcome).contains("redraw failed"));
1091    }
1092
1093    #[test]
1094    fn visual_keys_cancel_without_treating_release_resize_or_paste_as_interrupts() {
1095        use crossterm::event::{KeyEvent, KeyEventKind};
1096        for key in [
1097            KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),
1098            KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE),
1099            KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE),
1100        ] {
1101            assert!(matches!(
1102                visual_control(Event::Key(key)),
1103                Control::Cancel(130)
1104            ));
1105            assert!(matches!(
1106                visual_control(Event::Key(KeyEvent {
1107                    kind: KeyEventKind::Release,
1108                    ..key
1109                })),
1110                Control::Redraw(0)
1111            ));
1112        }
1113        assert!(matches!(
1114            visual_control(Event::Resize(10, 4)),
1115            Control::Resize { eligible: false }
1116        ));
1117        assert!(matches!(
1118            visual_control(Event::Paste("q\u{3}".into())),
1119            Control::Redraw(0)
1120        ));
1121    }
1122
1123    #[tokio::test]
1124    async fn visual_driver_drains_real_events_and_retains_diagnostic_snapshot() {
1125        let (sender, receiver) = tokio::sync::mpsc::channel(64);
1126        let mut terminal = Terminal::new(ratatui::backend::TestBackend::new(100, 28)).unwrap();
1127        let mut view = LifecycleView::new("down", "model", false);
1128        let diagnostics = DiagnosticObserver::default();
1129        let outcome = drive_visual(
1130            (&mut terminal, || {}),
1131            &mut view,
1132            async {
1133                sender
1134                    .try_send(LifecycleEvent {
1135                        scope: LifecycleScope::Runtime,
1136                        stage: LifecycleStage::Stop,
1137                        status: LifecycleStatus::Failed,
1138                    })
1139                    .unwrap();
1140                Err(BackendError("stop failed".into()))
1141            },
1142            &CancellationToken::new(),
1143            stream::pending(),
1144            receiver,
1145            &diagnostics,
1146        )
1147        .await
1148        .unwrap();
1149        assert_eq!(outcome.exit_code, 1);
1150        assert!(outcome.diagnostics.is_some());
1151        let text: String = terminal
1152            .backend()
1153            .buffer()
1154            .content
1155            .iter()
1156            .map(|cell| cell.symbol())
1157            .collect();
1158        assert!(text.contains("Runtime / Stop: failed"));
1159        assert!(text.contains("Cleanup success is not confirmed"));
1160        assert!(evidence(&outcome).contains("stop failed"));
1161    }
1162
1163    #[tokio::test]
1164    async fn completion_drains_events_in_order_without_waiting_for_held_sender() {
1165        let (sender, receiver) = tokio::sync::mpsc::channel(64);
1166        let started = LifecycleEvent {
1167            scope: LifecycleScope::Runtime,
1168            stage: LifecycleStage::Readiness,
1169            status: LifecycleStatus::Started,
1170        };
1171        let completed = LifecycleEvent {
1172            status: LifecycleStatus::Completed,
1173            ..started
1174        };
1175        sender.try_send(started).unwrap();
1176        let mut phases = Vec::new();
1177        let cancel = CancellationToken::new();
1178        let outcome = tokio::time::timeout(
1179            std::time::Duration::from_secs(1),
1180            drive(
1181                async {
1182                    sender.try_send(completed).unwrap();
1183                    Ok((json!({"type":"ready"}), "Ready.\n".into()))
1184                },
1185                &cancel,
1186                stream::pending(),
1187                Some(receiver),
1188                |phase| {
1189                    phases.push(phase);
1190                    Ok(())
1191                },
1192            ),
1193        )
1194        .await
1195        .expect("must not wait for the sender to drop")
1196        .unwrap();
1197        assert_eq!(outcome.exit_code, 0);
1198        assert_eq!(
1199            phases,
1200            [
1201                Phase::Running,
1202                Phase::Event(started),
1203                Phase::Event(completed),
1204                Phase::Completed,
1205            ]
1206        );
1207    }
1208
1209    #[test]
1210    fn labels_preserve_scope_stage_and_status_without_claiming_command_success() {
1211        for (scope, scope_label) in [
1212            (LifecycleScope::Runtime, "Runtime"),
1213            (LifecycleScope::AcquisitionDaemon, "Acquisition daemon"),
1214        ] {
1215            for (stage, stage_label) in [
1216                (LifecycleStage::Acquisition, "Acquisition"),
1217                (LifecycleStage::Verification, "Verification"),
1218                (
1219                    LifecycleStage::AcquisitionVerification,
1220                    "Acquisition and verification",
1221                ),
1222                (LifecycleStage::Start, "Start/serve (may reuse a server)"),
1223                (LifecycleStage::Attach, "Attach"),
1224                (LifecycleStage::Activation, "Activation"),
1225                (LifecycleStage::Readiness, "Readiness"),
1226                (LifecycleStage::Stop, "Stop"),
1227            ] {
1228                for (status, status_label) in [
1229                    (LifecycleStatus::Started, "started"),
1230                    (LifecycleStatus::Completed, "completed"),
1231                    (LifecycleStatus::Failed, "failed"),
1232                ] {
1233                    let mut output = Vec::new();
1234                    write_phase(
1235                        &mut output,
1236                        "up",
1237                        "model",
1238                        Phase::Event(LifecycleEvent {
1239                            scope,
1240                            stage,
1241                            status,
1242                        }),
1243                    )
1244                    .unwrap();
1245                    assert_eq!(
1246                        String::from_utf8(output).unwrap(),
1247                        format!("{scope_label} / {stage_label}: {status_label}\n")
1248                    );
1249                }
1250            }
1251        }
1252        let mut output = Vec::new();
1253        write_phase(&mut output, "up\u{1b}[31m", "model\nname", Phase::Running).unwrap();
1254        let text = String::from_utf8(output).unwrap();
1255        assert!(!text.contains('\u{1b}'));
1256        assert!(text.contains("best-effort and may be incomplete"));
1257        assert!(text.contains("does not confirm command success or saved state"));
1258    }
1259
1260    #[tokio::test]
1261    async fn events_are_presented_live_and_failure_is_drained_before_recovery() {
1262        let cancel = CancellationToken::new();
1263        let (sender, receiver) = tokio::sync::mpsc::channel(64);
1264        let (acknowledge, acknowledged) = tokio::sync::oneshot::channel();
1265        let mut acknowledge = Some(acknowledge);
1266        let started = LifecycleEvent {
1267            scope: LifecycleScope::Runtime,
1268            stage: LifecycleStage::Verification,
1269            status: LifecycleStatus::Started,
1270        };
1271        let mut output = Vec::new();
1272        let outcome = tokio::time::timeout(
1273            std::time::Duration::from_secs(1),
1274            drive(
1275                async {
1276                    sender.try_send(started).unwrap();
1277                    acknowledged.await.unwrap();
1278                    sender
1279                        .try_send(LifecycleEvent {
1280                            status: LifecycleStatus::Failed,
1281                            ..started
1282                        })
1283                        .unwrap();
1284                    Err(BackendError("verification failed".into()))
1285                },
1286                &cancel,
1287                stream::pending(),
1288                Some(receiver),
1289                |phase| {
1290                    write_phase(&mut output, "up", "model", phase)?;
1291                    if phase == Phase::Event(started) {
1292                        acknowledge.take().unwrap().send(()).unwrap();
1293                    }
1294                    Ok(())
1295                },
1296            ),
1297        )
1298        .await
1299        .expect("started must be presented before the operation completes")
1300        .unwrap();
1301        let text = String::from_utf8(output).unwrap();
1302        assert!(text.ends_with("Runtime / Verification: started\nRuntime / Verification: failed\nRuntime returned an error. Final evidence follows.\n"));
1303        assert_eq!(outcome.exit_code, 1);
1304        assert!(evidence(&outcome).contains("Effects are unknown"));
1305        assert!(!cancel.is_cancelled());
1306    }
1307
1308    #[tokio::test]
1309    async fn signal_has_priority_and_cleanup_events_remain_live_until_completion() {
1310        for code in [130, 143] {
1311            let cancel = CancellationToken::new();
1312            let (sender, receiver) = tokio::sync::mpsc::channel(64);
1313            let (acknowledge, acknowledged) = tokio::sync::oneshot::channel();
1314            let mut acknowledge = Some(acknowledge);
1315            let event = LifecycleEvent {
1316                scope: LifecycleScope::AcquisitionDaemon,
1317                stage: LifecycleStage::Stop,
1318                status: LifecycleStatus::Started,
1319            };
1320            let completed = LifecycleEvent {
1321                status: LifecycleStatus::Completed,
1322                ..event
1323            };
1324            sender.try_send(event).unwrap();
1325            let mut phases = Vec::new();
1326            let outcome = tokio::time::timeout(
1327                std::time::Duration::from_secs(1),
1328                drive(
1329                    async {
1330                        assert!(cancel.is_cancelled());
1331                        acknowledged.await.unwrap();
1332                        sender.try_send(completed).unwrap();
1333                        Ok((json!({"type":"stopped"}), "Stopped.\n".into()))
1334                    },
1335                    &cancel,
1336                    stream::iter([Ok(Control::Cancel(code))]),
1337                    Some(receiver),
1338                    |phase| {
1339                        phases.push(phase);
1340                        if phase == Phase::Event(event) {
1341                            acknowledge.take().unwrap().send(()).unwrap();
1342                        }
1343                        Ok(())
1344                    },
1345                ),
1346            )
1347            .await
1348            .expect("cleanup events must remain live after cancellation")
1349            .unwrap();
1350            assert_eq!(outcome.exit_code, code);
1351            assert!(outcome.result.is_ok());
1352            assert_eq!(
1353                phases,
1354                [
1355                    Phase::Running,
1356                    Phase::Cancelling,
1357                    Phase::Event(event),
1358                    Phase::Event(completed),
1359                    Phase::Completed
1360                ]
1361            );
1362        }
1363    }
1364
1365    #[tokio::test]
1366    async fn event_sink_failure_cancels_and_awaits_cleanup_without_masking_later_signal() {
1367        for signal in [false, true] {
1368            let cancel = CancellationToken::new();
1369            let cleaned = Cell::new(false);
1370            let writes = Cell::new(0);
1371            let (sender, receiver) = tokio::sync::mpsc::channel(64);
1372            let event = LifecycleEvent {
1373                scope: LifecycleScope::Runtime,
1374                stage: LifecycleStage::Readiness,
1375                status: LifecycleStatus::Started,
1376            };
1377            let outcome = tokio::time::timeout(
1378                std::time::Duration::from_secs(1),
1379                drive(
1380                    async {
1381                        sender.try_send(event).unwrap();
1382                        cancel.cancelled().await;
1383                        sender
1384                            .try_send(LifecycleEvent {
1385                                stage: LifecycleStage::Stop,
1386                                ..event
1387                            })
1388                            .unwrap();
1389                        tokio::task::yield_now().await;
1390                        cleaned.set(true);
1391                        Ok((json!({"type":"stopped"}), "Stopped.\n".into()))
1392                    },
1393                    &cancel,
1394                    stream::once(async {
1395                        if !signal {
1396                            std::future::pending::<()>().await;
1397                        }
1398                        cancel.cancelled().await;
1399                        Ok(Control::Cancel(143))
1400                    }),
1401                    Some(receiver),
1402                    |phase| {
1403                        writes.set(writes.get() + 1);
1404                        if matches!(phase, Phase::Event(_)) {
1405                            Err(io::Error::other("event sink failed"))
1406                        } else {
1407                            Ok(())
1408                        }
1409                    },
1410                ),
1411            )
1412            .await
1413            .expect("sink failure must cancel and await the operation")
1414            .unwrap();
1415            assert!(cleaned.get());
1416            assert!(cancel.is_cancelled());
1417            assert_eq!(writes.get(), 2);
1418            assert_eq!(outcome.exit_code, if signal { 143 } else { 1 });
1419            assert_eq!(outcome.result.as_ref().unwrap().0["type"], "stopped");
1420            assert!(evidence(&outcome).contains("Presentation error: event sink failed"));
1421        }
1422    }
1423
1424    #[test]
1425    fn closed_event_channel_does_not_spin_or_end_the_operation() {
1426        use std::task::{Context, Poll};
1427        let (observer, receiver) =
1428            rigspark_runtime::application::events::LifecycleObserver::channel();
1429        drop(observer);
1430        let cancel = CancellationToken::new();
1431        let polls = Cell::new(0);
1432        let complete = Cell::new(false);
1433        let operation = std::future::poll_fn(|_| {
1434            polls.set(polls.get() + 1);
1435            assert!(
1436                polls.get() <= 3,
1437                "closed event input must not repeatedly poll the operation"
1438            );
1439            if complete.get() {
1440                Poll::Ready(Ok((json!({}), String::new())))
1441            } else {
1442                Poll::Pending
1443            }
1444        });
1445        let mut controller = std::pin::pin!(drive(
1446            operation,
1447            &cancel,
1448            stream::pending(),
1449            Some(receiver),
1450            |_| Ok(())
1451        ));
1452        let mut context = Context::from_waker(futures_util::task::noop_waker_ref());
1453        assert!(controller.as_mut().poll(&mut context).is_pending());
1454        complete.set(true);
1455        let Poll::Ready(Ok(outcome)) = controller.as_mut().poll(&mut context) else {
1456            panic!("operation completion must end the controller");
1457        };
1458        assert_eq!(outcome.exit_code, 0);
1459    }
1460
1461    #[tokio::test]
1462    async fn cancellation_waits_for_runtime_and_preserves_signal_exit() {
1463        for code in [130, 143] {
1464            let cancel = CancellationToken::new();
1465            let cleaned = Cell::new(false);
1466            let mut phases = Vec::new();
1467            let result = drive(
1468                async {
1469                    cancel.cancelled().await;
1470                    cleaned.set(true);
1471                    Err(BackendError("runtime stopped after cleanup".into()))
1472                },
1473                &cancel,
1474                stream::iter([Ok(Control::Cancel(code))]),
1475                None,
1476                |phase| {
1477                    phases.push(phase);
1478                    Ok(())
1479                },
1480            )
1481            .await
1482            .unwrap();
1483            assert!(cleaned.get());
1484            assert_eq!(result.exit_code, code);
1485            assert!(result.result.is_err());
1486            assert_eq!(phases, [Phase::Running, Phase::Cancelling, Phase::Failed]);
1487        }
1488    }
1489
1490    #[tokio::test]
1491    async fn success_after_cancellation_is_not_reported_as_rollback() {
1492        let cancel = CancellationToken::new();
1493        let result = drive(
1494            async {
1495                cancel.cancelled().await;
1496                Ok((json!({"type":"switched"}), "Switched.\n".into()))
1497            },
1498            &cancel,
1499            stream::iter([Ok(Control::Cancel(130))]),
1500            None,
1501            |_| Ok(()),
1502        )
1503        .await
1504        .unwrap();
1505        assert_eq!(result.exit_code, 130);
1506        assert_eq!(result.result.unwrap().0["type"], "switched");
1507    }
1508
1509    #[tokio::test]
1510    async fn display_failure_before_execution_does_not_poll_runtime() {
1511        let polled = Cell::new(false);
1512        let result = drive(
1513            async {
1514                polled.set(true);
1515                Ok((json!({}), String::new()))
1516            },
1517            &CancellationToken::new(),
1518            stream::pending(),
1519            None,
1520            |_| Err(io::Error::other("display unavailable")),
1521        )
1522        .await;
1523        assert!(result.is_err());
1524        assert!(!polled.get());
1525    }
1526
1527    #[tokio::test]
1528    async fn input_failure_cancels_once_and_drains_runtime() {
1529        let cancel = CancellationToken::new();
1530        let calls = Cell::new(0);
1531        let result = drive(
1532            async {
1533                calls.set(calls.get() + 1);
1534                cancel.cancelled().await;
1535                Err(BackendError("cleanup result".into()))
1536            },
1537            &cancel,
1538            stream::iter([Err(io::Error::other("input failed"))]),
1539            None,
1540            |_| Ok(()),
1541        )
1542        .await
1543        .unwrap();
1544        assert_eq!(calls.get(), 1);
1545        assert_eq!(result.exit_code, 1);
1546        assert!(result.presentation_error.is_some());
1547    }
1548
1549    #[tokio::test]
1550    async fn final_display_failure_preserves_success_without_retry() {
1551        let calls = Cell::new(0);
1552        let cancel = CancellationToken::new();
1553        let result = drive(
1554            async {
1555                calls.set(calls.get() + 1);
1556                Ok((json!({"type":"stopped"}), "Stopped.\n".into()))
1557            },
1558            &cancel,
1559            stream::pending(),
1560            None,
1561            |phase| {
1562                if phase == Phase::Completed {
1563                    Err(io::Error::other("display failed"))
1564                } else {
1565                    Ok(())
1566                }
1567            },
1568        )
1569        .await
1570        .unwrap();
1571        assert_eq!(calls.get(), 1);
1572        assert_eq!(result.exit_code, 1);
1573        assert_eq!(result.result.as_ref().unwrap().0["type"], "stopped");
1574        assert!(evidence(&result).contains("Presentation error: display failed"));
1575        assert!(!cancel.is_cancelled());
1576    }
1577
1578    #[tokio::test]
1579    async fn unexpected_control_exit_cancels_and_waits_for_runtime_cleanup() {
1580        let cancel = CancellationToken::new();
1581        let cleaned = Cell::new(false);
1582        let result = tokio::time::timeout(
1583            Duration::from_secs(1),
1584            drive(
1585                async {
1586                    cancel.cancelled().await;
1587                    cleaned.set(true);
1588                    Err(BackendError("cleanup finished".into()))
1589                },
1590                &cancel,
1591                stream::empty(),
1592                None,
1593                |_| Ok(()),
1594            ),
1595        )
1596        .await
1597        .unwrap()
1598        .unwrap();
1599        assert!(cleaned.get());
1600        assert_eq!(result.exit_code, 1);
1601        assert_eq!(
1602            result.presentation_error.as_deref(),
1603            Some("lifecycle control input ended")
1604        );
1605        assert!(
1606            result
1607                .result
1608                .unwrap_err()
1609                .to_string()
1610                .contains("cleanup finished")
1611        );
1612    }
1613
1614    #[tokio::test]
1615    async fn cancellation_display_failure_does_not_mask_termination_or_cleanup() {
1616        let cancel = CancellationToken::new();
1617        let result = drive(
1618            async {
1619                cancel.cancelled().await;
1620                Err(BackendError("runtime cleanup failed".into()))
1621            },
1622            &cancel,
1623            stream::iter([Ok(Control::Cancel(143))]),
1624            None,
1625            |phase| {
1626                if phase == Phase::Cancelling {
1627                    Err(io::Error::other("display failed"))
1628                } else {
1629                    Ok(())
1630                }
1631            },
1632        )
1633        .await
1634        .unwrap();
1635        assert_eq!(result.exit_code, 143);
1636        assert!(evidence(&result).contains("runtime cleanup failed"));
1637        assert!(evidence(&result).contains("Effects are unknown"));
1638    }
1639
1640    #[tokio::test]
1641    async fn runtime_failure_is_not_retried_or_reclassified_as_clean_cancellation() {
1642        let mut phases = Vec::new();
1643        let result = drive(
1644            async { Err(BackendError("integrity mismatch\u{1b}[31m".into())) },
1645            &CancellationToken::new(),
1646            stream::pending(),
1647            None,
1648            |phase| {
1649                phases.push(phase);
1650                Ok(())
1651            },
1652        )
1653        .await
1654        .unwrap();
1655        assert_eq!(result.exit_code, 1);
1656        assert_eq!(phases, [Phase::Running, Phase::Failed]);
1657        let text = evidence(&result);
1658        assert!(text.contains("integrity mismatch\n"));
1659        assert!(text.contains("Effects are unknown"));
1660        assert!(text.contains("llmup-native doctor"));
1661        assert!(!text.contains('\u{1b}'));
1662        assert!(!text.contains("Cancellation was requested"));
1663    }
1664
1665    #[test]
1666    fn evidence_preserves_lines_and_only_displays_returned_fields() {
1667        let result = Outcome {
1668            result: Ok((
1669                json!({
1670                    "backend": "ollama", "ownership": "attached", "integrity": "size-only"
1671                }),
1672                "Model ready\nRuntime model: test\u{1b}[31m\n".into(),
1673            )),
1674            exit_code: 0,
1675            presentation_error: None,
1676            diagnostics: None,
1677            presentation_restored: false,
1678        };
1679        let text = evidence(&result);
1680        assert!(text.contains("Model ready\nRuntime model: test\n"));
1681        assert!(text.contains("Ownership: attached\nIntegrity: size-only\n"));
1682        assert!(!text.contains("verified"));
1683        assert!(!text.contains("Endpoint:"));
1684        assert!(!text.contains("%"));
1685        assert!(!text.contains('\u{1b}'));
1686    }
1687}