feat(tui): display real-time todos for subagents (#259)

- Add SubagentTodoItem and SubagentTodoStatus types to app.rs
- Add todos field to SubagentTaskDisplay struct
- Add TodoUpdated progress event for subagent todo updates
- Handle TodoUpdated event in event_loop to update subagent todos
- Render todos in render_subagent with status icons (✓/●/○)
- Remove '── Subagents ──' header for cleaner display

This allows the TUI to display the subagent's current todo list
in real-time instead of just showing line counts or output previews.

Co-authored-by: Droid Agent <droid@factory.ai>

Author: echobt

cortex-engine/src/tools/handlers/subagent/progress.rs

@@ -105,6 +105,13 @@ pub enum ProgressEvent {
 
     /// Warning message.
     Warning { session_id: String, message: String },
+
+    /// Todo list updated (from TodoWrite tool).
+    TodoUpdated {
+        session_id: String,
+        /// Todo items: (content, status) where status is "pending", "in_progress", or "completed"
+        todos: Vec<(String, String)>,
+    },
 }
 
 impl ProgressEvent {
@@ -125,6 +132,7 @@ impl ProgressEvent {
             Self::Cancelled { session_id, .. } => session_id,
             Self::Info { session_id, .. } => session_id,
             Self::Warning { session_id, .. } => session_id,
+            Self::TodoUpdated { session_id, .. } => session_id,
         }
     }
 
@@ -216,6 +224,22 @@ impl ProgressEvent {
             Self::Warning { message, .. } => {
                 format!("Warning: {}", message)
             }
+            Self::TodoUpdated { todos, .. } => {
+                let in_progress = todos
+                    .iter()
+                    .filter(|(_, status)| status == "in_progress")
+                    .count();
+                let completed = todos
+                    .iter()
+                    .filter(|(_, status)| status == "completed")
+                    .count();
+                format!(
+                    "Todos: {} items ({} in progress, {} completed)",
+                    todos.len(),
+                    in_progress,
+                    completed
+                )
+            }
         }
     }
 }
@@ -454,6 +478,14 @@ impl SubagentProgress {
         });
     }
 
+    /// Update todo list (from TodoWrite tool).
+    pub fn update_todos(&self, todos: Vec<(String, String)>) {
+        let _ = self.event_tx.send(ProgressEvent::TodoUpdated {
+            session_id: self.session_id.clone(),
+            todos,
+        });
+    }
+
     /// Get summary statistics.
     pub fn stats(&self) -> ProgressStats {
         ProgressStats {

cortex-tui/src/app.rs

@@ -179,6 +179,36 @@ pub struct PendingToolResult {
 // SUBAGENT TASK DISPLAY
 // ============================================================================
 
+/// A simple todo item for display in the subagent task view.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SubagentTodoItem {
+    /// Todo item content/description.
+    pub content: String,
+    /// Status: pending, in_progress, or completed.
+    pub status: SubagentTodoStatus,
+}
+
+/// Status of a subagent todo item.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SubagentTodoStatus {
+    /// Not started yet.
+    Pending,
+    /// Currently being worked on.
+    InProgress,
+    /// Completed.
+    Completed,
+}
+
+impl SubagentTodoItem {
+    /// Create a new todo item.
+    pub fn new(content: impl Into<String>, status: SubagentTodoStatus) -> Self {
+        Self {
+            content: content.into(),
+            status,
+        }
+    }
+}
+
 /// Display state for an active subagent task.
 #[derive(Debug, Clone)]
 pub struct SubagentTaskDisplay {
@@ -202,6 +232,8 @@ pub struct SubagentTaskDisplay {
     pub output_preview: String,
     /// Start time.
     pub started_at: Instant,
+    /// Current todo items from the subagent (if any).
+    pub todos: Vec<SubagentTodoItem>,
 }
 
 impl SubagentTaskDisplay {
@@ -223,6 +255,7 @@ impl SubagentTaskDisplay {
             tool_calls: Vec::new(),
             output_preview: String::new(),
             started_at: Instant::now(),
+            todos: Vec::new(),
         }
     }
 

cortex-tui/src/runner/event_loop.rs

@@ -3384,6 +3384,28 @@ impl EventLoop {
                         });
                     }
 
+                    ProgressEvent::TodoUpdated { todos, .. } => {
+                        use crate::app::{SubagentTodoItem, SubagentTodoStatus};
+                        tracing::debug!(
+                            "Subagent todos updated: {} - {} items",
+                            session_id,
+                            todos.len()
+                        );
+                        self.app_state.update_subagent(&session_id, |task| {
+                            task.todos = todos
+                                .iter()
+                                .map(|(content, status)| {
+                                    let todo_status = match status.as_str() {
+                                        "completed" => SubagentTodoStatus::Completed,
+                                        "in_progress" => SubagentTodoStatus::InProgress,
+                                        _ => SubagentTodoStatus::Pending,
+                                    };
+                                    SubagentTodoItem::new(content.clone(), todo_status)
+                                })
+                                .collect();
+                        });
+                    }
+
                     _ => {}
                 }
             }

cortex-tui/src/views/minimal_session.rs

@@ -428,8 +428,30 @@ impl<'a> MinimalSessionView<'a> {
             ),
         ]));
 
-        // Line 2: Tool calls summary if any
-        if !task.tool_calls.is_empty() {
+        // Display todos if any (real-time todo list from subagent)
+        if !task.todos.is_empty() {
+            use crate::app::SubagentTodoStatus;
+            for todo in &task.todos {
+                let (status_icon, status_color) = match todo.status {
+                    SubagentTodoStatus::Completed => ("✓", self.colors.success),
+                    SubagentTodoStatus::InProgress => ("●", self.colors.accent),
+                    SubagentTodoStatus::Pending => ("○", self.colors.text_muted),
+                };
+                // Truncate long todo content
+                let content = if todo.content.len() > 55 {
+                    format!("{}...", &todo.content.chars().take(52).collect::<String>())
+                } else {
+                    todo.content.clone()
+                };
+                lines.push(Line::from(vec![
+                    Span::styled("  ", Style::default()),
+                    Span::styled(status_icon, Style::default().fg(status_color)),
+                    Span::styled(" ", Style::default()),
+                    Span::styled(content, Style::default().fg(self.colors.text_dim)),
+                ]));
+            }
+        } else if !task.tool_calls.is_empty() {
+            // Fallback: show tool calls summary if no todos
             let tool_summary: String = task
                 .tool_calls
                 .iter()
@@ -450,10 +472,8 @@ impl<'a> MinimalSessionView<'a> {
                     Style::default().fg(self.colors.text_dim),
                 ),
             ]));
-        }
-
-        // Line 3: Output preview if any
-        if !task.output_preview.is_empty() {
+        } else if !task.output_preview.is_empty() {
+            // Fallback: show output preview if no todos and no tool calls
             let preview = if task.output_preview.len() > 60 {
                 format!(
                     "{}...",
@@ -587,18 +607,9 @@ impl<'a> MinimalSessionView<'a> {
         }
 
         // Render active subagents (always visible when running)
-        if !self.app_state.active_subagents.is_empty() {
-            // Add separator if we have other content
-            if !all_lines.is_empty() {
-                all_lines.push(Line::from(Span::styled(
-                    "── Subagents ──",
-                    Style::default().fg(self.colors.text_muted),
-                )));
-            }
-
-            for task in &self.app_state.active_subagents {
-                all_lines.extend(self.render_subagent(task));
-            }
+        // Note: No "Subagents" header - todos are displayed directly
+        for task in &self.app_state.active_subagents {
+            all_lines.extend(self.render_subagent(task));
         }
 
         let total_lines = all_lines.len();