[Fix] Zoo prompts about command output when short foreground commands emit output (Zoo-Code-Org#1043)

* fix(terminal): delay command_output ask for short foreground commands

The command_output ask fired on the first output chunk of any foreground
command, prompting users even for commands about to complete. Schedule the
ask instead so it only fires when the command is still running after a
5s delay, preserving the interrupt/feedback path for long-running commands
while letting short commands finish without prompting.

Closes Zoo-Code-Org#1042

* fix(terminal): anchor command_output ask delay to execution start

Anchor the ask-delay timer to onShellExecutionStarted (falling back to the
pre-runCommand timestamp) so shell-integration startup on cold terminals
does not consume the grace period, and expand ask-policy tests to cover
the agent-timeout cancel, re-anchor reschedule, ask error handling, and
non-message responses to restore patch coverage.

* test(terminal): cover fallback anchor for command_output ask delay

* 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.

* test(terminal): note synthetic yesButtonClicked in non-message ask test

---------

Co-authored-by: Roomote <roomote@roomote.dev>

Author: zoomote[bot]

src/core/tools/ExecuteCommandTool.ts

@@ -35,6 +35,15 @@ export function canRetryShellIntegrationError(error: unknown): error is ShellInt
 	return error instanceof ShellIntegrationError && !error.commandSubmitted
 }
 
+/**
+ * Grace period before a foreground command may trigger a `command_output` ask.
+ * Short commands that emit output and exit within this window never prompt the
+ * user; the ask only fires when the command is still running once the delay
+ * elapses, so users can still interrupt or provide feedback on long-running
+ * commands.
+ */
+export const COMMAND_OUTPUT_ASK_DELAY_MS = 5_000
+
 export function getTerminalProviderForExecution(terminalShellIntegrationDisabled: boolean): {
 	terminalProvider: RooTerminalProvider
 	isCmdExeFallback: boolean
@@ -340,6 +349,58 @@ export async function executeCommandInTerminal(
 		resolveOnCompleted = resolve
 	})
 
+	// Delay the `command_output` ask so short foreground commands that emit
+	// output and exit normally never prompt the user. The ask only fires if the
+	// command is still running once COMMAND_OUTPUT_ASK_DELAY_MS has elapsed
+	// since execution started, preserving the interrupt/feedback path for
+	// long-running commands. The anchor is re-based to onShellExecutionStarted
+	// (falling back to the pre-runCommand timestamp when that event never
+	// fires) so shell-integration startup on cold terminals does not consume
+	// the grace period.
+	let commandStartedAt = 0
+	let commandOutputAskTimer: NodeJS.Timeout | undefined
+
+	const askForCommandOutput = async (process: RooTerminalProcess): Promise<void> => {
+		if (runInBackground || hasAskedForCommandOutput || completed) {
+			return
+		}
+
+		// Mark that we've asked to prevent multiple concurrent asks
+		hasAskedForCommandOutput = true
+
+		try {
+			const { response, text, images } = await task.ask("command_output", "")
+			runInBackground = true
+
+			if (response === "messageResponse") {
+				message = { text, images }
+			}
+
+			// 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")
+		}
+	}
+
+	const scheduleCommandOutputAsk = (process: RooTerminalProcess): void => {
+		if (runInBackground || hasAskedForCommandOutput || completed || commandOutputAskTimer) {
+			return
+		}
+
+		const remainingDelay = COMMAND_OUTPUT_ASK_DELAY_MS - (Date.now() - commandStartedAt)
+
+		commandOutputAskTimer = setTimeout(
+			() => {
+				commandOutputAskTimer = undefined
+				void askForCommandOutput(process)
+			},
+			Math.max(remainingDelay, 0),
+		)
+	}
+
 	const callbacks: RooTerminalCallbacks = {
 		onLine: async (lines: string, process: RooTerminalProcess) => {
 			accumulatedOutput += lines
@@ -359,26 +420,19 @@ export async function executeCommandInTerminal(
 			provider?.postMessageToWebview({ type: "commandExecutionStatus", text: JSON.stringify(status) })
 			schedulePartialCommandOutputUpdate()
 
-			if (runInBackground || hasAskedForCommandOutput) {
-				return
-			}
-
-			// Mark that we've asked to prevent multiple concurrent asks
-			hasAskedForCommandOutput = true
-
-			try {
-				const { response, text, images } = await task.ask("command_output", "")
-				runInBackground = true
-
-				if (response === "messageResponse") {
-					message = { text, images }
-					process.continue()
-				}
-			} catch (_error) {
-				// Silently handle ask errors (e.g., "Current ask promise was ignored")
-			}
+			scheduleCommandOutputAsk(process)
 		},
 		onCompleted: async (output: string | undefined) => {
+			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
 
@@ -412,9 +466,21 @@ export async function executeCommandInTerminal(
 					console.error("[ExecuteCommandTool] Failed to flush final command_output:", error)
 				})
 		},
-		onShellExecutionStarted: (pid: number | undefined) => {
+		onShellExecutionStarted: (pid: number | undefined, process: RooTerminalProcess) => {
 			const status: CommandExecutionStatus = { executionId, status: "started", pid, command }
 			provider?.postMessageToWebview({ type: "commandExecutionStatus", text: JSON.stringify(status) })
+
+			// Re-anchor the ask delay to actual execution start so the shell
+			// integration startup wait does not count against the grace period.
+			commandStartedAt = Date.now()
+
+			// Output should not precede this event, but if it did, reschedule
+			// the pending ask against the corrected anchor.
+			if (commandOutputAskTimer) {
+				clearTimeout(commandOutputAskTimer)
+				commandOutputAskTimer = undefined
+				scheduleCommandOutputAsk(process)
+			}
 		},
 		onShellExecutionComplete: (details: ExitCodeDetails) => {
 			const status: CommandExecutionStatus = { executionId, status: "exited", exitCode: details.exitCode }
@@ -441,6 +507,8 @@ export async function executeCommandInTerminal(
 		workingDir = terminal.getCurrentWorkingDirectory()
 	}
 
+	// Fallback anchor for providers that never fire onShellExecutionStarted.
+	commandStartedAt = Date.now()
 	const process = terminal.runCommand(command, callbacks)
 	task.terminalProcess = process
 
@@ -462,6 +530,8 @@ export async function executeCommandInTerminal(
 				new Promise<void>((resolve) => {
 					agentTimeoutId = setTimeout(() => {
 						runInBackground = true
+						clearTimeout(commandOutputAskTimer)
+						commandOutputAskTimer = undefined
 						process.continue()
 						task.supersedePendingAsk()
 						resolve()
@@ -501,6 +571,7 @@ export async function executeCommandInTerminal(
 	} finally {
 		clearTimeout(agentTimeoutId)
 		clearTimeout(userTimeoutId)
+		clearTimeout(commandOutputAskTimer)
 		clearTimeout(pendingCommandOutputEmitTimer)
 		task.terminalProcess = undefined
 	}