refactor(terminal): promote no_shell_integration payload to typed object

Author: edelauna

src/integrations/terminal/TerminalProcess.ts

@@ -49,10 +49,10 @@ export class TerminalProcess extends BaseTerminalProcess {
 				"[TerminalProcess] Shell integration not available. Command sent without knowledge of response.",
 			)
 
-			this.emit(
-				"no_shell_integration",
-				"Command was submitted; output is not available, as shell integration is inactive.",
-			)
+			this.emit("no_shell_integration", {
+				message: "Command was submitted; output is not available, as shell integration is inactive.",
+				commandSubmitted: true,
+			})
 
 			this.emit(
 				"completed",
@@ -70,10 +70,10 @@ export class TerminalProcess extends BaseTerminalProcess {
 				this.removeAllListeners("stream_available")
 
 				// Emit no_shell_integration event with descriptive message
-				this.emit(
-					"no_shell_integration",
-					`VSCE shell integration stream did not start within ${Terminal.getShellIntegrationTimeout() / 1000} seconds. Terminal problem?`,
-				)
+				this.emit("no_shell_integration", {
+					message: `VSCE shell integration stream did not start within ${Terminal.getShellIntegrationTimeout() / 1000} seconds. Terminal problem?`,
+					commandSubmitted: true,
+				})
 
 				// Reject with descriptive error
 				reject(
@@ -95,10 +95,16 @@ export class TerminalProcess extends BaseTerminalProcess {
 			this.once("shell_execution_complete", (details: ExitCodeDetails) => resolve(details))
 		})
 
-		// Execute command
-		const defaultWindowsShellProfile = vscode.workspace
-			.getConfiguration("terminal.integrated.defaultProfile")
-			.get("windows")
+		// Execute command.
+		// Determine whether the active shell is PowerShell so we can apply the
+		// PS-specific counter/sleep workarounds.  Prefer the Zoo Code profile
+		// override (if set) over the VS Code default profile.  Fix for the wrong
+		// config API: must be getConfiguration("terminal.integrated").get(
+		// "defaultProfile.windows"), not the reversed form that always returns null.
+		const profileOverride = Terminal.getTerminalProfile()
+		const defaultWindowsShellProfile =
+			profileOverride ??
+			vscode.workspace.getConfiguration("terminal.integrated").get<string>("defaultProfile.windows")
 
 		const isPowerShell =
 			process.platform === "win32" &&
@@ -208,26 +214,35 @@ export class TerminalProcess extends BaseTerminalProcess {
 			// Emit any remaining output before completing
 			this.emitRemainingBufferIfListening()
 		} else {
-			const errorMsg =
-				"VSCE output start escape sequence (]633;C or ]133;C) not received, but the stream has started. Upstream VSCE Bug?"
-
 			const inspectPreOutput = inspect(preOutput, { colors: false, breakLength: Infinity })
+
+			// Empty stream (preOutput === '') is a first-run race: VS Code fires
+			// onDidStartTerminalShellExecution before the shell is fully initialized on
+			// a freshly-created terminal. The command was never submitted, so this is
+			// retryable (commandSubmitted: false triggers the execa fallback).
+			//
+			// Non-empty preOutput means the stream had data but ]633;C never arrived —
+			// a genuine shell integration failure after submission (not retryable).
+			const commandSubmitted = preOutput !== ""
+
+			const errorMsg = commandSubmitted
+				? "VSCE output start escape sequence (]633;C or ]133;C) not received, but the stream has started. Upstream VSCE Bug?"
+				: "VSCE shell integration stream completed with no output on first command (shell startup race). Command was not submitted."
+
 			console.error(`[Terminal Process] ${errorMsg} preOutput: ${inspectPreOutput}`)
 
-			// Emit no_shell_integration event
-			this.emit("no_shell_integration", errorMsg)
+			this.emit("no_shell_integration", { message: errorMsg, commandSubmitted })
 
-			// Emit completed event with error message
 			this.emit(
 				"completed",
-				"<VSCE shell integration markers not found: terminal output and command execution status is unknown>\n" +
-					`<preOutput>${inspectPreOutput}</preOutput>\n` +
-					"AI MODEL: You MUST notify the user with the information above so they can open a bug report.",
+				commandSubmitted
+					? "<VSCE shell integration markers not found: terminal output and command execution status is unknown>\n" +
+							`<preOutput>${inspectPreOutput}</preOutput>\n` +
+							"AI MODEL: You MUST notify the user with the information above so they can open a bug report."
+					: "<shell integration stream was empty on first execution: command was not submitted>",
 			)
 
 			this.continue()
-
-			// Return early since we can't process output without shell integration markers
 			return
 		}
 

src/integrations/terminal/__tests__/TerminalProcess.spec.ts

@@ -114,11 +114,15 @@ describe("TerminalProcess", () => {
 
 			// Create new process with the no-shell terminal
 			const noShellProcess = new TerminalProcess(noShellTerminalInfo)
+			let commandSubmitted: boolean | undefined
 
 			// Set up event listeners to verify events are emitted
 			const eventPromises = Promise.all([
 				new Promise<void>((resolve) =>
-					noShellProcess.once("no_shell_integration", (_message: string) => resolve()),
+					noShellProcess.once("no_shell_integration", (details) => {
+						commandSubmitted = details.commandSubmitted
+						resolve()
+					}),
 				),
 				new Promise<void>((resolve) => noShellProcess.once("completed", (_output?: string) => resolve())),
 				new Promise<void>((resolve) => noShellProcess.once("continue", resolve)),
@@ -130,11 +134,83 @@ describe("TerminalProcess", () => {
 
 			// Verify sendText was called with the command
 			expect(noShellTerminal.sendText).toHaveBeenCalledWith("test command", true)
+			expect(commandSubmitted).toBe(true)
 
 			// Restore the original console.warn
 			consoleWarnSpy.mockRestore()
 		})
 
+		it("emits no_shell_integration with commandSubmitted=false when stream is empty (first-run startup race)", async () => {
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+
+			let details: { message: string; commandSubmitted: boolean } | undefined
+
+			const eventPromises = Promise.all([
+				new Promise<void>((resolve) =>
+					terminalProcess.once("no_shell_integration", (d) => {
+						details = d
+						resolve()
+					}),
+				),
+				new Promise<void>((resolve) => terminalProcess.once("completed", (_output?: string) => resolve())),
+				new Promise<void>((resolve) => terminalProcess.once("continue", resolve)),
+			])
+
+			// Empty stream: simulates VS Code firing onDidStartTerminalShellExecution
+			// before the shell has fully initialised on a freshly-created terminal.
+			async function* emptyStream(): AsyncGenerator<string> {
+				terminalProcess.emit("shell_execution_complete", { exitCode: 0 })
+				return
+				yield "" // satisfy require-yield; never reached
+			}
+			mockStream = emptyStream()
+
+			mockExecution = { read: vi.fn().mockReturnValue(mockStream) }
+			mockTerminal.shellIntegration.executeCommand.mockReturnValue(mockExecution)
+
+			const runPromise = terminalProcess.run("test command")
+			terminalProcess.emit("stream_available", mockStream)
+			await runPromise
+			await eventPromises
+
+			expect(details?.commandSubmitted).toBe(false)
+			consoleErrorSpy.mockRestore()
+		})
+
+		it("emits no_shell_integration with commandSubmitted=true when stream has data but no ]633;C", async () => {
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+
+			let details: { message: string; commandSubmitted: boolean } | undefined
+
+			const eventPromises = Promise.all([
+				new Promise<void>((resolve) =>
+					terminalProcess.once("no_shell_integration", (d) => {
+						details = d
+						resolve()
+					}),
+				),
+				new Promise<void>((resolve) => terminalProcess.once("completed", (_output?: string) => resolve())),
+				new Promise<void>((resolve) => terminalProcess.once("continue", resolve)),
+			])
+
+			// Stream has output but never emits ]633;C — genuine shell integration failure.
+			mockStream = (async function* () {
+				yield "some output without marker\n"
+				terminalProcess.emit("shell_execution_complete", { exitCode: 0 })
+			})()
+
+			mockExecution = { read: vi.fn().mockReturnValue(mockStream) }
+			mockTerminal.shellIntegration.executeCommand.mockReturnValue(mockExecution)
+
+			const runPromise = terminalProcess.run("test command")
+			terminalProcess.emit("stream_available", mockStream)
+			await runPromise
+			await eventPromises
+
+			expect(details?.commandSubmitted).toBe(true)
+			consoleErrorSpy.mockRestore()
+		})
+
 		it("sets hot state for compiling commands", async () => {
 			let lines: string[] = []
 

src/integrations/terminal/types.ts

@@ -26,7 +26,12 @@ export interface RooTerminalCallbacks {
 	onCompleted: (output: string | undefined, process: RooTerminalProcess) => void | Promise<void>
 	onShellExecutionStarted: (pid: number | undefined, process: RooTerminalProcess) => void
 	onShellExecutionComplete: (details: ExitCodeDetails, process: RooTerminalProcess) => void
-	onNoShellIntegration?: (message: string, process: RooTerminalProcess) => void
+	onNoShellIntegration?: (details: ShellIntegrationErrorDetails, process: RooTerminalProcess) => void
+}
+
+export interface ShellIntegrationErrorDetails {
+	message: string
+	commandSubmitted: boolean
 }
 
 export interface RooTerminalProcess extends EventEmitter<RooTerminalProcessEvents> {
@@ -50,7 +55,7 @@ export interface RooTerminalProcessEvents {
 	shell_execution_started: [pid: number | undefined]
 	shell_execution_complete: [exitDetails: ExitCodeDetails]
 	error: [error: Error]
-	no_shell_integration: [message: string]
+	no_shell_integration: [details: ShellIntegrationErrorDetails]
 }
 
 export interface ExitCodeDetails {