Use tombstone for failure UX for cloud mode (#10895)

## Description
<!-- Please remember to add your design buddy onto the PR for review, if
it contains any UI changes! -->
This PR reverts back to using the tombstone, rather than the message
bar, to display setup failures in cloud mode.

In addition to showing the tombstone, we also:
- Update `conversation_output_status_from_conversation` to return
statuses even when the conversation doesn't have any tasks (e.g. failure
before conversation running, third-party harness)
- Deserialize an `error_code` from task status messages (already present
in the GraphQL) so that for setup command failures we don't show the
tombstone with Continue/Continue Locally actions (it doesn't make sense
to continue for an environment that's borked).

Loom: https://www.loom.com/share/685d737b881f4d89a1be0ade033da5ab


## Testing
<!--
How did you test this change? What automated tests did you add? If you
didn't add any new tests, what's your justification for not adding any?

Manual testing is required for changes that can be manually tested, and
almost all changes can be manually tested. If your change can be
manually tested, please include screenshots or a screen recording that
show it working end to end.

You can run the app locally using `./script/run` - see WARP.md for more
details on how to get set up.
-->

Added unit tests and tested a variety of failure modes in the Loom
above.

### Screenshots / Videos
<!-- Attach screenshots or a short video demonstrating the change, where
appropriate. Remove this section if it is not relevant to your PR. -->

Not included in the Loom, but setup command failure:
<img width="1392" height="912" alt="image"
src="https://github.com/user-attachments/assets/eefbb82c-1c0a-4ede-b92d-79d93a9faa8c"
/>

I don't think it's perfect but it's better than what we had before:
<img width="602" height="126" alt="image"
src="https://github.com/user-attachments/assets/7a2367b7-75c9-498d-a5e8-dbb5044e73bc"
/>


## Agent Mode
- [x] Warp Agent Mode - This PR was created via Warp's AI Agent Mode

Author: liliwilson

app/src/ai/agent_conversations_model_tests.rs

@@ -1754,6 +1754,7 @@ fn test_task_status_maps_blocked_state_to_blocked() {
         task.state = AmbientAgentTaskState::Blocked;
         task.status_message = Some(TaskStatusMessage {
             message: "Needs clarification".to_string(),
+            error_code: None,
         });
 
         app.update(|ctx| {

app/src/ai/ambient_agents/mod.rs

@@ -78,19 +78,32 @@ pub fn conversation_output_status_from_conversation(
             blocked_action: blocked_action.clone(),
         });
     }
-
-    let last_exchange = conversation.root_task_exchanges().last()?;
-    if let AIAgentOutputStatus::Finished { finished_output } = &last_exchange.output_status {
-        let status = match finished_output {
-            FinishedAIAgentOutput::Cancelled { output: _, reason } => {
-                AmbientConversationStatus::Cancelled { reason: *reason }
-            }
-            FinishedAIAgentOutput::Error { output: _, error } => AmbientConversationStatus::Error {
-                error: error.clone(),
-            },
-            FinishedAIAgentOutput::Success { output: _ } => AmbientConversationStatus::Success,
-        };
-        return Some(status);
+    if let Some(last_exchange) = conversation.root_task_exchanges().last() {
+        if let AIAgentOutputStatus::Finished { finished_output } = &last_exchange.output_status {
+            let status = match finished_output {
+                FinishedAIAgentOutput::Cancelled { output: _, reason } => {
+                    AmbientConversationStatus::Cancelled { reason: *reason }
+                }
+                FinishedAIAgentOutput::Error { output: _, error } => {
+                    AmbientConversationStatus::Error {
+                        error: error.clone(),
+                    }
+                }
+                FinishedAIAgentOutput::Success { output: _ } => AmbientConversationStatus::Success,
+            };
+            return Some(status);
+        }
+    }
+    if let ConversationStatus::Error = conversation.status() {
+        if let Some(error_message) = conversation.status_error_message() {
+            return Some(AmbientConversationStatus::Error {
+                error: RenderableAIError::Other {
+                    error_message: error_message.to_string(),
+                    will_attempt_resume: false,
+                    waiting_for_network: false,
+                },
+            });
+        }
     }
 
     None

app/src/ai/ambient_agents/spawn_tests.rs

@@ -166,6 +166,7 @@ async fn followup_terminal_failure_surfaces_status_message() {
             let mut task = task_with(AmbientAgentTaskState::Error, None, None);
             task.status_message = Some(TaskStatusMessage {
                 message: "failed to provision runtime".to_string(),
+                error_code: None,
             });
             Ok(task)
         });

app/src/ai/ambient_agents/task.rs

@@ -520,6 +520,31 @@ pub struct TaskPrincipalInfo {
 #[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
 pub struct TaskStatusMessage {
     pub message: String,
+    #[serde(default, alias = "errorCode")]
+    pub error_code: Option<TaskStatusErrorCode>,
+}
+
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum TaskStatusErrorCode {
+    #[serde(alias = "ENVIRONMENT_SETUP_FAILED")]
+    EnvironmentSetupFailed,
+    #[serde(other)]
+    Unknown,
+}
+
+impl TaskStatusErrorCode {
+    pub fn is_environment_setup_failure(&self) -> bool {
+        matches!(self, TaskStatusErrorCode::EnvironmentSetupFailed)
+    }
+}
+
+impl TaskStatusMessage {
+    pub fn is_environment_setup_failure(&self) -> bool {
+        self.error_code
+            .as_ref()
+            .is_some_and(TaskStatusErrorCode::is_environment_setup_failure)
+    }
 }
 
 #[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
@@ -563,3 +588,7 @@ pub fn cancel_task_silently<V: View>(task_id: AmbientAgentTaskId, ctx: &mut View
         },
     );
 }
+
+#[cfg(test)]
+#[path = "task_tests.rs"]
+mod tests;

app/src/ai/ambient_agents/task_tests.rs

@@ -0,0 +1,38 @@
+use super::{TaskStatusErrorCode, TaskStatusMessage};
+
+#[test]
+fn task_status_error_code_deserializes_public_api_casing() {
+    let message: TaskStatusMessage = serde_json::from_str(
+        "{\"message\":\"setup failed\",\"error_code\":\"environment_setup_failed\"}",
+    )
+    .unwrap();
+
+    assert_eq!(
+        message.error_code,
+        Some(TaskStatusErrorCode::EnvironmentSetupFailed)
+    );
+    assert!(message.is_environment_setup_failure());
+}
+
+#[test]
+fn task_status_error_code_deserializes_graphql_casing() {
+    let message: TaskStatusMessage = serde_json::from_str(
+        "{\"message\":\"setup failed\",\"errorCode\":\"ENVIRONMENT_SETUP_FAILED\"}",
+    )
+    .unwrap();
+
+    assert_eq!(
+        message.error_code,
+        Some(TaskStatusErrorCode::EnvironmentSetupFailed)
+    );
+    assert!(message.is_environment_setup_failure());
+}
+
+#[test]
+fn task_status_error_code_deserializes_unknown_codes() {
+    let message: TaskStatusMessage =
+        serde_json::from_str("{\"message\":\"failed\",\"error_code\":\"new_error\"}").unwrap();
+
+    assert_eq!(message.error_code, Some(TaskStatusErrorCode::Unknown));
+    assert!(!message.is_environment_setup_failure());
+}

app/src/ai/blocklist/block/status_bar.rs

@@ -944,19 +944,6 @@ impl BlocklistAIStatusBar {
             ]));
         }
 
-        if let Some(error_message) = ambient_agent_model.error_message() {
-            return Some(Message::new(vec![
-                MessageItem::Icon {
-                    icon: CoreIcon::Triangle,
-                    color: Some(error_color),
-                },
-                MessageItem::Text {
-                    content: error_message.to_owned().into(),
-                    color: Some(error_color),
-                },
-            ]));
-        }
-
         if ambient_agent_model.is_cancelled() {
             let color = theme.disabled_text_color(theme.background()).into_solid();
             return Some(Message::new(vec![

app/src/terminal/view/ambient_agent/view_impl.rs

@@ -230,11 +230,16 @@ impl TerminalView {
                     Some(error_message.clone()),
                     ctx,
                 );
+
+                if FeatureFlag::CloudModeSetupV2.is_enabled() {
+                    self.insert_conversation_ended_tombstone(ctx);
+                }
+
                 // Refresh the details panel to show failed status
                 if self.is_conversation_details_panel_open {
                     self.fetch_and_update_conversation_details_panel(ctx);
                 }
-                // Re-render to show the error state in the footer.
+                // Re-render to show the error state.
                 ctx.emit(TerminalViewEvent::TerminalViewStateChanged);
                 ctx.notify();
             }

app/src/terminal/view/shared_session/conversation_ended_tombstone_view.rs

@@ -53,6 +53,7 @@ struct TombstoneDisplayData {
     working_directory: Option<String>,
     /// Artifacts from the conversation
     artifacts: Vec<Artifact>,
+    hide_continue_actions: bool,
     /// Execution harness for the task. None until the task is loaded.
     #[cfg(not(target_family = "wasm"))]
     harness: Option<Harness>,
@@ -117,6 +118,7 @@ impl TombstoneDisplayData {
             credits: Some(format_credits(conversation.credits_spent())),
             working_directory: conversation.initial_working_directory(),
             artifacts: conversation.artifacts().to_vec(),
+            hide_continue_actions: false,
             #[cfg(not(target_family = "wasm"))]
             harness: None,
         }
@@ -149,6 +151,9 @@ impl TombstoneDisplayData {
         if task.state.is_failure_like() {
             self.is_error = true;
             if let Some(status_message) = &task.status_message {
+                if status_message.is_environment_setup_failure() {
+                    self.hide_continue_actions = true;
+                }
                 self.error_message = Some(status_message.message.clone());
             }
         }
@@ -195,17 +200,23 @@ impl ConversationEndedTombstoneView {
             .all_live_conversations_for_terminal_view(terminal_view_id)
             .next()
             .map(|c| c.id());
-
-        let display_data = conversation_id
-            .map(|id| {
+        let mut display_data = conversation_id
+            .map(|conversation_id| {
                 TombstoneDisplayData::from_conversation(
-                    id,
+                    conversation_id,
                     terminal_view_id,
                     task_id.is_some(),
                     ctx,
                 )
             })
             .unwrap_or_default();
+        let failed_before_task_creation =
+            display_data.is_error && task_id.is_none() && !display_data.conversation_is_transcript;
+        if failed_before_task_creation {
+            display_data.title = Some("Cloud agent failed to start".to_string());
+            display_data.credits = None;
+            display_data.hide_continue_actions = true;
+        }
 
         let artifact_buttons_view =
             ctx.add_typed_action_view(|ctx| ArtifactButtonsRow::new(&display_data.artifacts, ctx));
@@ -225,17 +236,21 @@ impl ConversationEndedTombstoneView {
             });
 
         #[cfg(not(target_family = "wasm"))]
-        let continue_locally_button = conversation_id.map(|conv_id| {
-            ctx.add_typed_action_view(move |_| {
-                ActionButton::new("Continue locally", PrimaryTheme)
-                    .with_tooltip("Fork this conversation locally")
-                    .on_click(move |ctx| {
-                        ctx.dispatch_typed_action(
-                            ConversationEndedTombstoneAction::ContinueLocally(conv_id),
-                        );
-                    })
+        let continue_locally_button = if failed_before_task_creation {
+            None
+        } else {
+            conversation_id.map(|conv_id| {
+                ctx.add_typed_action_view(move |_| {
+                    ActionButton::new("Continue locally", PrimaryTheme)
+                        .with_tooltip("Fork this conversation locally")
+                        .on_click(move |ctx| {
+                            ctx.dispatch_typed_action(
+                                ConversationEndedTombstoneAction::ContinueLocally(conv_id),
+                            );
+                        })
+                })
             })
-        });
+        };
 
         // In wasm, continuing locally is impossible so we instead
         // offer to open the conversation in warp (where you can continue locally).
@@ -494,6 +509,9 @@ impl ConversationEndedTombstoneView {
             .with_spacing(8.);
 
         let mut has_button = false;
+        if self.display_data.hide_continue_actions {
+            return Empty::new().finish();
+        }
 
         #[cfg(not(target_family = "wasm"))]
         {
@@ -535,6 +553,29 @@ impl ConversationEndedTombstoneView {
     }
 }
 
+#[cfg(test)]
+impl ConversationEndedTombstoneView {
+    pub(in crate::terminal::view) fn title_for_test(&self) -> Option<&str> {
+        self.display_data.title.as_deref()
+    }
+
+    pub(in crate::terminal::view) fn error_message_for_test(&self) -> Option<&str> {
+        self.display_data.error_message.as_deref()
+    }
+
+    pub(in crate::terminal::view) fn credits_for_test(&self) -> Option<&str> {
+        self.display_data.credits.as_deref()
+    }
+
+    pub(in crate::terminal::view) fn has_continue_locally_button_for_test(&self) -> bool {
+        !self.display_data.hide_continue_actions && self.continue_locally_button.is_some()
+    }
+
+    pub(in crate::terminal::view) fn has_continue_in_cloud_button_for_test(&self) -> bool {
+        !self.display_data.hide_continue_actions && self.continue_in_cloud_button.is_some()
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum ConversationEndedTombstoneAction {
     #[cfg(not(target_family = "wasm"))]

app/src/terminal/view/shared_session/conversation_ended_tombstone_view_tests.rs

@@ -2,7 +2,8 @@ use chrono::{Duration, Utc};
 use warp_cli::agent::Harness;
 
 use crate::ai::ambient_agents::task::{
-    AgentConfigSnapshot, HarnessConfig, RequestUsage, TaskPrincipalInfo,
+    AgentConfigSnapshot, HarnessConfig, RequestUsage, TaskPrincipalInfo, TaskStatusErrorCode,
+    TaskStatusMessage,
 };
 use crate::ai::ambient_agents::{AmbientAgentTask, AmbientAgentTaskState};
 use crate::ai::artifacts::Artifact;
@@ -67,6 +68,41 @@ fn data_with_conversation_values() -> TombstoneDisplayData {
     }
 }
 
+#[test]
+fn task_failure_status_message_overrides_conversation_error() {
+    let mut task = task_with_run_time_and_credits();
+    task.state = AmbientAgentTaskState::Failed;
+    task.status_message = Some(TaskStatusMessage {
+        message: "task failed".to_string(),
+        error_code: None,
+    });
+    let mut data = TombstoneDisplayData {
+        is_error: true,
+        error_message: Some("setup failed".to_string()),
+        ..Default::default()
+    };
+
+    data.enrich_from_task(task);
+
+    assert!(data.is_error);
+    assert_eq!(data.error_message.as_deref(), Some("task failed"));
+}
+
+#[test]
+fn environment_setup_failure_hides_continue_actions() {
+    let mut task = task_with_run_time_and_credits();
+    task.state = AmbientAgentTaskState::Failed;
+    task.status_message = Some(TaskStatusMessage {
+        message: "Environment setup failed: Failed to run setup command: hi".to_string(),
+        error_code: Some(TaskStatusErrorCode::EnvironmentSetupFailed),
+    });
+    let mut data = TombstoneDisplayData::default();
+
+    data.enrich_from_task(task);
+
+    assert!(data.hide_continue_actions);
+}
+
 fn pr_artifact(branch: &str) -> Artifact {
     Artifact::PullRequest {
         url: format!("https://github.com/example/repo/pull/{branch}"),

app/src/terminal/view/shared_session/view_impl.rs

@@ -1672,8 +1672,7 @@ impl TerminalView {
         }
         let task_id = self.ambient_agent_task_id_for_details_panel(ctx);
         let terminal_view_id = self.id();
-
-        let tombstone_view_handle = ctx.add_typed_action_view(|ctx| {
+        let tombstone_view_handle = ctx.add_typed_action_view(move |ctx| {
             ConversationEndedTombstoneView::new(ctx, terminal_view_id, task_id)
         });
         #[cfg(not(target_family = "wasm"))]