🤖 fix: Show 'failed' status when status_set validation fails

## Problem
When status_set validation failed (e.g., invalid emoji), the tool showed
'completed' status in the UI 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',
which is true even for failed results. It didn't check result.success.

## Solution
1. Enhanced status determination to check result.success for tools that
   return { success: boolean } pattern
2. Show 'failed' status when result.success === false
3. Display error message in StatusSetToolCall UI for failed validations

## Testing
- Added unit tests for failed/completed status display
- All 839 tests pass
- Typecheck passes

When validation fails now:
- Tool shows 'failed' status (not 'completed')
- Error message displays in UI
- agentStatus NOT updated (correct existing behavior)
- Clear feedback to user that validation failed

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

@@ -257,4 +257,124 @@ describe("StreamingMessageAggregator - Agent Status", () => {
     // Status should be cleared on new stream start
     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,
+      model: "test-model",
+      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: [],
+    });
+
+    // 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");
+  });
+
 });

src/utils/messages/StreamingMessageAggregator.ts

@@ -769,14 +769,24 @@ export class StreamingMessageAggregator {
                 timestamp: part.timestamp ?? baseTimestamp,
               });
             } else if (isDynamicToolPart(part)) {
-              const status =
-                part.state === "output-available"
-                  ? "completed"
-                  : part.state === "input-available" && message.metadata?.partial
-                    ? "interrupted"
-                    : part.state === "input-available"
-                      ? "executing"
-                      : "pending";
+              // Determine status based on part state and result
+              let status: "pending" | "executing" | "completed" | "failed" | "interrupted";
+              if (part.state === "output-available") {
+                // Check if result indicates failure (for tools that return { success: boolean })
+                const output = part.output as unknown;
+                const isFailed =
+                  typeof output === "object" &&
+                  output !== null &&
+                  "success" in output &&
+                  output.success === false;
+                status = isFailed ? "failed" : "completed";
+              } else if (part.state === "input-available" && message.metadata?.partial) {
+                status = "interrupted";
+              } else if (part.state === "input-available") {
+                status = "executing";
+              } else {
+                status = "pending";
+              }
 
               displayedMessages.push({
                 type: "tool",