🤖 fix: improve status_set tool description and display logic (#466)

## Overview

Fixes two critical bugs with the `status_set` tool and refines
completion status examples.

## Problems Fixed

### 1. Validation failures showed as 'completed' ✓ instead of 'failed' ✗

When `status_set` validation failed (e.g., invalid emoji), the tool
displayed 'completed' status even though it failed. This made users
think validation was silently failing, especially when the status didn't
appear in the sidebar.

**Root cause:** Tool status determination only checked `part.state ===
'output-available'` (meaning the tool returned a result), but didn't
check whether that result indicated success or failure via
`result.success`.

### 2. Status didn't persist across page reloads or workspace switches

Workspaces with successful `status_set` calls would lose their status
after reload because `loadHistoricalMessages()` didn't reconstruct
derived state from tool results.

**Root cause:** Derived state (agentStatus, currentTodos) was only
updated during live streaming events, not when loading historical
messages.

## Solutions

### 1. Show 'failed' status for validation errors

- Enhanced status determination to check `result.success` for tools
returning `{ success: boolean }`
- Extracted `hasSuccessResult()` and `hasFailureResult()` helpers to
eliminate duplication
- Display error message in StatusSetToolCall UI when validation fails

### 2. Shared tool result processing

Extracted `processToolResult()` as single source of truth for updating
derived state. Called from:
1. **`handleToolCallEnd()`** - live streaming events
2. **`loadHistoricalMessages()`** - historical message loading

This ensures agentStatus and currentTodos are reconstructed uniformly
whether processing live events or historical snapshots.

### 3. Refined completion status examples

Replaced generic examples with outcome-specific ones that show variety:
- ✅ Success: 'PR checks pass and ready to merge'
- ❌ Failure: 'CreateWorkspace Tests failed'  
- ⚠️ Warning: 'Encountered serious issue with design'

Encourages agents to communicate actual outcomes, not just completion.

## Implementation Details

**Status determination (StreamingMessageAggregator.ts:772-789):**
```typescript
if (part.state === "output-available") {
  status = hasFailureResult(part.output) ? "failed" : "completed";
}
```

**Shared result processing (StreamingMessageAggregator.ts:530-552):**
```typescript
private processToolResult(toolName: string, input: unknown, output: unknown): void {
  if (toolName === "todo_write" && hasSuccessResult(output)) {
    // Update todos...
  }
  if (toolName === "status_set" && hasSuccessResult(output)) {
    // Update agentStatus...
  }
}
```

**Historical message processing
(StreamingMessageAggregator.ts:199-213):**
```typescript
loadHistoricalMessages(messages: CmuxMessage[]): void {
  for (const message of messages) {
    this.messages.set(message.id, message);
    if (message.role === "assistant") {
      for (const part of message.parts) {
        if (isDynamicToolPart(part) && part.state === "output-available") {
          this.processToolResult(part.toolName, part.input, part.output);
        }
      }
    }
  }
}
```

## Testing

- Added 5 new unit tests for status persistence and validation display
- All 842 tests pass
- Typecheck and lint pass

**New tests:**
1. Show 'failed' status when validation fails
2. Show 'completed' status when validation succeeds
3. Reconstruct agentStatus from historical messages
4. Use most recent status when loading multiple messages
5. Don't reconstruct from failed status_set

## Before/After

### Validation Failure Display
**Before:**
```
status_set({ emoji: "not-emoji", message: "test" })
→ Shows: completed ✓
→ Sidebar: No status appears
→ User: "Is validation failing silently?" 🤔
```

**After:**
```
status_set({ emoji: "not-emoji", message: "test" })
→ Shows: failed ✗ (emoji must be a single emoji character)
→ Sidebar: No status appears (correct - validation failed)
→ User: Clear feedback! ✨
```

### Status Persistence
**Before:**
```
1. Agent sets status: "🔍 Analyzing code"
2. Reload page or switch workspace
3. Status disappears (even though it was successful)
```

**After:**
```
1. Agent sets status: "🔍 Analyzing code"
2. Reload page or switch workspace
3. Status persists ✅
```

## Architecture Benefits

1. **Single source of truth**: One method processes tool results,
regardless of source
2. **Leverages existing data**: Tool parts already contain everything we
need
3. **No special reconstruction logic**: Just process parts uniformly
4. **Easier to extend**: Adding new derived state only requires updating
`processToolResult()`
5. **Matches architecture**: Historical messages are complete snapshots

_Generated with `cmux`_

Author: ammar-agent

src/components/tools/StatusSetToolCall.tsx

@@ -12,11 +12,17 @@ interface StatusSetToolCallProps {
 
 export const StatusSetToolCall: React.FC<StatusSetToolCallProps> = ({
   args,
-  result: _result,
+  result,
   status = "pending",
 }) => {
   const statusDisplay = getStatusDisplay(status);
 
+  // Show error message if validation failed
+  const errorMessage =
+    status === "failed" && result && typeof result === "object" && "error" in result
+      ? String(result.error)
+      : undefined;
+
   return (
     <ToolContainer expanded={false}>
       <ToolHeader>
@@ -25,6 +31,7 @@ export const StatusSetToolCall: React.FC<StatusSetToolCallProps> = ({
           <Tooltip>status_set</Tooltip>
         </TooltipWrapper>
         <span className="text-muted-foreground italic">{args.message}</span>
+        {errorMessage && <span className="text-error-foreground text-sm">({errorMessage})</span>}
         <StatusIndicator status={status}>{statusDisplay}</StatusIndicator>
       </ToolHeader>
     </ToolContainer>

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,253 @@ describe("StreamingMessageAggregator - Agent Status", () => {
     // Status persists after stream ends
     expect(aggregator.getAgentStatus()?.message).toBe("First task");
 
-    // Start a NEW stream - status should be cleared
+    // 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 user message
+    expect(aggregator.getAgentStatus()).toBeUndefined();
+  });
+
+  it("should show 'failed' status in UI when status_set validation fails", () => {
+    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
+    const messageId = "msg1";
+
+    // Start a stream
+    aggregator.handleStreamStart({
+      type: "stream-start",
+      workspaceId: "workspace1",
+      messageId,
+      model: "test-model",
+      historySequence: 1,
+    });
+
+    // Add a status_set tool call with invalid emoji
+    aggregator.handleToolCallStart({
+      type: "tool-call-start",
+      workspaceId: "workspace1",
+      messageId,
+      toolCallId: "tool1",
+      toolName: "status_set",
+      args: { emoji: "not-an-emoji", message: "test" },
+      tokens: 10,
+      timestamp: Date.now(),
+    });
+
+    // Complete with validation failure
+    aggregator.handleToolCallEnd({
+      type: "tool-call-end",
+      workspaceId: "workspace1",
+      messageId,
+      toolCallId: "tool1",
+      toolName: "status_set",
+      result: { success: false, error: "emoji must be a single emoji character" },
+    });
+
+    // End the stream to finalize message
+    aggregator.handleStreamEnd({
+      type: "stream-end",
+      workspaceId: "workspace1",
+      messageId,
+      metadata: { model: "test-model" },
+      parts: [],
+    });
+
+    // Check that the tool message shows 'failed' status in the UI
+    const displayedMessages = aggregator.getDisplayedMessages();
+    const toolMessage = displayedMessages.find((m) => m.type === "tool");
+    expect(toolMessage).toBeDefined();
+    expect(toolMessage?.type).toBe("tool");
+    if (toolMessage?.type === "tool") {
+      expect(toolMessage.status).toBe("failed");
+      expect(toolMessage.toolName).toBe("status_set");
+    }
+
+    // And status should NOT be updated in aggregator
+    expect(aggregator.getAgentStatus()).toBeUndefined();
+  });
+
+  it("should show 'completed' status in UI when status_set validation succeeds", () => {
+    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
+    const messageId = "msg1";
+
+    // Start a stream
     aggregator.handleStreamStart({
       type: "stream-start",
       workspaceId: "workspace1",
-      messageId: "msg2",
+      messageId,
       model: "test-model",
-      historySequence: 2,
+      historySequence: 1,
+    });
+
+    // Add a successful status_set tool call
+    aggregator.handleToolCallStart({
+      type: "tool-call-start",
+      workspaceId: "workspace1",
+      messageId,
+      toolCallId: "tool1",
+      toolName: "status_set",
+      args: { emoji: "🔍", message: "Analyzing code" },
+      tokens: 10,
+      timestamp: Date.now(),
+    });
+
+    // Complete successfully
+    aggregator.handleToolCallEnd({
+      type: "tool-call-end",
+      workspaceId: "workspace1",
+      messageId,
+      toolCallId: "tool1",
+      toolName: "status_set",
+      result: { success: true, emoji: "🔍", message: "Analyzing code" },
+    });
+
+    // End the stream to finalize message
+    aggregator.handleStreamEnd({
+      type: "stream-end",
+      workspaceId: "workspace1",
+      messageId,
+      metadata: { model: "test-model" },
+      parts: [],
     });
 
-    // Status should be cleared on new stream start
+    // Check that the tool message shows 'completed' status in the UI
+    const displayedMessages = aggregator.getDisplayedMessages();
+    const toolMessage = displayedMessages.find((m) => m.type === "tool");
+    expect(toolMessage).toBeDefined();
+    expect(toolMessage?.type).toBe("tool");
+    if (toolMessage?.type === "tool") {
+      expect(toolMessage.status).toBe("completed");
+      expect(toolMessage.toolName).toBe("status_set");
+    }
+
+    // And status SHOULD be updated in aggregator
+    const status = aggregator.getAgentStatus();
+    expect(status).toBeDefined();
+    expect(status?.emoji).toBe("🔍");
+    expect(status?.message).toBe("Analyzing code");
+  });
+
+  it("should reconstruct agentStatus when loading historical messages", () => {
+    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
+
+    // Create historical messages with a completed status_set tool call
+    const historicalMessages = [
+      {
+        id: "msg1",
+        role: "user" as const,
+        parts: [{ type: "text" as const, text: "Hello" }],
+        metadata: { timestamp: Date.now(), historySequence: 1 },
+      },
+      {
+        id: "msg2",
+        role: "assistant" as const,
+        parts: [
+          { type: "text" as const, text: "Working on it..." },
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "tool1",
+            toolName: "status_set",
+            state: "output-available" as const,
+            input: { emoji: "🔍", message: "Analyzing code" },
+            output: { success: true, emoji: "🔍", message: "Analyzing code" },
+            timestamp: Date.now(),
+          },
+        ],
+        metadata: { timestamp: Date.now(), historySequence: 2 },
+      },
+    ];
+
+    // Load historical messages
+    aggregator.loadHistoricalMessages(historicalMessages);
+
+    // Status should be reconstructed from the historical tool call
+    const status = aggregator.getAgentStatus();
+    expect(status).toBeDefined();
+    expect(status?.emoji).toBe("🔍");
+    expect(status?.message).toBe("Analyzing code");
+  });
+
+  it("should use most recent status_set when loading multiple historical messages", () => {
+    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
+
+    // Create historical messages with multiple status_set calls
+    const historicalMessages = [
+      {
+        id: "msg1",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "tool1",
+            toolName: "status_set",
+            state: "output-available" as const,
+            input: { emoji: "🔍", message: "First status" },
+            output: { success: true, emoji: "🔍", message: "First status" },
+            timestamp: Date.now(),
+          },
+        ],
+        metadata: { timestamp: Date.now(), historySequence: 1 },
+      },
+      {
+        id: "msg2",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "tool2",
+            toolName: "status_set",
+            state: "output-available" as const,
+            input: { emoji: "📝", message: "Second status" },
+            output: { success: true, emoji: "📝", message: "Second status" },
+            timestamp: Date.now(),
+          },
+        ],
+        metadata: { timestamp: Date.now(), historySequence: 2 },
+      },
+    ];
+
+    // Load historical messages
+    aggregator.loadHistoricalMessages(historicalMessages);
+
+    // Should use the most recent (last processed) status
+    const status = aggregator.getAgentStatus();
+    expect(status?.emoji).toBe("📝");
+    expect(status?.message).toBe("Second status");
+  });
+
+  it("should not reconstruct status from failed status_set in historical messages", () => {
+    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
+
+    // Create historical message with failed status_set
+    const historicalMessages = [
+      {
+        id: "msg1",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "tool1",
+            toolName: "status_set",
+            state: "output-available" as const,
+            input: { emoji: "not-emoji", message: "test" },
+            output: { success: false, error: "emoji must be a single emoji character" },
+            timestamp: Date.now(),
+          },
+        ],
+        metadata: { timestamp: Date.now(), historySequence: 1 },
+      },
+    ];
+
+    // Load historical messages
+    aggregator.loadHistoricalMessages(historicalMessages);
+
+    // Status should remain undefined (failed validation)
     expect(aggregator.getAgentStatus()).toBeUndefined();
   });
 });