🤖 fix: reset todos on stream end and persist correctly on reload

## Problem

1. **Todos not resetting on stream end**: Todos persisted after stream completion instead of being cleared
2. **Incorrect persistence on reload**: TODOs were reconstructed from history even for completed streams, causing stale todos to reappear
3. **Missing reconnection logic**: No distinction between reloading during an active stream vs after completion

## Solution

### Reset todos on stream end
- Modified `cleanupStreamState()` to clear `currentTodos` when stream completes (end/abort/error)
- Todos are now truly stream-scoped - cleared immediately when streams end

### Smart reconstruction on reload
- Added `hasActiveStream` parameter to `loadHistoricalMessages()`
- **WorkspaceStore** checks buffered events for `stream-start` to detect active streams
- **Active stream reconnection** (hasActiveStream=true): Reconstruct TODOs from history ✅
- **Completed stream reload** (hasActiveStream=false): Don't reconstruct TODOs ✅
- **agentStatus** always reconstructed (persists across sessions) ✅

### Simplified UI
- Removed filtering logic from `PinnedTodoList` - no longer needed since todos auto-clear
- Cleaner component with fewer moving parts

## Implementation

**StreamingMessageAggregator.loadHistoricalMessages():**
```typescript
loadHistoricalMessages(messages: CmuxMessage[], hasActiveStream: boolean = false): void {
  // ... add messages to map ...

  // Reconstruct based on tool type and stream state
  const shouldReconstructTodos = part.toolName === "todo_write" && hasActiveStream;
  const shouldReconstructStatus = part.toolName === "status_set";

  if (shouldReconstructTodos || shouldReconstructStatus) {
    this.processToolResult(part.toolName, part.input, part.output);
  }
}
```

**WorkspaceStore.handleChatMessage():**
```typescript
// Check if there's an active stream in buffered events
const pendingEvents = this.pendingStreamEvents.get(workspaceId) ?? [];
const hasActiveStream = pendingEvents.some(
  (event) => "type" in event && event.type === "stream-start"
);

aggregator.loadHistoricalMessages(historicalMsgs, hasActiveStream);
```

## Testing

✅ **Todo reset on stream end** - todos cleared on completion
✅ **Todo reset on stream abort** - todos cleared on interruption
✅ **Active stream reconnection** - todos reconstructed with hasActiveStream=true
✅ **Completed stream reload** - todos NOT reconstructed with hasActiveStream=false
✅ **agentStatus persistence** - always reconstructed regardless of stream state
✅ **User message clears todos** - existing behavior maintained

All 146 tests pass ✅

## Behavior After This PR

**During streaming:**
- Todos update in real-time as `todo_write` is called
- UI shows all todos (pending, in_progress, completed)

**On stream end:**
- Todos cleared immediately
- UI shows nothing (clean slate)

**On reload - active stream (reconnection):**
- Backend sends buffered `stream-start` event
- TODOs reconstructed from historical tool calls ✅
- Stream continues with todos visible

**On reload - completed stream:**
- No buffered stream events
- TODOs NOT reconstructed ✅
- UI remains clean

**On new user message:**
- Todos cleared for fresh start
- Existing behavior unchanged

---

_Generated with `cmux`_

Author: ammar-agent

src/components/PinnedTodoList.tsx

@@ -10,13 +10,14 @@ interface PinnedTodoListProps {
 
 /**
  * Pinned TODO list displayed at bottom of chat (before StreamingBarrier).
- * Shows current TODOs from active stream only.
+ * Shows current TODOs from active stream only - automatically cleared when stream ends.
  * Reuses TodoList component for consistent styling.
  *
  * Relies on natural reference stability from MapStore + Aggregator architecture:
  * - Aggregator.getCurrentTodos() returns direct reference (not a copy)
  * - Reference only changes when todos are actually modified
  * - MapStore caches WorkspaceState per version, avoiding unnecessary recomputation
+ * - Todos are cleared by StreamingMessageAggregator when stream completes
  */
 export const PinnedTodoList: React.FC<PinnedTodoListProps> = ({ workspaceId }) => {
   const [expanded, setExpanded] = usePersistedState("pinnedTodoExpanded", true);
@@ -27,17 +28,8 @@ export const PinnedTodoList: React.FC<PinnedTodoListProps> = ({ workspaceId }) =
     () => workspaceStore.getWorkspaceState(workspaceId).todos
   );
 
-  // Get streaming state
-  const canInterrupt = useSyncExternalStore(
-    (callback) => workspaceStore.subscribeKey(workspaceId, callback),
-    () => workspaceStore.getWorkspaceState(workspaceId).canInterrupt
-  );
-
-  // When idle (not streaming), only show completed todos for clean summary
-  // When streaming, show all todos so user can see active work
-  const displayTodos = canInterrupt ? todos : todos.filter((todo) => todo.status === "completed");
-
-  if (displayTodos.length === 0) {
+  // Todos are cleared when stream ends, so if there are todos they're from an active stream
+  if (todos.length === 0) {
     return null;
   }
 
@@ -57,7 +49,7 @@ export const PinnedTodoList: React.FC<PinnedTodoListProps> = ({ workspaceId }) =
         </span>
         TODO{expanded ? ":" : ""}
       </div>
-      {expanded && <TodoList todos={displayTodos} />}
+      {expanded && <TodoList todos={todos} />}
     </div>
   );
 };

src/stores/WorkspaceStore.ts

@@ -910,17 +910,22 @@ export class WorkspaceStore {
     const historicalMsgs = this.historicalMessages.get(workspaceId) ?? [];
 
     if (isCaughtUpMessage(data)) {
+      // Check if there's an active stream in buffered events (reconnection scenario)
+      const pendingEvents = this.pendingStreamEvents.get(workspaceId) ?? [];
+      const hasActiveStream = pendingEvents.some(
+        (event) => "type" in event && event.type === "stream-start"
+      );
+
       // Load historical messages first
       if (historicalMsgs.length > 0) {
-        aggregator.loadHistoricalMessages(historicalMsgs);
+        aggregator.loadHistoricalMessages(historicalMsgs, hasActiveStream);
         this.historicalMessages.set(workspaceId, []);
       }
 
       // Mark that we're replaying buffered history (prevents O(N) scheduling)
       this.replayingHistory.add(workspaceId);
 
       // Process buffered stream events now that history is loaded
-      const pendingEvents = this.pendingStreamEvents.get(workspaceId) ?? [];
       for (const event of pendingEvents) {
         this.processStreamEvent(workspaceId, aggregator, event);
       }

src/utils/messages/StreamingMessageAggregator.test.ts

@@ -137,4 +137,246 @@ describe("StreamingMessageAggregator", () => {
       expect(messages1).toBe(messages2);
     });
   });
+
+  describe("todo lifecycle", () => {
+    test("should clear todos when stream ends", () => {
+      const aggregator = new StreamingMessageAggregator(TEST_CREATED_AT);
+
+      // Start a stream
+      aggregator.handleStreamStart({
+        type: "stream-start",
+        workspaceId: "test-workspace",
+        messageId: "msg1",
+        historySequence: 1,
+        model: "claude-3-5-sonnet-20241022",
+      });
+
+      // Simulate todo_write tool call
+      aggregator.handleToolCallStart({
+        messageId: "msg1",
+        toolCallId: "tool1",
+        toolName: "todo_write",
+        args: {
+          todos: [
+            { content: "Do task 1", status: "in_progress" },
+            { content: "Do task 2", status: "pending" },
+          ],
+        },
+        tokens: 10,
+        timestamp: Date.now(),
+        type: "tool-call-start",
+        workspaceId: "test-workspace",
+      });
+
+      aggregator.handleToolCallEnd({
+        type: "tool-call-end",
+        workspaceId: "test-workspace",
+        messageId: "msg1",
+        toolCallId: "tool1",
+        toolName: "todo_write",
+        result: { success: true },
+      });
+
+      // Verify todos are set
+      expect(aggregator.getCurrentTodos()).toHaveLength(2);
+      expect(aggregator.getCurrentTodos()[0].content).toBe("Do task 1");
+
+      // End the stream
+      aggregator.handleStreamEnd({
+        type: "stream-end",
+        workspaceId: "test-workspace",
+        messageId: "msg1",
+        metadata: {
+          historySequence: 1,
+          timestamp: Date.now(),
+          model: "claude-3-5-sonnet-20241022",
+        },
+        parts: [],
+      });
+
+      // Todos should be cleared
+      expect(aggregator.getCurrentTodos()).toHaveLength(0);
+    });
+
+    test("should clear todos when stream aborts", () => {
+      const aggregator = new StreamingMessageAggregator(TEST_CREATED_AT);
+
+      aggregator.handleStreamStart({
+        type: "stream-start",
+        workspaceId: "test-workspace",
+        messageId: "msg1",
+        historySequence: 1,
+        model: "claude-3-5-sonnet-20241022",
+      });
+
+      // Simulate todo_write
+      aggregator.handleToolCallStart({
+        messageId: "msg1",
+        toolCallId: "tool1",
+        toolName: "todo_write",
+        args: {
+          todos: [{ content: "Task", status: "in_progress" }],
+        },
+        tokens: 10,
+        timestamp: Date.now(),
+        type: "tool-call-start",
+        workspaceId: "test-workspace",
+      });
+
+      aggregator.handleToolCallEnd({
+        type: "tool-call-end",
+        workspaceId: "test-workspace",
+        messageId: "msg1",
+        toolCallId: "tool1",
+        toolName: "todo_write",
+        result: { success: true },
+      });
+
+      expect(aggregator.getCurrentTodos()).toHaveLength(1);
+
+      // Abort the stream
+      aggregator.handleStreamAbort({
+        type: "stream-abort",
+        workspaceId: "test-workspace",
+        messageId: "msg1",
+        metadata: {},
+      });
+
+      // Todos should be cleared
+      expect(aggregator.getCurrentTodos()).toHaveLength(0);
+    });
+
+    test("should reconstruct todos on reload ONLY when reconnecting to active stream", () => {
+      const aggregator = new StreamingMessageAggregator(TEST_CREATED_AT);
+
+      const historicalMessage = {
+        id: "msg1",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "tool1",
+            toolName: "todo_write",
+            state: "output-available" as const,
+            input: {
+              todos: [
+                { content: "Historical task 1", status: "completed" },
+                { content: "Historical task 2", status: "completed" },
+              ],
+            },
+            output: { success: true },
+          },
+        ],
+        metadata: {
+          historySequence: 1,
+          timestamp: Date.now(),
+          model: "claude-3-5-sonnet-20241022",
+        },
+      };
+
+      // Scenario 1: Reload with active stream (hasActiveStream = true)
+      aggregator.loadHistoricalMessages([historicalMessage], true);
+      expect(aggregator.getCurrentTodos()).toHaveLength(2);
+      expect(aggregator.getCurrentTodos()[0].content).toBe("Historical task 1");
+
+      // Reset for next scenario
+      const aggregator2 = new StreamingMessageAggregator(TEST_CREATED_AT);
+
+      // Scenario 2: Reload without active stream (hasActiveStream = false)
+      aggregator2.loadHistoricalMessages([historicalMessage], false);
+      expect(aggregator2.getCurrentTodos()).toHaveLength(0);
+    });
+
+    test("should reconstruct agentStatus but NOT todos when no active stream", () => {
+      const aggregator = new StreamingMessageAggregator(TEST_CREATED_AT);
+
+      const historicalMessage = {
+        id: "msg1",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "tool1",
+            toolName: "todo_write",
+            state: "output-available" as const,
+            input: {
+              todos: [{ content: "Task 1", status: "completed" }],
+            },
+            output: { success: true },
+          },
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "tool2",
+            toolName: "status_set",
+            state: "output-available" as const,
+            input: { emoji: "🔧", message: "Working on it" },
+            output: { success: true, emoji: "🔧", message: "Working on it" },
+          },
+        ],
+        metadata: {
+          historySequence: 1,
+          timestamp: Date.now(),
+          model: "claude-3-5-sonnet-20241022",
+        },
+      };
+
+      // Load without active stream
+      aggregator.loadHistoricalMessages([historicalMessage], false);
+
+      // agentStatus should be reconstructed (persists across sessions)
+      expect(aggregator.getAgentStatus()).toEqual({ emoji: "🔧", message: "Working on it" });
+
+      // TODOs should NOT be reconstructed (stream-scoped)
+      expect(aggregator.getCurrentTodos()).toHaveLength(0);
+    });
+
+    test("should clear todos when new user message arrives during active stream", () => {
+      const aggregator = new StreamingMessageAggregator(TEST_CREATED_AT);
+
+      // Simulate an active stream with todos
+      aggregator.handleStreamStart({
+        type: "stream-start",
+        workspaceId: "test-workspace",
+        messageId: "msg1",
+        historySequence: 1,
+        model: "claude-3-5-sonnet-20241022",
+      });
+
+      aggregator.handleToolCallStart({
+        messageId: "msg1",
+        toolCallId: "tool1",
+        toolName: "todo_write",
+        args: {
+          todos: [{ content: "Task", status: "completed" }],
+        },
+        tokens: 10,
+        timestamp: Date.now(),
+        type: "tool-call-start",
+        workspaceId: "test-workspace",
+      });
+
+      aggregator.handleToolCallEnd({
+        type: "tool-call-end",
+        workspaceId: "test-workspace",
+        messageId: "msg1",
+        toolCallId: "tool1",
+        toolName: "todo_write",
+        result: { success: true },
+      });
+
+      // TODOs should be set
+      expect(aggregator.getCurrentTodos()).toHaveLength(1);
+
+      // Add new user message (simulating user sending a new message)
+      aggregator.handleMessage({
+        id: "msg2",
+        role: "user",
+        parts: [{ type: "text", text: "Hello" }],
+        metadata: { historySequence: 2, timestamp: Date.now() },
+      });
+
+      // Todos should be cleared when new user message arrives
+      expect(aggregator.getCurrentTodos()).toHaveLength(0);
+    });
+  });
 });