🤖 Fix lint errors and add italic styling to status message

Lint fixes:
- Removed unused imports (useGitStatus, TooltipWrapper, Tooltip) from AIView.tsx
- Removed unused agentStatus variable from AIView.tsx
- Removed async from status_set tool execute (no await needed)
- Added proper type assertions to test results to satisfy TypeScript strict checks
- Ran prettier to fix formatting issues

Visual improvement:
- Added italic class to status message text in StatusSetToolCall
- Creates visual distinction from other tool call headers

Generated with `cmux`

Author: ammar-agent

src/components/AIView.tsx

@@ -23,9 +23,6 @@ import { useThinking } from "@/contexts/ThinkingContext";
 import { useWorkspaceState, useWorkspaceAggregator } from "@/stores/WorkspaceStore";
 import { WorkspaceHeader } from "./WorkspaceHeader";
 import { getModelName } from "@/utils/ai/models";
-
-import { useGitStatus } from "@/stores/GitStatusStore";
-import { TooltipWrapper, Tooltip } from "./Tooltip";
 import type { DisplayedMessage } from "@/types/message";
 import type { RuntimeConfig } from "@/types/runtime";
 import { useAIViewKeybinds } from "@/hooks/useAIViewKeybinds";
@@ -265,7 +262,7 @@ const AIViewInner: React.FC<AIViewProps> = ({
   }
 
   // Extract state from workspace state
-  const { messages, canInterrupt, isCompacting, loading, currentModel, agentStatus } = workspaceState;
+  const { messages, canInterrupt, isCompacting, loading, currentModel } = workspaceState;
 
   // Get active stream message ID for token counting
   const activeStreamMessageId = aggregator.getActiveStreamMessageId();

src/components/WorkspaceHeader.tsx

@@ -60,4 +60,3 @@ export const WorkspaceHeader: React.FC<WorkspaceHeaderProps> = ({
     </div>
   );
 };
-

src/components/tools/StatusSetToolCall.tsx

@@ -24,7 +24,7 @@ export const StatusSetToolCall: React.FC<StatusSetToolCallProps> = ({
           <span>{args.emoji}</span>
           <Tooltip>status_set</Tooltip>
         </TooltipWrapper>
-        <span className="text-muted-foreground">{args.message}</span>
+        <span className="italic text-muted-foreground">{args.message}</span>
         <StatusIndicator status={status}>{statusDisplay}</StatusIndicator>
       </ToolHeader>
     </ToolContainer>

src/services/tools/status_set.test.ts

@@ -22,75 +22,118 @@ describe("status_set tool validation", () => {
 
       const emojis = ["🔍", "📝", "✅", "🚀", "⏳"];
       for (const emoji of emojis) {
-        const result = await tool.execute!({ emoji, message: "Test" }, mockToolCallOptions);
+        const result = (await tool.execute!({ emoji, message: "Test" }, mockToolCallOptions)) as {
+          success: boolean;
+          emoji: string;
+          message: string;
+        };
         expect(result).toEqual({ success: true, emoji, message: "Test" });
       }
     });
 
     it("should reject multiple emojis", async () => {
       const tool = createStatusSetTool(mockConfig);
 
-      const result1 = await tool.execute!({ emoji: "🔍📝", message: "Test" }, mockToolCallOptions);
-      expect(result1).toEqual({ success: false, error: "emoji must be a single emoji character" });
+      const result1 = (await tool.execute!(
+        { emoji: "🔍📝", message: "Test" },
+        mockToolCallOptions
+      )) as { success: boolean; error: string };
+      expect(result1.success).toBe(false);
+      expect(result1.error).toBe("emoji must be a single emoji character");
 
-      const result2 = await tool.execute!({ emoji: "✅✅", message: "Test" }, mockToolCallOptions);
-      expect(result2).toEqual({ success: false, error: "emoji must be a single emoji character" });
+      const result2 = (await tool.execute!(
+        { emoji: "✅✅", message: "Test" },
+        mockToolCallOptions
+      )) as { success: boolean; error: string };
+      expect(result2.success).toBe(false);
+      expect(result2.error).toBe("emoji must be a single emoji character");
     });
 
     it("should reject text (non-emoji)", async () => {
       const tool = createStatusSetTool(mockConfig);
 
-      const result1 = await tool.execute!({ emoji: "a", message: "Test" }, mockToolCallOptions);
-      expect(result1).toEqual({ success: false, error: "emoji must be a single emoji character" });
-
-      const result2 = await tool.execute!({ emoji: "abc", message: "Test" }, mockToolCallOptions);
-      expect(result2).toEqual({ success: false, error: "emoji must be a single emoji character" });
+      const result1 = (await tool.execute!(
+        { emoji: "a", message: "Test" },
+        mockToolCallOptions
+      )) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result1.success).toBe(false);
+      expect(result1.error).toBe("emoji must be a single emoji character");
+
+      const result2 = (await tool.execute!(
+        { emoji: "abc", message: "Test" },
+        mockToolCallOptions
+      )) as { success: boolean; error: string };
+      expect(result2.success).toBe(false);
+      expect(result2.error).toBe("emoji must be a single emoji character");
 
-      const result3 = await tool.execute!({ emoji: "!", message: "Test" }, mockToolCallOptions);
-      expect(result3).toEqual({ success: false, error: "emoji must be a single emoji character" });
+      const result3 = (await tool.execute!(
+        { emoji: "!", message: "Test" },
+        mockToolCallOptions
+      )) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result3.success).toBe(false);
+      expect(result3.error).toBe("emoji must be a single emoji character");
     });
 
     it("should reject empty emoji", async () => {
       const tool = createStatusSetTool(mockConfig);
 
-      const result = await tool.execute!({ emoji: "", message: "Test" }, mockToolCallOptions);
-      expect(result).toEqual({ success: false, error: "emoji must be a single emoji character" });
+      const result = (await tool.execute!({ emoji: "", message: "Test" }, mockToolCallOptions)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("emoji must be a single emoji character");
     });
 
     it("should reject emoji with text", async () => {
       const tool = createStatusSetTool(mockConfig);
 
-      const result1 = await tool.execute!({ emoji: "🔍a", message: "Test" }, mockToolCallOptions);
-      expect(result1).toEqual({ success: false, error: "emoji must be a single emoji character" });
+      const result1 = (await tool.execute!(
+        { emoji: "🔍a", message: "Test" },
+        mockToolCallOptions
+      )) as { success: boolean; error: string };
+      expect(result1.success).toBe(false);
+      expect(result1.error).toBe("emoji must be a single emoji character");
 
-      const result2 = await tool.execute!({ emoji: "x🔍", message: "Test" }, mockToolCallOptions);
-      expect(result2).toEqual({ success: false, error: "emoji must be a single emoji character" });
+      const result2 = (await tool.execute!(
+        { emoji: "x🔍", message: "Test" },
+        mockToolCallOptions
+      )) as { success: boolean; error: string };
+      expect(result2.success).toBe(false);
+      expect(result2.error).toBe("emoji must be a single emoji character");
     });
   });
 
   describe("message validation", () => {
     it("should accept messages up to 40 characters", async () => {
       const tool = createStatusSetTool(mockConfig);
 
-      const result1 = await tool.execute!(
+      const result1 = (await tool.execute!(
         { emoji: "✅", message: "a".repeat(40) },
         mockToolCallOptions
-      );
+      )) as { success: boolean };
       expect(result1.success).toBe(true);
 
-      const result2 = await tool.execute!(
+      const result2 = (await tool.execute!(
         { emoji: "✅", message: "Analyzing code structure" },
         mockToolCallOptions
-      );
+      )) as { success: boolean };
       expect(result2.success).toBe(true);
     });
 
     it("should accept empty message", async () => {
       const tool = createStatusSetTool(mockConfig);
 
-      const result = await tool.execute!({ emoji: "✅", message: "" }, mockToolCallOptions);
+      const result = (await tool.execute!({ emoji: "✅", message: "" }, mockToolCallOptions)) as {
+        success: boolean;
+      };
       expect(result.success).toBe(true);
     });
   });
 });
-

src/services/tools/status_set.ts

@@ -41,23 +41,22 @@ export const createStatusSetTool: ToolFactory = () => {
   return tool({
     description: TOOL_DEFINITIONS.status_set.description,
     inputSchema: TOOL_DEFINITIONS.status_set.schema,
-    execute: async ({ emoji, message }): Promise<StatusSetToolResult> => {
+    execute: ({ emoji, message }): Promise<StatusSetToolResult> => {
       // Validate emoji
       if (!isValidEmoji(emoji)) {
-        return {
+        return Promise.resolve({
           success: false,
           error: "emoji must be a single emoji character",
-        };
+        });
       }
 
       // Tool execution is a no-op on the backend
       // The status is tracked by StreamingMessageAggregator and displayed in the frontend
-      return {
+      return Promise.resolve({
         success: true,
         emoji,
         message,
-      };
+      });
     },
   });
 };
-

src/types/tools.ts

@@ -174,4 +174,3 @@ export type StatusSetToolResult =
       success: false;
       error: string;
     };
-

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

@@ -258,4 +258,3 @@ describe("StreamingMessageAggregator - Agent Status", () => {
     expect(aggregator.getAgentStatus()).toBeUndefined();
   });
 });
-

src/utils/ui/statusTooltip.tsx

@@ -45,4 +45,3 @@ export function getStatusTooltip(options: {
 
   return "Idle";
 }
-