Report terminal completion states and blocking reasons (#54114)

## Why

Terminal status previously collapsed completed and failed turns into `idle` and reported blocking prompts without a reason. Blocking detection also depended on terminal title settings.

## What changed

- Emit `done` and `error` through OSC 7501 for live turn results, retaining them until deliberate keyboard, paste, or mouse input acknowledges them. Mouse movement does not acknowledge results.
- Classify blocking requests with `kind=permission`, `kind=question`, or `kind=auth`, including requests hidden behind another view or delayed while typing, independently of terminal title settings.
- Keep pending follow-up work and active goals `working`. Treat interrupted turns and replayed results as `idle` rather than new results.
- Preserve the existing iTerm2 OSC 21337 labels and indicators, mapping `done` and `error` to `Idle`.

## Testing

Add lifecycle and input-acknowledgment tests covering approvals, completion, failure, interruption, replay, pending follow-ups, and active goals. Extend blocking-request assertions and terminal protocol snapshots for the new states and reasons.

GitOrigin-RevId: 90bad1d54d8b3b9e3cec66fbd3bf3df0c42b995b
This commit is contained in:
Channing Conger
2026-10-14 22:58:37 +00:00
committed by copyberry
parent e1e2257e29
commit dec54912f9
20 changed files with 441 additions and 58 deletions
@@ -313,6 +313,11 @@ impl ChatWidget {
self.requeue_image_submission();
// Finalize, log a gentle prompt, and clear running state.
self.finalize_turn();
// Cancellation means idle in the program-status protocol, not a failed task.
if reason == TurnAbortReason::Interrupted {
self.status_state.program_status_after_turn =
crate::terminal_program_status::ProgramStatus::Idle;
}
let send_pending_steers_immediately =
self.input_queue.submit_pending_steers_after_interrupt;
self.input_queue.submit_pending_steers_after_interrupt = false;
@@ -1,6 +1,7 @@
//! Status indicator and terminal-title state for `ChatWidget`.
use crate::status_indicator_widget::STATUS_DETAILS_DEFAULT_MAX_LINES;
use crate::terminal_program_status::ProgramStatus;
#[derive(Clone, Debug, PartialEq, Eq)]
pub(super) struct StatusIndicatorState {
@@ -120,6 +121,9 @@ pub(super) struct StatusState {
pub(super) current_status: StatusIndicatorState,
pub(super) pending_guardian_review_status: PendingGuardianReviewStatus,
pub(super) terminal_title_status_kind: TerminalTitleStatusKind,
/// Result of the latest live turn until the user interacts again. Active
/// work and blocking prompts take precedence over this value.
pub(super) program_status_after_turn: ProgramStatus,
pub(super) retry_status_header: Option<String>,
pub(super) pending_status_indicator_restore: bool,
pub(super) thread_title_generation_pending: bool,
@@ -135,6 +139,7 @@ impl Default for StatusState {
current_status: StatusIndicatorState::working(),
pending_guardian_review_status: PendingGuardianReviewStatus::default(),
terminal_title_status_kind: TerminalTitleStatusKind::Working,
program_status_after_turn: ProgramStatus::Idle,
retry_status_header: None,
pending_status_indicator_restore: false,
thread_title_generation_pending: false,
+25 -5
View File
@@ -322,13 +322,33 @@ impl ChatWidget {
self.bottom_pane.terminal_title_requires_action()
}
pub(super) fn desired_program_status(&self) -> ProgramStatus {
if self.terminal_title_requires_action() {
ProgramStatus::Blocked
} else if self.bottom_pane.is_task_running() || !self.unified_exec_processes.is_empty() {
/// Reports the displayed thread's actual state independently of terminal
/// title/notification settings. Replays never produce an unseen result.
pub(crate) fn desired_program_status(&self) -> ProgramStatus {
if let Some(kind) = self.bottom_pane.program_status_blocked_kind() {
ProgramStatus::Blocked(kind)
} else if self.bottom_pane.is_task_running()
|| self.is_user_turn_pending_or_running()
|| !self.unified_exec_processes.is_empty()
|| (self.status_state.program_status_after_turn == ProgramStatus::Done
&& self
.current_goal_status
.as_ref()
.is_some_and(GoalStatusState::is_active))
{
ProgramStatus::Working
} else {
ProgramStatus::Idle
self.status_state.program_status_after_turn
}
}
pub(crate) fn acknowledge_program_status(&mut self) {
if matches!(
self.desired_program_status(),
ProgramStatus::Done | ProgramStatus::Error
) {
self.status_state.program_status_after_turn = ProgramStatus::Idle;
self.request_redraw();
}
}
+2
View File
@@ -275,6 +275,8 @@ mod plan_mode;
#[path = "tests/plugin_catalog_tests.rs"]
mod plugin_catalog;
mod popups_and_settings;
#[path = "tests/program_status.rs"]
mod program_status;
#[path = "tests/rate_limit_recovery_tests.rs"]
mod rate_limit_recovery_tests;
#[path = "tests/reasoning_status_tests.rs"]
@@ -0,0 +1,101 @@
//! Exercises terminal status across live, interrupted, and replayed turns.
//! Replayed results and work already underway must never appear as new completions.
use super::*;
use crate::terminal_program_status::ProgramStatus;
use crate::terminal_program_status::ProgramStatusKind;
use pretty_assertions::assert_eq;
#[tokio::test]
async fn program_status_tracks_live_results_and_resolved_approvals() {
let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
let mut statuses = vec![chat.desired_program_status()];
handle_turn_started(&mut chat, "status-turn");
statuses.push(chat.desired_program_status());
handle_exec_approval_request(
&mut chat,
"status-approval",
ExecApprovalRequestEvent {
kind: Default::default(),
call_id: "status-call".to_string(),
approval_id: Some("status-call".to_string()),
turn_id: "status-turn".to_string(),
environment_id: None,
command: vec!["echo".to_string(), "hello".to_string()],
cwd: AbsolutePathBuf::current_dir().expect("current dir"),
reason: Some("need confirmation".to_string()),
network_approval_context: None,
proposed_execpolicy_amendment: None,
proposed_network_policy_amendments: None,
additional_permissions: None,
available_decisions: None,
},
);
statuses.push(chat.desired_program_status());
chat.handle_key_event(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
statuses.push(chat.desired_program_status());
handle_turn_completed(&mut chat, "status-turn", /*duration_ms*/ None);
statuses.push(chat.desired_program_status());
chat.pre_draw_tick();
statuses.push(chat.desired_program_status());
chat.acknowledge_program_status();
statuses.push(chat.desired_program_status());
handle_turn_started(&mut chat, "cancelled-turn");
handle_turn_interrupted(&mut chat, "cancelled-turn");
statuses.push(chat.desired_program_status());
handle_turn_started(&mut chat, "failed-turn");
chat.handle_server_notification(
ServerNotification::TurnCompleted(TurnCompletedNotification {
thread_id: String::new(),
turn: app_server_turn(
"failed-turn",
AppServerTurnStatus::Failed,
/*duration_ms*/ None,
/*error*/ None,
),
}),
/*replay_kind*/ None,
);
statuses.push(chat.desired_program_status());
chat.acknowledge_program_status();
statuses.push(chat.desired_program_status());
assert_eq!(
statuses,
[
ProgramStatus::Idle,
ProgramStatus::Working,
ProgramStatus::Blocked(ProgramStatusKind::Permission),
ProgramStatus::Working,
ProgramStatus::Done,
ProgramStatus::Done,
ProgramStatus::Idle,
ProgramStatus::Idle,
ProgramStatus::Error,
ProgramStatus::Idle,
]
);
}
#[tokio::test]
async fn program_status_does_not_treat_replayed_results_as_new_or_hide_follow_up_work() {
let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
handle_turn_started(&mut chat, "old-turn");
chat.on_task_complete(
/*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ true,
);
let replayed = chat.desired_program_status();
handle_turn_started(&mut chat, "live-turn");
handle_turn_completed(&mut chat, "live-turn", /*duration_ms*/ None);
let completed = chat.desired_program_status();
// A queued follow-up is already submitted, before its TurnStarted notification arrives.
chat.input_queue.user_turn_pending_start = true;
let pending = chat.desired_program_status();
assert_eq!(
[replayed, completed, pending],
[
ProgramStatus::Idle,
ProgramStatus::Done,
ProgramStatus::Working
]
);
}
@@ -2263,6 +2263,37 @@ async fn ctrl_c_interrupt_pauses_active_goal_turn() {
assert_goal_paused_event(&mut rx, thread_id);
}
#[tokio::test]
async fn program_status_stays_working_when_input_acknowledges_an_active_goal() {
use crate::terminal_program_status::ProgramStatus;
let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
let thread_id = start_active_goal_turn(&mut chat);
let mut statuses = vec![chat.desired_program_status()];
chat.on_task_complete(
/*last_agent_message*/ None, /*completion*/ None, /*from_replay*/ false,
);
statuses.push(chat.desired_program_status());
// App acknowledges input before the composer handles a non-interrupting key.
chat.acknowledge_program_status();
chat.handle_key_event(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE));
statuses.push(chat.desired_program_status());
update_thread_goal(&mut chat, thread_id, AppThreadGoalStatus::Complete);
statuses.push(chat.desired_program_status());
chat.acknowledge_program_status();
statuses.push(chat.desired_program_status());
assert_eq!(
statuses,
[
ProgramStatus::Working,
ProgramStatus::Working,
ProgramStatus::Working,
ProgramStatus::Done,
ProgramStatus::Idle,
]
);
}
#[tokio::test]
async fn esc_interrupt_pauses_active_goal_turn() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
@@ -4,6 +4,7 @@ use pretty_assertions::assert_eq;
use crate::terminal_program_status::ProgramStatus::Blocked;
use crate::terminal_program_status::ProgramStatus::Idle;
use crate::terminal_program_status::ProgramStatus::Working;
use crate::terminal_program_status::ProgramStatusKind;
#[tokio::test]
async fn session_status_follows_existing_lifecycle_state() {
@@ -52,7 +53,15 @@ async fn session_status_follows_existing_lifecycle_state() {
assert_eq!(
states,
[Idle, Working, Blocked, Working, Idle, Working, Idle]
[
Idle,
Working,
Blocked(ProgramStatusKind::Permission),
Working,
Idle,
Working,
Idle
]
);
}
@@ -66,7 +75,7 @@ async fn session_status_detail_uses_only_foreground_activity() {
let generic = detail(&chat, Working);
chat.set_status_header("Reading source".to_string());
let working = detail(&chat, Working);
let waiting = detail(&chat, Blocked);
let waiting = detail(&chat, Blocked(ProgramStatusKind::Question));
chat.bottom_pane.set_task_running(/*running*/ false);
let idle = detail(&chat, Idle);
let background = detail(&chat, Working);
@@ -75,6 +75,8 @@ impl ChatWidget {
// Raw reasoning uses the same flow as summarized reasoning
pub(super) fn on_task_started(&mut self) {
self.status_state.program_status_after_turn =
crate::terminal_program_status::ProgramStatus::Idle;
self.bottom_pane.dismiss_composer_sparkle();
self.clear_context_compaction();
self.input_queue.user_turn_pending_start = false;
@@ -187,6 +189,11 @@ impl ChatWidget {
self.clear_active_hook_cell();
self.clear_guardian_review_status();
self.turn_lifecycle.finish();
self.status_state.program_status_after_turn = if from_replay {
crate::terminal_program_status::ProgramStatus::Idle
} else {
crate::terminal_program_status::ProgramStatus::Done
};
self.clear_safety_buffering();
self.update_task_running_state();
self.running_commands.clear();
@@ -347,6 +354,12 @@ impl ChatWidget {
self.input_queue.user_turn_pending_start = false;
self.clear_guardian_review_status();
self.turn_lifecycle.finish();
self.status_state.program_status_after_turn = if self.thread_usage.replaying_turn_completion
{
crate::terminal_program_status::ProgramStatus::Idle
} else {
crate::terminal_program_status::ProgramStatus::Error
};
self.update_task_running_state();
self.running_commands.clear();
self.suppressed_exec_calls.clear();