WIP

Signed-off-by: Thomas Kosiewski <tk@coder.com>

Author: ThomasK33

src/browser/components/AIView.tsx

@@ -314,10 +314,12 @@ const AIViewInner: React.FC<AIViewProps> = ({
   }
 
   // Extract state from workspace state
-  const { messages, canInterrupt, isCompacting, loading, currentModel } = workspaceState;
+  const { messages, canInterrupt, isCompacting, loading, currentModel, pendingScriptExecution } =
+    workspaceState;
 
   // Get active stream message ID for token counting
   const activeStreamMessageId = aggregator.getActiveStreamMessageId();
+  const isScriptExecutionPending = Boolean(pendingScriptExecution);
 
   // Note: We intentionally do NOT reset autoRetry when streams start.
   // If user pressed the interrupt key, autoRetry stays false until they manually retry.
@@ -377,6 +379,33 @@ const AIViewInner: React.FC<AIViewProps> = ({
     );
   }
 
+  const interruptKeybindDisplay = formatKeybind(
+    vimEnabled ? KEYBINDS.INTERRUPT_STREAM_VIM : KEYBINDS.INTERRUPT_STREAM_NORMAL
+  );
+  const acceptEarlyKeybind = formatKeybind(KEYBINDS.ACCEPT_EARLY_COMPACTION);
+  const streamingStatusText = pendingScriptExecution
+    ? `${pendingScriptExecution.command} running...`
+    : isCompacting
+      ? currentModel
+        ? `${getModelName(currentModel)} compacting...`
+        : "compacting..."
+      : currentModel
+        ? `${getModelName(currentModel)} streaming...`
+        : "streaming...";
+  const streamingCancelText = pendingScriptExecution
+    ? `hit ${interruptKeybindDisplay} to cancel script`
+    : isCompacting
+      ? `${interruptKeybindDisplay} cancel | ${acceptEarlyKeybind} accept early`
+      : `hit ${interruptKeybindDisplay} to cancel`;
+  const streamingTokenCount =
+    isScriptExecutionPending || !activeStreamMessageId
+      ? undefined
+      : aggregator.getStreamingTokenCount(activeStreamMessageId);
+  const streamingTPS =
+    isScriptExecutionPending || !activeStreamMessageId
+      ? undefined
+      : aggregator.getStreamingTPS(activeStreamMessageId);
+
   return (
     <div
       className={cn(
@@ -469,30 +498,10 @@ const AIViewInner: React.FC<AIViewProps> = ({
               <PinnedTodoList workspaceId={workspaceId} />
               {canInterrupt && (
                 <StreamingBarrier
-                  statusText={
-                    isCompacting
-                      ? currentModel
-                        ? `${getModelName(currentModel)} compacting...`
-                        : "compacting..."
-                      : currentModel
-                        ? `${getModelName(currentModel)} streaming...`
-                        : "streaming..."
-                  }
-                  cancelText={
-                    isCompacting
-                      ? `${formatKeybind(vimEnabled ? KEYBINDS.INTERRUPT_STREAM_VIM : KEYBINDS.INTERRUPT_STREAM_NORMAL)} cancel | ${formatKeybind(KEYBINDS.ACCEPT_EARLY_COMPACTION)} accept early`
-                      : `hit ${formatKeybind(vimEnabled ? KEYBINDS.INTERRUPT_STREAM_VIM : KEYBINDS.INTERRUPT_STREAM_NORMAL)} to cancel`
-                  }
-                  tokenCount={
-                    activeStreamMessageId
-                      ? aggregator.getStreamingTokenCount(activeStreamMessageId)
-                      : undefined
-                  }
-                  tps={
-                    activeStreamMessageId
-                      ? aggregator.getStreamingTPS(activeStreamMessageId)
-                      : undefined
-                  }
+                  statusText={streamingStatusText}
+                  cancelText={streamingCancelText}
+                  tokenCount={streamingTokenCount}
+                  tps={streamingTPS}
                 />
               )}
               {workspaceState?.queuedMessage && (

src/browser/stores/WorkspaceStore.test.ts

@@ -1,4 +1,7 @@
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
+import { createMuxMessage } from "@/common/types/message";
+import type { WorkspaceChatMessage } from "@/common/types/ipc";
+import type { BashToolResult } from "@/common/types/tools";
 import { DEFAULT_RUNTIME_CONFIG } from "@/common/constants/workspace";
 import { WorkspaceStore } from "./WorkspaceStore";
 
@@ -13,6 +16,13 @@ const mockExecuteBash = jest.fn(() => ({
   },
 }));
 
+const SCRIPT_RESULT: BashToolResult = {
+  success: true,
+  output: "ok",
+  exitCode: 0,
+  wall_duration_ms: 1,
+};
+
 const mockWindow = {
   api: {
     workspace: {
@@ -246,6 +256,55 @@ describe("WorkspaceStore", () => {
     });
   });
 
+  describe("script execution state", () => {
+    it("treats pending scripts as interruptible", async () => {
+      const workspaceId = "script-workspace";
+      createAndAddWorkspace(store, workspaceId);
+
+      const onChatCallback = getOnChatCallback<WorkspaceChatMessage>();
+
+      onChatCallback({ type: "caught-up" });
+
+      const timestamp = Date.now();
+      const baseMetadata = {
+        historySequence: 1,
+        timestamp,
+        muxMetadata: {
+          type: "script-execution" as const,
+          id: "script-exec-1",
+          historySequence: 1,
+          timestamp,
+          command: "/script wait_pr_checks",
+          scriptName: "wait_pr_checks",
+          args: [] as string[],
+        },
+      };
+
+      const scriptMessage = createMuxMessage("script-1", "user", "Run script", baseMetadata);
+      onChatCallback(scriptMessage);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      const pendingState = store.getWorkspaceState(workspaceId);
+      expect(pendingState.canInterrupt).toBe(true);
+      expect(pendingState.pendingScriptExecution).toMatchObject({
+        scriptName: "wait_pr_checks",
+      });
+
+      const completedScript = createMuxMessage("script-1", "user", "Run script", {
+        ...baseMetadata,
+        muxMetadata: {
+          ...baseMetadata.muxMetadata,
+          result: SCRIPT_RESULT,
+        },
+      });
+      onChatCallback(completedScript);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      const finalState = store.getWorkspaceState(workspaceId);
+      expect(finalState.pendingScriptExecution).toBeNull();
+      expect(finalState.canInterrupt).toBe(false);
+    });
+  });
   describe("getWorkspaceState", () => {
     it("should return initial state for newly added workspace", () => {
       createAndAddWorkspace(store, "new-workspace");

src/browser/stores/WorkspaceStore.ts

@@ -9,7 +9,10 @@ import { createMuxMessage } from "@/common/types/message";
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
 import type { WorkspaceChatMessage } from "@/common/types/ipc";
 import type { TodoItem } from "@/common/types/tools";
-import { StreamingMessageAggregator } from "@/browser/utils/messages/StreamingMessageAggregator";
+import {
+  StreamingMessageAggregator,
+  type PendingScriptExecutionInfo,
+} from "@/browser/utils/messages/StreamingMessageAggregator";
 import { updatePersistedState } from "@/browser/hooks/usePersistedState";
 import { getRetryStateKey } from "@/common/constants/storage";
 import { CUSTOM_EVENTS, createCustomEvent } from "@/common/constants/events";
@@ -48,6 +51,7 @@ export interface WorkspaceState {
   recencyTimestamp: number | null;
   todos: TodoItem[];
   agentStatus: { emoji: string; message: string; url?: string } | undefined;
+  pendingScriptExecution: PendingScriptExecutionInfo | null;
   pendingStreamStartTime: number | null;
 }
 
@@ -340,8 +344,9 @@ export class WorkspaceStore {
       const activeStreams = aggregator.getActiveStreams();
       const messages = aggregator.getAllMessages();
       const metadata = this.workspaceMetadata.get(workspaceId);
+      const pendingScriptExecution = aggregator.getPendingScriptExecution();
 
-      const canInterrupt = activeStreams.length > 0 || aggregator.hasPendingScriptExecution();
+      const canInterrupt = activeStreams.length > 0 || pendingScriptExecution !== null;
 
       return {
         name: metadata?.name ?? workspaceId, // Fall back to ID if metadata missing
@@ -356,6 +361,7 @@ export class WorkspaceStore {
         todos: aggregator.getCurrentTodos(),
         agentStatus: aggregator.getAgentStatus(),
         pendingStreamStartTime: aggregator.getPendingStreamStartTime(),
+        pendingScriptExecution,
       };
     });
   }

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

@@ -442,6 +442,10 @@ describe("StreamingMessageAggregator", () => {
 
       aggregator.addMessage(pendingScript);
       expect(aggregator.hasPendingScriptExecution()).toBe(true);
+      expect(aggregator.getPendingScriptExecution()).toMatchObject({
+        scriptName: "wait",
+        command: "/script wait",
+      });
 
       const completedScript = createMuxMessage("script-2", "user", "Run script", {
         historySequence: 1,
@@ -460,6 +464,7 @@ describe("StreamingMessageAggregator", () => {
 
       aggregator.addMessage(completedScript);
       expect(aggregator.hasPendingScriptExecution()).toBe(false);
+      expect(aggregator.getPendingScriptExecution()).toBeNull();
     });
 
     test("clears pending script executions when messages are deleted", () => {
@@ -482,11 +487,16 @@ describe("StreamingMessageAggregator", () => {
 
       aggregator.addMessage(pendingScript);
       expect(aggregator.hasPendingScriptExecution()).toBe(true);
+      expect(aggregator.getPendingScriptExecution()).toMatchObject({
+        scriptName: "cleanup",
+        command: "/script cleanup",
+      });
 
       const deleteEvent: DeleteMessage = { type: "delete", historySequences: [7] };
       aggregator.handleDeleteMessage(deleteEvent);
 
       expect(aggregator.hasPendingScriptExecution()).toBe(false);
+      expect(aggregator.getPendingScriptExecution()).toBeNull();
     });
     test("removes script logs when history is truncated", () => {
       const aggregator = new StreamingMessageAggregator(TEST_CREATED_AT);

src/browser/utils/messages/StreamingMessageAggregator.ts

@@ -33,6 +33,13 @@ import { computeRecencyTimestamp } from "./recency";
 // Full history is still maintained internally for token counting and stats
 const MAX_DISPLAYED_MESSAGES = 128;
 
+export interface PendingScriptExecutionInfo {
+  messageId: string;
+  command: string;
+  scriptName: string;
+  args: string[];
+  timestamp: number;
+}
 interface StreamingContext {
   startTime: number;
   isComplete: boolean;
@@ -100,7 +107,7 @@ export class StreamingMessageAggregator {
   // (or the user retries) so retry UI/backoff logic doesn't misfire on send failures.
 
   private pendingStreamStartTime: number | null = null;
-  private pendingScriptExecutions = new Set<string>();
+  private pendingScriptExecutions = new Map<string, PendingScriptExecutionInfo>();
 
   // Workspace creation timestamp (used for recency calculation)
   // REQUIRED: Backend guarantees every workspace has createdAt via config.ts
@@ -277,26 +284,49 @@ export class StreamingMessageAggregator {
     return this.pendingStreamStartTime;
   }
 
-  private setPendingStreamStartTime(time: number | null): void {
-    this.pendingStreamStartTime = time;
-  }
   hasPendingScriptExecution(): boolean {
     return this.pendingScriptExecutions.size > 0;
   }
 
+  getPendingScriptExecution(): PendingScriptExecutionInfo | null {
+    if (this.pendingScriptExecutions.size === 0) {
+      return null;
+    }
+
+    let latest: PendingScriptExecutionInfo | null = null;
+    for (const info of this.pendingScriptExecutions.values()) {
+      if (!latest || info.timestamp > latest.timestamp) {
+        latest = info;
+      }
+    }
+    return latest;
+  }
+
   private syncScriptExecutionState(message: MuxMessage): void {
     const muxMetadata = message.metadata?.muxMetadata;
     if (muxMetadata?.type === "script-execution" && muxMetadata.result === undefined) {
-      this.pendingScriptExecutions.add(message.id);
-    } else {
-      this.pendingScriptExecutions.delete(message.id);
+      const info: PendingScriptExecutionInfo = {
+        messageId: message.id,
+        command: muxMetadata.command ?? `/script ${muxMetadata.scriptName}`,
+        scriptName: muxMetadata.scriptName,
+        args: Array.isArray(muxMetadata.args) ? muxMetadata.args : [],
+        timestamp: muxMetadata.timestamp ?? message.metadata?.timestamp ?? Date.now(),
+      };
+      this.pendingScriptExecutions.set(message.id, info);
+      return;
     }
+
+    this.pendingScriptExecutions.delete(message.id);
   }
 
   private clearScriptExecutionState(messageId: string): void {
     this.pendingScriptExecutions.delete(messageId);
   }
 
+  private setPendingStreamStartTime(time: number | null): void {
+    this.pendingStreamStartTime = time;
+  }
+
   getActiveStreams(): StreamingContext[] {
     return Array.from(this.activeStreams.values());
   }