🤖 refactor: simplify status_set polling and drop persistence

Author: ammar-agent

src/browser/components/tools/StatusSetToolCall.tsx

@@ -24,7 +24,8 @@ export const StatusSetToolCall: React.FC<StatusSetToolCallProps> = ({
 
   const iconEmoji = "📡";
 
-  const summary = `poll=${args.poll_interval_ms}ms: ${args.script.split(/\r?\n/)[0] ?? ""}`;
+  const pollLabel = args.poll_interval_s === undefined ? "once" : `${args.poll_interval_s}s`;
+  const summary = `poll=${pollLabel}: ${args.script.split(/\r?\n/)[0] ?? ""}`;
 
   return (
     <ToolContainer expanded={false}>

src/browser/stories/App.chat.stories.tsx

@@ -204,7 +204,7 @@ export const WithAgentStatus: AppStory = {
                   createStatusTool(
                     "call-1",
                     "echo '🚀 PR #1234 waiting for CI https://github.com/example/repo/pull/1234'",
-                    5000
+                    5
                   ),
                 ],
               }

src/browser/stories/App.demo.stories.tsx

@@ -198,7 +198,7 @@ export const Comprehensive: AppStory = {
               createStatusTool(
                 "call-4",
                 "echo '🚀 PR #1234 waiting for CI https://github.com/example/repo/pull/1234'",
-                5000
+                5
               ),
             ],
           }),

src/browser/stories/mockFactory.ts

@@ -292,14 +292,14 @@ export function createTerminalTool(
 export function createStatusTool(
   toolCallId: string,
   script: string,
-  pollIntervalMs: number
+  pollIntervalS?: number
 ): MuxPart {
   return {
     type: "dynamic-tool",
     toolCallId,
     toolName: "status_set",
     state: "output-available",
-    input: { script, poll_interval_ms: pollIntervalMs },
+    input: { script, ...(pollIntervalS !== undefined ? { poll_interval_s: pollIntervalS } : {}) },
     output: { success: true },
   };
 }

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

@@ -1,51 +1,6 @@
-import { afterAll, afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { getStatusStateKey } from "@/common/constants/storage";
+import { describe, expect, it } from "bun:test";
 import { StreamingMessageAggregator } from "./StreamingMessageAggregator";
 
-const originalLocalStorage: Storage | undefined = (globalThis as { localStorage?: Storage })
-  .localStorage;
-
-const createMockLocalStorage = () => {
-  const store = new Map<string, string>();
-  return {
-    get length() {
-      return store.size;
-    },
-    key: (index: number) => Array.from(store.keys())[index] ?? null,
-    getItem: (key: string) => (store.has(key) ? store.get(key)! : null),
-    setItem: (key: string, value: string) => {
-      store.set(key, value);
-    },
-    removeItem: (key: string) => {
-      store.delete(key);
-    },
-    clear: () => {
-      store.clear();
-    },
-  } satisfies Storage;
-};
-
-beforeEach(() => {
-  const mock = createMockLocalStorage();
-  Object.defineProperty(globalThis, "localStorage", {
-    value: mock,
-    configurable: true,
-  });
-});
-
-afterEach(() => {
-  const ls = (globalThis as { localStorage?: Storage }).localStorage;
-  ls?.clear?.();
-});
-
-afterAll(() => {
-  if (originalLocalStorage !== undefined) {
-    Object.defineProperty(globalThis, "localStorage", { value: originalLocalStorage });
-  } else {
-    delete (globalThis as { localStorage?: Storage }).localStorage;
-  }
-});
-
 describe("StreamingMessageAggregator - Agent Status", () => {
   it("should start with undefined agent status", () => {
     const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
@@ -111,7 +66,6 @@ describe("StreamingMessageAggregator - Agent Status", () => {
       toolName: "status_set",
       args: {
         script: "echo '🚀 PR #1 https://github.com/example/repo/pull/1'",
-        poll_interval_ms: 0,
       },
       tokens: 10,
       timestamp: Date.now(),
@@ -268,7 +222,7 @@ describe("StreamingMessageAggregator - Agent Status", () => {
       messageId,
       toolCallId: "tool1",
       toolName: "status_set",
-      args: { script: "echo 'not important'", poll_interval_ms: 0 },
+      args: { script: "echo 'not important'" },
       tokens: 10,
       timestamp: Date.now(),
     });
@@ -329,7 +283,6 @@ describe("StreamingMessageAggregator - Agent Status", () => {
       toolName: "status_set",
       args: {
         script: "echo '🚀 PR #1 https://github.com/example/repo/pull/1'",
-        poll_interval_ms: 0,
       },
       tokens: 10,
       timestamp: Date.now(),
@@ -390,8 +343,8 @@ describe("StreamingMessageAggregator - Agent Status", () => {
             toolCallId: "tool1",
             toolName: "status_set",
             state: "output-available" as const,
-            input: { emoji: "🔍", message: "Analyzing code" },
-            output: { success: true, emoji: "🔍", message: "Analyzing code" },
+            input: { script: "echo 'Analyzing code'" },
+            output: { success: true },
             timestamp: Date.now(),
           },
         ],
@@ -406,167 +359,6 @@ describe("StreamingMessageAggregator - Agent Status", () => {
     expect(aggregator.getAgentStatus()).toBeUndefined();
   });
 
-  it("should not reconstruct agent status even if multiple historical status_set tool calls exist", () => {
-    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);
-
-    expect(aggregator.getAgentStatus()).toBeUndefined();
-  });
-
-  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();
-  });
-
-  it("should retain last status_set even if later assistant messages omit it", () => {
-    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
-
-    const historicalMessages = [
-      {
-        id: "assistant1",
-        role: "assistant" as const,
-        parts: [
-          {
-            type: "dynamic-tool" as const,
-            toolCallId: "tool1",
-            toolName: "status_set",
-            state: "output-available" as const,
-            input: { emoji: "🧪", message: "Running tests" },
-            output: { success: true, emoji: "🧪", message: "Running tests" },
-            timestamp: 1000,
-          },
-        ],
-        metadata: { timestamp: 1000, historySequence: 1 },
-      },
-      {
-        id: "assistant2",
-        role: "assistant" as const,
-        parts: [{ type: "text" as const, text: "[compaction summary]" }],
-        metadata: { timestamp: 2000, historySequence: 2 },
-      },
-    ];
-
-    aggregator.loadHistoricalMessages(historicalMessages);
-
-    const status = aggregator.getAgentStatus();
-    expect(status?.emoji).toBe("🧪");
-    expect(status?.message).toBe("Running tests");
-  });
-
-  it("should restore persisted status when history is compacted away", () => {
-    const workspaceId = "workspace1";
-    const persistedStatus = {
-      emoji: "🔗",
-      message: "PR open",
-      url: "https://example.com/pr/123",
-    } as const;
-    localStorage.setItem(getStatusStateKey(workspaceId), JSON.stringify(persistedStatus));
-
-    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z", workspaceId);
-
-    // History with no status_set (e.g., after compaction removes older tool calls)
-    const historicalMessages = [
-      {
-        id: "assistant2",
-        role: "assistant" as const,
-        parts: [{ type: "text" as const, text: "[compacted history]" }],
-        metadata: { timestamp: 3000, historySequence: 1 },
-      },
-    ];
-
-    aggregator.loadHistoricalMessages(historicalMessages);
-
-    expect(aggregator.getAgentStatus()).toEqual(persistedStatus);
-  });
-
-  it("should rehydrate agent status from persisted localStorage", () => {
-    const workspaceId = "workspace1";
-    const key = getStatusStateKey(workspaceId);
-
-    const aggregator1 = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
-    aggregator1.handleMessage({
-      type: "agent-status-update",
-      workspaceId,
-      status: {
-        emoji: "🚀",
-        message: "PR #1 checks running",
-        url: "https://github.com/example/repo/pull/1",
-      },
-    });
-
-    expect((globalThis as { localStorage: Storage }).localStorage.getItem(key)).not.toBeNull();
-
-    const aggregator2 = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
-    expect(aggregator2.getAgentStatus()).toEqual({
-      emoji: "🚀",
-      message: "PR #1 checks running",
-      url: "https://github.com/example/repo/pull/1",
-    });
-  });
-
   it("should store URL when provided in agent-status-update", () => {
     const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
 
@@ -673,69 +465,4 @@ describe("StreamingMessageAggregator - Agent Status", () => {
       url: testUrl,
     });
   });
-
-  it("should not reconstruct URL from history tool calls", () => {
-    // status is ephemeral and persisted outside chat history; historical tool calls should not
-    // reconstruct the status/link.
-    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
-    const testUrl = "https://github.com/owner/repo/pull/123";
-
-    // Historical messages: first assistant sets URL, second assistant updates status without URL
-    const historicalMessages = [
-      {
-        id: "user1",
-        role: "user" as const,
-        parts: [{ type: "text" as const, text: "Make a PR" }],
-        metadata: { timestamp: 1000, historySequence: 1 },
-      },
-      {
-        id: "assistant1",
-        role: "assistant" as const,
-        parts: [
-          {
-            type: "dynamic-tool" as const,
-            toolName: "status_set",
-            toolCallId: "tool1",
-            state: "output-available" as const,
-            input: { emoji: "🔗", message: "PR submitted", url: testUrl },
-            output: { success: true, emoji: "🔗", message: "PR submitted", url: testUrl },
-            timestamp: 1001,
-            tokens: 10,
-          },
-        ],
-        metadata: { timestamp: 1001, historySequence: 2 },
-      },
-      {
-        id: "user2",
-        role: "user" as const,
-        parts: [{ type: "text" as const, text: "Continue" }],
-        metadata: { timestamp: 2000, historySequence: 3 },
-      },
-      {
-        id: "assistant2",
-        role: "assistant" as const,
-        parts: [
-          {
-            type: "dynamic-tool" as const,
-            toolName: "status_set",
-            toolCallId: "tool2",
-            state: "output-available" as const,
-            input: { emoji: "✅", message: "Tests passed" },
-            output: { success: true, emoji: "✅", message: "Tests passed" }, // No URL!
-            timestamp: 2001,
-            tokens: 10,
-          },
-        ],
-        metadata: { timestamp: 2001, historySequence: 4 },
-      },
-    ];
-
-    aggregator.loadHistoricalMessages(historicalMessages);
-
-    expect(aggregator.getAgentStatus()).toBeUndefined();
-  });
-
-  // Note: URL persistence through compaction is handled via localStorage,
-  // which is tested in integration tests. The aggregator saves lastStatusUrl
-  // to localStorage when it changes, and loads it on construction.
 });

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

@@ -312,7 +312,7 @@ describe("StreamingMessageAggregator", () => {
             toolCallId: "tool2",
             toolName: "status_set",
             state: "output-available" as const,
-            input: { script: "echo 'Working on it'", poll_interval_ms: 0 },
+            input: { script: "echo 'Working on it'" },
             output: { success: true },
           },
         ],