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}