Upgrade delegate with better UX for notifications and change the file dependence. (#3337)

Author: abhraina-aws

crates/chat-cli/src/cli/chat/conversation.rs

@@ -379,6 +379,10 @@ impl ConversationState {
     }
 
     pub async fn set_next_user_message(&mut self, input: String) {
+        self.set_next_user_message_with_context(input, String::new()).await;
+    }
+
+    pub async fn set_next_user_message_with_context(&mut self, input: String, additional_context: String) {
         debug_assert!(self.next_message.is_none(), "next_message should not exist");
         if let Some(next_message) = self.next_message.as_ref() {
             warn!(?next_message, "next_message should not exist");
@@ -391,7 +395,8 @@ impl ConversationState {
             input
         };
 
-        let msg = UserMessage::new_prompt(input, Some(Local::now().fixed_offset()));
+        let mut msg = UserMessage::new_prompt(input, Some(Local::now().fixed_offset()));
+        msg.additional_context = additional_context;
         self.next_message = Some(msg);
     }
 

crates/chat-cli/src/cli/chat/mod.rs

@@ -127,7 +127,11 @@ use tool_manager::{
     ToolManager,
     ToolManagerBuilder,
 };
-use tools::delegate::status_all_agents;
+use tools::delegate::{
+    AgentExecution,
+    save_agent_execution,
+    status_all_agents,
+};
 use tools::gh_issue::GhIssueContext;
 use tools::{
     NATIVE_TOOLS,
@@ -465,12 +469,71 @@ fn trust_all_text() -> String {
     ui_text::trust_all_warning()
 }
 
+fn format_rich_notification(executions: &[AgentExecution]) -> String {
+    let count = executions.len();
+    let header = if count == 1 {
+        "1 Background Task Completed".to_string()
+    } else {
+        format!("{} Background Tasks Completed", count)
+    };
+
+    // Plain text notification - will be colored by highlight_prompt
+    let mut notification = format!("{}\n\n", header);
+
+    for (i, execution) in executions.iter().enumerate() {
+        let status_icon = match execution.status {
+            tools::delegate::AgentStatus::Completed => "✓ SUCCESS",
+            tools::delegate::AgentStatus::Failed => "✗ FAILED",
+            tools::delegate::AgentStatus::Running => "⏳ RUNNING", // shouldn't happen but just in case
+        };
+
+        let time_ago = if let Some(completed_at) = execution.completed_at {
+            let duration = chrono::Utc::now().signed_duration_since(completed_at);
+            if duration.num_minutes() < 1 {
+                "Completed just now".to_string()
+            } else if duration.num_minutes() < 60 {
+                format!("Completed {} min ago", duration.num_minutes())
+            } else if duration.num_hours() < 24 {
+                format!("Completed {} hr ago", duration.num_hours())
+            } else {
+                format!("Completed {} days ago", duration.num_days())
+            }
+        } else {
+            "unknown".to_string()
+        };
+
+        // Shorten CWD path - replace home directory with ~
+        let shortened_cwd = if let Ok(home) = std::env::var("HOME") {
+            execution.cwd.replace(&home, "~")
+        } else {
+            execution.cwd.clone()
+        };
+
+        let summary = execution.summary.as_deref().unwrap_or("No summary available");
+
+        notification.push_str(&format!(
+            "[{}] {} · {} · {} · {}\n\nTask: {}\n\n{}\n\n",
+            i + 1,
+            execution.agent,
+            shortened_cwd,
+            status_icon,
+            time_ago,
+            execution.task,
+            summary
+        ));
+    }
+
+    // Add footer with instructions
+    notification.push_str("To read the full details of any task, ask the delegate tool.\n");
+
+    notification
+}
+
 const TOOL_BULLET: &str = " ● ";
 const CONTINUATION_LINE: &str = " ⋮ ";
 const PURPOSE_ARROW: &str = " ↳ ";
 const SUCCESS_TICK: &str = " ✓ ";
 const ERROR_EXCLAMATION: &str = " ❗ ";
-const DELEGATE_NOTIFIER: &str = "[BACKGROUND TASK READY]";
 
 /// Enum used to denote the origin of a tool use event
 enum ToolUseStatus {
@@ -611,6 +674,8 @@ pub struct ChatSession {
     ctrlc_rx: broadcast::Receiver<()>,
     wrap: Option<WrapMode>,
     prompt_ack_rx: std::sync::mpsc::Receiver<()>,
+    /// Additional context to be added to the next user message (e.g., delegate task summaries)
+    pending_additional_context: Option<String>,
 }
 
 impl ChatSession {
@@ -747,6 +812,7 @@ impl ChatSession {
             ctrlc_rx,
             wrap,
             prompt_ack_rx,
+            pending_additional_context: None,
         })
     }
 
@@ -2219,7 +2285,11 @@ impl ChatSession {
                 };
                 self.conversation.abandon_tool_use(&self.tool_uses, user_input);
             } else {
-                self.conversation.set_next_user_message(user_input).await;
+                // Add additional context if available (e.g., delegate summaries)
+                let context = self.pending_additional_context.take().unwrap_or_default();
+                self.conversation
+                    .set_next_user_message_with_context(user_input, context)
+                    .await;
             }
 
             self.reset_user_turn();
@@ -3486,8 +3556,24 @@ impl ChatSession {
         let mut generated_prompt =
             prompt::generate_prompt(profile.as_deref(), all_trusted, tangent_mode, usage_percentage);
 
-        if ExperimentManager::is_enabled(os, ExperimentName::Delegate) && status_all_agents(os).await.is_ok() {
-            generated_prompt = format!("{DELEGATE_NOTIFIER}\n{generated_prompt}");
+        if ExperimentManager::is_enabled(os, ExperimentName::Delegate) {
+            if let Ok(mut executions) = status_all_agents(os).await {
+                if !executions.is_empty() {
+                    let rich_notification = format_rich_notification(&executions);
+                    generated_prompt = format!("{}\n{}", rich_notification, generated_prompt);
+
+                    // Use the notification text as context for the model (it's already plain text)
+                    self.pending_additional_context = Some(rich_notification.clone());
+
+                    // Mark all shown tasks as user_notified
+                    for execution in &mut executions {
+                        execution.user_notified = true;
+                        if let Err(e) = save_agent_execution(os, execution).await {
+                            eprintln!("Failed to mark agent execution as notified: {}", e);
+                        }
+                    }
+                }
+            }
         }
 
         generated_prompt

crates/chat-cli/src/cli/chat/prompt.rs

@@ -459,14 +459,14 @@ impl Highlighter for ChatHelper {
     fn highlight_prompt<'b, 's: 'b, 'p: 'b>(&'s self, prompt: &'p str, _default: bool) -> Cow<'b, str> {
         use crate::theme::StyledText;
 
-        // Parse the plain text prompt to extract profile and warning information
-        // and apply colors using crossterm's ANSI escape codes
+        // Parse the plain text prompt to extract components
         if let Some(components) = parse_prompt_components(prompt) {
             let mut result = String::new();
 
-            // Add notifier part if present (info blue)
+            // Add delegate notifier if present (colored as warning)
             if let Some(notifier) = components.delegate_notifier {
-                result.push_str(&StyledText::info(&format!("[{}]\n", notifier)));
+                result.push_str(&StyledText::warning(&notifier));
+                result.push('\n');
             }
 
             // Add profile part if present (profile indicator cyan)

crates/chat-cli/src/cli/chat/prompt_parser.rs

@@ -18,21 +18,22 @@ pub fn parse_prompt_components(prompt: &str) -> Option<PromptComponents> {
     let mut warning = false;
     let mut tangent_mode = false;
     let mut usage_percentage = None;
-    let mut remaining = prompt.trim();
 
-    // Check for delegate notifier first
-    if let Some(start) = remaining.find('[') {
-        if let Some(end) = remaining.find(']') {
-            if start < end {
-                let content = &remaining[start + 1..end];
-                // Only set profile if it's not "BACKGROUND TASK READY" or if it doesn't end with newline
-                if content == "BACKGROUND TASK READY" && remaining[end + 1..].starts_with('\n') {
-                    delegate_notifier = Some(content.to_string());
-                    remaining = remaining[end + 1..].trim_start();
-                }
-            }
+    // Check if multi-line prompt (e.g., with rich notification)
+    // Everything before the last line is treated as delegate_notifier
+    let remaining = if prompt.contains('\n') {
+        let lines: Vec<&str> = prompt.lines().collect();
+        if lines.len() > 1 {
+            // Everything except last line is the notification
+            delegate_notifier = Some(lines[..lines.len() - 1].join("\n"));
         }
-    }
+        // Parse only the last line for prompt components
+        lines.last().unwrap_or(&"").trim()
+    } else {
+        prompt.trim()
+    };
+
+    let mut remaining = remaining;
 
     // Check for agent pattern [agent] first
     if let Some(start) = remaining.find('[') {