fix(terminal): clean up pending command_output ask on completion

- Supersede a still-pending command_output ask in onCompleted so it
  resolves immediately instead of lingering until the next interactive
  message, and clear the Proceed/Kill controls in the webview when the
  final non-partial command_output say arrives.
- Continue the process for any ask answer, not just typed messages, so a
  non-message response actually backgrounds the command and the tool
  resolves before the process completes.
- Strengthen ask-policy tests: assert the rescheduled ask still fires at
  the re-anchored deadline, assert early resolution for non-message
  answers, and cover ask supersession on completion.

Author: roomote

src/core/tools/ExecuteCommandTool.ts

@@ -374,8 +374,12 @@ export async function executeCommandInTerminal(
 
 			if (response === "messageResponse") {
 				message = { text, images }
-				process.continue()
 			}
+
+			// Any answer means the command should keep running in the background;
+			// continue the process so the tool resolves now instead of blocking
+			// until the command actually completes.
+			process.continue()
 		} catch (_error) {
 			// Silently handle ask errors (e.g., "Current ask promise was ignored")
 		}
@@ -422,6 +426,13 @@ export async function executeCommandInTerminal(
 			clearTimeout(commandOutputAskTimer)
 			commandOutputAskTimer = undefined
 
+			// If an interactive command_output ask is still pending, supersede it
+			// so it resolves immediately instead of lingering until the next
+			// interactive message bumps lastMessageTs.
+			if (hasAskedForCommandOutput && !runInBackground) {
+				task.supersedePendingAsk()
+			}
+
 			clearTimeout(pendingCommandOutputEmitTimer)
 			pendingCommandOutputEmitTimer = undefined
 

src/core/tools/__tests__/executeCommandTool.spec.ts

@@ -78,6 +78,7 @@ describe("executeCommandTool", () => {
 			},
 			recordToolUsage: vitest.fn().mockReturnValue({} as ToolUsage),
 			recordToolError: vitest.fn(),
+			supersedePendingAsk: vitest.fn(),
 			providerRef: {
 				deref: vitest.fn().mockResolvedValue({
 					getState: vitest.fn().mockResolvedValue({
@@ -357,7 +358,12 @@ describe("executeCommandTool", () => {
 			const processPromise = new Promise<void>((resolve) => {
 				state.resolveProcess = resolve
 			})
-			state.proc = Object.assign(processPromise, { continue: vitest.fn(), abort: vitest.fn() })
+			// Mirror real terminal behavior: continue() resolves the wait early
+			// while the command keeps running in the background.
+			state.proc = Object.assign(processPromise, {
+				continue: vitest.fn(() => state.resolveProcess()),
+				abort: vitest.fn(),
+			})
 			;(TerminalRegistry.getOrCreateTerminal as ReturnType<typeof vitest.fn>).mockResolvedValue({
 				runCommand: vitest.fn((_cmd: string, callbacks: RooTerminalCallbacks) => {
 					state.callbacks = callbacks
@@ -480,16 +486,17 @@ describe("executeCommandTool", () => {
 
 		it("re-anchors a pending ask when execution start is reported after early output", async () => {
 			vitest.useFakeTimers()
+			mockCline.ask.mockResolvedValue({ response: "messageResponse", text: "keep going", images: undefined })
 			const terminal = await setupControllableTerminal()
 
-			const handlePromise = handleCommand("echo hello")
+			const handlePromise = handleCommand("sleep 60")
 
 			await vitest.waitFor(() => expect(terminal.callbacks).toBeDefined())
 			const callbacks = terminal.callbacks!
 			const proc = terminal.proc as unknown as RooTerminalProcess
 
 			// Output arrives before the execution-started event (defensive case).
-			await callbacks.onLine("hello\n", proc)
+			await callbacks.onLine("working...\n", proc)
 			await vitest.advanceTimersByTimeAsync(executeCommandModule.COMMAND_OUTPUT_ASK_DELAY_MS - 2_000)
 			callbacks.onShellExecutionStarted!(1234, proc)
 
@@ -498,19 +505,23 @@ describe("executeCommandTool", () => {
 			await vitest.advanceTimersByTimeAsync(2_500)
 			expect(mockCline.ask).not.toHaveBeenCalled()
 
-			await callbacks.onCompleted!("hello\n", proc)
+			// The ask must still fire at the re-anchored deadline — a version
+			// that cleared the old timer without rescheduling would fail here.
+			await vitest.advanceTimersByTimeAsync(2_500)
+			expect(mockCline.ask).toHaveBeenCalledWith("command_output", "")
+
+			// Let the command finish so the tool can resolve.
+			await callbacks.onCompleted!("working...\n", proc)
 			callbacks.onShellExecutionComplete!({ exitCode: 0 }, proc)
-			terminal.resolveProcess()
-			await vitest.advanceTimersByTimeAsync(executeCommandModule.COMMAND_OUTPUT_ASK_DELAY_MS + 1_000)
+			await vitest.advanceTimersByTimeAsync(100)
 
 			await handlePromise
 
-			expect(mockCline.ask).not.toHaveBeenCalled()
+			expect(mockPushToolResult).toHaveBeenCalled()
 		})
 
 		it("cancels a pending ask when the agent timeout moves the command to the background", async () => {
 			vitest.useFakeTimers()
-			mockCline.supersedePendingAsk = vitest.fn()
 			const terminal = await setupControllableTerminal()
 
 			const handlePromise = handleCommand("npm run dev", 2)
@@ -594,7 +605,7 @@ describe("executeCommandTool", () => {
 			expect(mockPushToolResult.mock.calls[0][0]).toContain("Exit code: 0")
 		})
 
-		it("does not continue the process when the ask is answered without a message", async () => {
+		it("resolves before completion when the ask is answered without a message", async () => {
 			vitest.useFakeTimers()
 			mockCline.ask.mockResolvedValue({ response: "yesButtonClicked", text: undefined, images: undefined })
 			const terminal = await setupControllableTerminal()
@@ -609,17 +620,50 @@ describe("executeCommandTool", () => {
 			await callbacks.onLine("working...\n", proc)
 			await vitest.advanceTimersByTimeAsync(executeCommandModule.COMMAND_OUTPUT_ASK_DELAY_MS)
 
+			// Any ask answer backgrounds the command: the process is continued and
+			// the tool resolves without waiting for the command to complete.
+			// Note the process promise is never resolved in this test.
+			await vitest.advanceTimersByTimeAsync(100)
+			await handlePromise
+
 			expect(mockCline.ask).toHaveBeenCalledWith("command_output", "")
-			expect(terminal.proc.continue).not.toHaveBeenCalled()
+			expect(terminal.proc.continue).toHaveBeenCalled()
+			expect(mockPushToolResult).toHaveBeenCalled()
+			expect(mockPushToolResult.mock.calls[0][0]).toContain("still running")
+
+			// Cleanup: let the command finish.
+			await callbacks.onCompleted!("working...\n", proc)
+			callbacks.onShellExecutionComplete!({ exitCode: 0 }, proc)
+		})
+
+		it("supersedes a pending ask when the command completes", async () => {
+			vitest.useFakeTimers()
+			mockCline.ask.mockReturnValue(new Promise(() => {}))
+			const terminal = await setupControllableTerminal()
+
+			const handlePromise = handleCommand("sleep 5")
+
+			await vitest.waitFor(() => expect(terminal.callbacks).toBeDefined())
+			const callbacks = terminal.callbacks!
+			const proc = terminal.proc as unknown as RooTerminalProcess
 
+			callbacks.onShellExecutionStarted!(1234, proc)
+			await callbacks.onLine("working...\n", proc)
+			await vitest.advanceTimersByTimeAsync(executeCommandModule.COMMAND_OUTPUT_ASK_DELAY_MS)
+
+			expect(mockCline.ask).toHaveBeenCalledWith("command_output", "")
+
+			// The command completes while the ask is still pending.
 			await callbacks.onCompleted!("working...\n", proc)
 			callbacks.onShellExecutionComplete!({ exitCode: 0 }, proc)
 			terminal.resolveProcess()
 			await vitest.advanceTimersByTimeAsync(100)
 
 			await handlePromise
 
+			expect(mockCline.supersedePendingAsk).toHaveBeenCalled()
 			expect(mockPushToolResult).toHaveBeenCalled()
+			expect(mockPushToolResult.mock.calls[0][0]).toContain("Exit code: 0")
 		})
 	})
 })

webview-ui/src/components/chat/ChatView.tsx

@@ -462,6 +462,17 @@ const ChatViewComponent: React.ForwardRefRenderFunction<ChatViewRef, ChatViewPro
 						case "error":
 						case "text":
 						case "command_output":
+							// A non-partial command_output say means the command
+							// finished; clear any lingering Proceed/Kill controls
+							// from the interactive ask so they don't stay up after
+							// completion.
+							if (lastMessage.partial !== true && clineAskRef.current === "command_output") {
+								setClineAsk(undefined)
+								setEnableButtons(false)
+								setPrimaryButtonText(undefined)
+								setSecondaryButtonText(undefined)
+							}
+							break
 						case "mcp_server_request_started":
 						case "mcp_server_response":
 						case "completion_result":

webview-ui/src/components/chat/__tests__/ChatView.spec.tsx

@@ -1134,6 +1134,69 @@ describe("ChatView - Message Queueing Tests", () => {
 			}),
 		)
 	})
+
+	it("clears the command_output controls when the final output arrives", async () => {
+		const { getByTestId, getByRole, queryByRole } = renderChatView()
+
+		// Hydrate state with a command_output ask (Proceed/Kill controls visible)
+		mockPostMessage({
+			clineMessages: [
+				{
+					type: "say",
+					say: "task",
+					ts: Date.now() - 2000,
+					text: "Initial task",
+				},
+				{
+					type: "ask",
+					ask: "command_output",
+					ts: Date.now() - 1000,
+					text: "",
+					partial: false,
+				},
+			],
+		})
+
+		await waitFor(() => {
+			expect(getByTestId("chat-textarea")).toBeInTheDocument()
+		})
+
+		await act(async () => {
+			await new Promise((resolve) => setTimeout(resolve, 50))
+		})
+
+		expect(getByRole("button", { name: "chat:proceedWhileRunning.title" })).toBeInTheDocument()
+
+		// The command completes: the final non-partial command_output say arrives.
+		mockPostMessage({
+			clineMessages: [
+				{
+					type: "say",
+					say: "task",
+					ts: Date.now() - 2000,
+					text: "Initial task",
+				},
+				{
+					type: "ask",
+					ask: "command_output",
+					ts: Date.now() - 1000,
+					text: "",
+					partial: false,
+				},
+				{
+					type: "say",
+					say: "command_output",
+					ts: Date.now(),
+					text: "done\n",
+					partial: false,
+				},
+			],
+		})
+
+		await waitFor(() => {
+			expect(queryByRole("button", { name: "chat:proceedWhileRunning.title" })).not.toBeInTheDocument()
+		})
+	})
 })
 
 describe("ChatView - Follow-up Suggestions", () => {