Address oz review.

Author: zachbai

app/src/ai/agent_conversations_model.rs

@@ -253,20 +253,29 @@ enum LinkPreference {
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum AgentRunDisplayStatus {
+    /// Raw task-service lifecycle states. `from_task` only returns `TaskInProgress` while the
+    /// task still has an active execution, or when there is no shadowed local conversation to
+    /// provide a more granular status.
     TaskQueued,
     TaskPending,
     TaskClaimed,
     TaskInProgress,
     TaskSucceeded,
     TaskFailed,
     TaskError,
-    TaskBlocked { blocked_action: String },
+    TaskBlocked {
+        blocked_action: String,
+    },
     TaskCancelled,
     TaskUnknown,
+    /// Conversation-derived lifecycle states, used for interactive conversations and for
+    /// in-progress ambient tasks after they can be resolved to their shadowed local conversation.
     ConversationInProgress,
     ConversationSucceeded,
     ConversationError,
-    ConversationBlocked { blocked_action: String },
+    ConversationBlocked {
+        blocked_action: String,
+    },
     ConversationCancelled,
 }
 

app/src/ui_components/agent_icon.rs

@@ -105,28 +105,11 @@ pub(crate) fn agent_conversation_entry_icon_variant(
     let is_ambient = matches!(entry.provenance, AgentConversationProvenance::AmbientRun)
         || entry.backing.has_ambient_run
         || entry.identity.ambient_agent_task_id.is_some();
-    Some(match entry.provenance {
-        AgentConversationProvenance::AmbientRun => agent_icon_variant_for_run(
-            entry.display.harness.unwrap_or(Harness::Oz),
-            status,
-            is_ambient,
-        ),
-        AgentConversationProvenance::LocalInteractive
-        | AgentConversationProvenance::CloudSyncedConversation => {
-            if is_ambient {
-                agent_icon_variant_for_run(
-                    entry.display.harness.unwrap_or(Harness::Oz),
-                    status,
-                    is_ambient,
-                )
-            } else {
-                IconWithStatusVariant::OzAgent {
-                    status: Some(status),
-                    is_ambient,
-                }
-            }
-        }
-    })
+    Some(agent_icon_variant_for_run(
+        entry.display.harness.unwrap_or(Harness::Oz),
+        status,
+        is_ambient,
+    ))
 }
 
 /// Primitive inputs to the terminal-view waterfall, gathered once from the live

app/src/ui_components/agent_icon_tests.rs

@@ -10,13 +10,22 @@
 //!
 //! Adding a new canonical state is a one-enum-variant + one `expected` arm + one `*_inputs`
 //! arm change; the table test below enforces every surface agrees.
+use chrono::Utc;
 use warp_cli::agent::Harness;
 
 use super::{
-    agent_icon_variant_for_run, agent_icon_variant_from_terminal_inputs, CLISessionInputs,
-    TerminalIconInputs,
+    agent_conversation_entry_icon_variant, agent_icon_variant_for_run,
+    agent_icon_variant_from_terminal_inputs, CLISessionInputs, TerminalIconInputs,
+};
+use crate::ai::agent::conversation::{AIConversationId, ConversationStatus};
+use crate::ai::agent_conversations_model::entry::{
+    AgentConversationBackingData, AgentConversationCapabilities, AgentConversationCreator,
+    AgentConversationDisplayData, AgentConversationIdentity,
+};
+use crate::ai::agent_conversations_model::{
+    AgentConversationEntry, AgentConversationEntryId, AgentConversationProvenance,
+    AgentRunDisplayStatus,
 };
-use crate::ai::agent::conversation::ConversationStatus;
 use crate::terminal::CLIAgent;
 use crate::ui_components::icon_with_status::IconWithStatusVariant;
 
@@ -372,3 +381,58 @@ fn local_claude_vs_cloud_claude_differ_only_by_is_ambient() {
     assert!(!local.is_ambient);
     assert!(cloud.is_ambient);
 }
+
+#[test]
+fn non_ambient_entry_uses_display_harness() {
+    let conversation_id = AIConversationId::new();
+    let entry = AgentConversationEntry {
+        id: AgentConversationEntryId::Conversation(conversation_id),
+        identity: AgentConversationIdentity {
+            local_conversation_id: Some(conversation_id),
+            ambient_agent_task_id: None,
+            server_conversation_token: None,
+            session_id: None,
+        },
+        provenance: AgentConversationProvenance::CloudSyncedConversation,
+        display: AgentConversationDisplayData {
+            title: "Codex conversation".to_string(),
+            initial_query: None,
+            created_at: Utc::now(),
+            last_updated: Utc::now(),
+            status: AgentRunDisplayStatus::ConversationSucceeded,
+            creator: AgentConversationCreator::default(),
+            request_usage: None,
+            run_time: None,
+            source: None,
+            working_directory: None,
+            environment_id: None,
+            harness: Some(Harness::Codex),
+            artifacts: Vec::new(),
+        },
+        backing: AgentConversationBackingData {
+            has_loaded_conversation: true,
+            has_local_persisted_data: true,
+            has_cloud_data: true,
+            has_ambient_run: false,
+        },
+        capabilities: AgentConversationCapabilities {
+            can_open: true,
+            can_copy_link: false,
+            can_share: false,
+            can_delete: false,
+            can_fork_locally: false,
+            can_cancel: false,
+        },
+    };
+
+    let variant = agent_conversation_entry_icon_variant(&entry).unwrap();
+    assert_eq!(
+        AgentIconFields::from_variant(&variant).unwrap(),
+        AgentIconFields {
+            is_cli: true,
+            cli_agent: Some(CLIAgent::Codex),
+            status: Some(ConversationStatus::Success),
+            is_ambient: false,
+        }
+    );
+}