🤖 refactor: Clear TODO/status on user message, not stream events

## Problem
Previous implementation cleared state at different times:
- TODOs: Cleared on stream-end (via cleanupStreamState)
- Status: Cleared on stream-start

This created historical/live disparity because stream events aren't persisted
in chat.jsonl. After page reload, TODOs would stick around (desirable!) but
the implementation was inconsistent.

## Solution
Clear BOTH todos and agentStatus when new user message arrives.

Why user messages?
- ✅ Persisted in chat.jsonl (unlike stream events)
- ✅ Consistent live/historical behavior
- ✅ Semantic: New question = new task = clear previous state

## Changes
1. Removed TODO clearing from cleanupStreamState()
2. Removed status clearing from handleStreamStart()
3. Added centralized clearing in handleMessage() when user message arrives
4. Updated test: 'stream-start' → 'new user message'

## Benefits
- Consistent behavior whether loading from history or processing live
- TODOs persist until next question (user preference!)
- Simpler: One place to clear state, not scattered across handlers
- Architecture: Relies on persisted data, not ephemeral events

## Testing
- All 842 tests pass
- Updated test reflects new clearing behavior
- Typecheck and lint pass

Author: ammar-agent

src/utils/messages/StreamingMessageAggregator.status.test.ts

@@ -199,7 +199,7 @@ describe("StreamingMessageAggregator - Agent Status", () => {
     expect(aggregator.getAgentStatus()).toBeUndefined();
   });
 
-  it("should clear agent status on stream-start (different from TODO behavior)", () => {
+  it("should clear agent status when new user message arrives", () => {
     const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
 
     // Start first stream and set status
@@ -245,16 +245,16 @@ describe("StreamingMessageAggregator - Agent Status", () => {
     // Status persists after stream ends
     expect(aggregator.getAgentStatus()?.message).toBe("First task");
 
-    // Start a NEW stream - status should be cleared
-    aggregator.handleStreamStart({
-      type: "stream-start",
-      workspaceId: "workspace1",
-      messageId: "msg2",
-      model: "test-model",
-      historySequence: 2,
-    });
+    // User sends a NEW message - status should be cleared
+    const newUserMessage = {
+      id: "msg2",
+      role: "user" as const,
+      parts: [{ type: "text" as const, text: "What's next?" }],
+      metadata: { timestamp: Date.now(), historySequence: 2 },
+    };
+    aggregator.handleMessage(newUserMessage);
 
-    // Status should be cleared on new stream start
+    // Status should be cleared on new user message
     expect(aggregator.getAgentStatus()).toBeUndefined();
   });
 

src/utils/messages/StreamingMessageAggregator.ts

@@ -167,11 +167,12 @@ export class StreamingMessageAggregator {
   /**
    * Clean up stream-scoped state when stream ends (normally or abnormally).
    * Called by handleStreamEnd, handleStreamAbort, and handleStreamError.
+   *
+   * NOTE: Does NOT clear todos or agentStatus - those are cleared when a new
+   * user message arrives (see handleMessage), ensuring consistent behavior
+   * whether loading from history or processing live events.
    */
   private cleanupStreamState(messageId: string): void {
-    this.currentTodos = [];
-    // NOTE: agentStatus is NOT cleared here - it persists after stream completion
-    // to show the last activity. This is different from todos which are stream-scoped.
     this.activeStreams.delete(messageId);
   }
 
@@ -311,10 +312,9 @@ export class StreamingMessageAggregator {
     // Clear pending stream start timestamp - stream has started
     this.setPendingStreamStartTime(null);
 
-    // Clear agent status on stream start (unlike todos which persist across streams).
-    // Rationale: Status represents current activity, so it should be cleared and reset
-    // for each new stream. Todos represent pending work, so they persist until completion.
-    this.agentStatus = undefined;
+    // NOTE: We do NOT clear agentStatus or currentTodos here.
+    // They are cleared when a new user message arrives (see handleMessage),
+    // ensuring consistent behavior whether loading from history or processing live events.
 
     // Detect if this stream is compacting by checking if last user message is a compaction-request
     const messages = this.getAllMessages();
@@ -649,8 +649,14 @@ export class StreamingMessageAggregator {
       // Now add the new message
       this.addMessage(incomingMessage);
 
-      // If this is a user message, record timestamp for pending stream detection
+      // If this is a user message, clear derived state and record timestamp
       if (incomingMessage.role === "user") {
+        // Clear derived state (todos, agentStatus) for new conversation turn
+        // This ensures consistent behavior whether loading from history or processing live events
+        // since stream-start/stream-end events are not persisted in chat.jsonl
+        this.currentTodos = [];
+        this.agentStatus = undefined;
+
         this.setPendingStreamStartTime(Date.now());
       }
     }