@codingame/monaco-vscode-katex-common 31.0.1 → 32.0.1

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineFileWriteAnalyzer.js

@@ -126,6 +126,9 @@ let CommandLineFileWriteAnalyzer = class CommandLineFileWriteAnalyzer extends Di
                                 folder => folder.uri.scheme === fileUri.scheme && (fileUri.path.startsWith(folder.uri.path + "/") || fileUri.path === folder.uri.path)
                             ));
                             if (!isInsideWorkspace) {
+                                if (options.hasSessionAutoApproval && this._isInTempDirectory(fileUri.path, options.os)) {
+                                    continue;
+                                }
                                 isAutoApproveAllowed = false;
                                 this._log("File write blocked outside workspace", ( fileUri.toString()));
                                 break;
@@ -149,12 +152,12 @@ let CommandLineFileWriteAnalyzer = class CommandLineFileWriteAnalyzer extends Di
             )).join(", ");
             if (!isAutoApproveAllowed) {
                 disclaimers.push(( localize(
-                    14017,
+                    14331,
                     "File write operations detected that cannot be auto approved: {0}",
                     fileWritesList
                 )));
             } else {
-                disclaimers.push(( localize(14018, "File write operations detected: {0}", fileWritesList)));
+                disclaimers.push(( localize(14332, "File write operations detected: {0}", fileWritesList)));
             }
         }
         return {
@@ -162,6 +165,12 @@ let CommandLineFileWriteAnalyzer = class CommandLineFileWriteAnalyzer extends Di
             disclaimers
         };
     }
+    _isInTempDirectory(uriPath, os) {
+        if (os === OperatingSystem.Windows) {
+            return /[\\/]te?mp[\\/].+/i.test(uriPath);
+        }
+        return uriPath.startsWith("/tmp/");
+    }
 };
 CommandLineFileWriteAnalyzer = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, ILabelService)), ( __param(4, IWorkspaceContextService))], CommandLineFileWriteAnalyzer));
 

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLineBackgroundDetachRewriter.d.ts

@@ -17,6 +17,26 @@ export declare class CommandLineBackgroundDetachRewriter extends Disposable impl
     private readonly _configurationService;
     constructor(_configurationService: IConfigurationService);
     rewrite(options: ICommandLineRewriterOptions): ICommandLineRewriterResult | undefined;
+    /**
+     * Returns true when the command line invokes a program that is known to
+     * require an interactive stdin. Detaching such a command would close stdin
+     * and either hang the program or make it exit with an error.
+     *
+     * The check is intentionally conservative — only well-known interactive
+     * front-ends are matched, and only when their command-line flags do not
+     * obviously force non-interactive behaviour.
+     */
+    private _readsFromStdin;
     private _rewriteForPosix;
+    /**
+     * Returns true when the command uses shell constructs that `nohup` cannot exec
+     * directly. Such commands must be wrapped in `<shell> -c '...'` before being
+     * passed to nohup.
+     *
+     * `nohup` only accepts a single simple external command (plus its arguments).
+     * Anything that requires shell parsing — compound statements, builtins, shell
+     * operators, or inline variable assignments — must go through a shell wrapper.
+     */
+    private _needsShellCWrapper;
     private _rewriteForPowerShell;
 }

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLineBackgroundDetachRewriter.js

@@ -4,7 +4,7 @@ import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
-import { isPowerShell } from '../../runInTerminalHelpers.js';
+import { isFish, isBash, isZsh, isPowerShell } from '../../runInTerminalHelpers.js';
 
 let CommandLineBackgroundDetachRewriter = class CommandLineBackgroundDetachRewriter extends Disposable {
     constructor(_configurationService) {
@@ -12,24 +12,79 @@ let CommandLineBackgroundDetachRewriter = class CommandLineBackgroundDetachRewri
         this._configurationService = _configurationService;
     }
     rewrite(options) {
-        if (!options.isBackground) {
+        if (!this._configurationService.getValue(TerminalChatAgentToolsSettingId.DetachBackgroundProcesses)) {
             return undefined;
         }
-        if (!this._configurationService.getValue(TerminalChatAgentToolsSettingId.DetachBackgroundProcesses)) {
+        const trimmedForCheck = options.commandLine.trimEnd();
+        const endsWithBareBackgroundAmp = /(?:^|[^&])&$/.test(trimmedForCheck);
+        if (!options.isBackground && !endsWithBareBackgroundAmp) {
+            return undefined;
+        }
+        if (this._readsFromStdin(options.commandLine)) {
             return undefined;
         }
         if (options.os === OperatingSystem.Windows) {
+            if (!options.isBackground) {
+                return undefined;
+            }
             return this._rewriteForPowerShell(options);
         }
         return this._rewriteForPosix(options);
     }
+    _readsFromStdin(commandLine) {
+        const trimmed = commandLine.replace(/^\s*(?:[A-Z_][A-Z0-9_]*=\S+\s+)+/, "").replace(/^\s*cd\s+\S+\s*(?:&&|;)\s*/i, "").trimStart();
+        if (/^(expect|passwd|vi|vim|nano|less|more|top|htop|sftp|ftp|telnet|gdb|lldb)\b/.test(trimmed)) {
+            return true;
+        }
+        if (/^psql\b/.test(trimmed) && !/\s(-c|-f|--command|--file)\b/.test(trimmed)) {
+            return true;
+        }
+        if (/^mysql\b/.test(trimmed) && !/\s(-e|--execute)\b/.test(trimmed)) {
+            return true;
+        }
+        if (/^ssh\b/.test(trimmed) && !/\s-T\b/.test(trimmed) && !/\sssh\s+\S+\s+\S/.test(" " + trimmed)) {
+            return true;
+        }
+        if (/^sudo\b/.test(trimmed) && !/\s-n\b/.test(trimmed) && !/\bSUDO_ASKPASS\b/.test(commandLine)) {
+            return true;
+        }
+        return false;
+    }
     _rewriteForPosix(options) {
+        const trimmed = options.commandLine.trimEnd();
+        const endsWithBackgroundAmp = /(?:^|[^&])&$/.test(trimmed);
+        let commandToWrap = trimmed;
+        if (this._needsShellCWrapper(trimmed)) {
+            const innerCommand = endsWithBackgroundAmp ? trimmed.replace(/\s*&$/, "") : trimmed;
+            if (isFish(options.shell, options.os)) {
+                const escaped = innerCommand.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+                commandToWrap = `${options.shell} -c "${escaped}"`;
+            } else {
+                const escaped = innerCommand.replace(/'/g, `'\\''`);
+                commandToWrap = `${options.shell} -c '${escaped}'`;
+            }
+        }
+        const needsTrailingAmp = !(/(?:^|[^&])&$/.test(commandToWrap));
+        const supportsDisown = isBash(options.shell, options.os) || isZsh(options.shell, options.os);
+        const disownSuffix = supportsDisown ? " disown" : "";
+        const rewritten = needsTrailingAmp ? `nohup ${commandToWrap} &${disownSuffix}` : `nohup ${commandToWrap}${disownSuffix}`;
         return {
-            rewritten: `nohup ${options.commandLine} &`,
+            rewritten,
             reasoning: "Wrapped background command with nohup to survive terminal shutdown",
             forDisplay: options.commandLine
         };
     }
+    _needsShellCWrapper(commandLine) {
+        const trimmed = commandLine.trimStart();
+        return (
+            (/^(for|while|until|if|case|select|function)\b/.test(trimmed) ||
+            /^(eval|set|export|source|unset|declare|typeset|local|readonly|alias|cd|exec)\b/.test(trimmed) ||
+            /^\.\s/.test(trimmed) ||
+            /^[{(]/.test(trimmed) ||
+            /^[A-Za-z_][A-Za-z0-9_]*=/.test(trimmed) ||
+            /(?:\|\||&&|[|;]|&(?!&)(?!\s*$))/.test(trimmed))
+        );
+    }
     _rewriteForPowerShell(options) {
         if (!isPowerShell(options.shell, options.os)) {
             return undefined;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLineSandboxRewriter.d.ts

@@ -1,8 +1,15 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { TreeSitterCommandParser } from "../../treeSitterCommandParser.js";
 import { ITerminalSandboxService } from "../../../common/terminalSandboxService.js";
 import type { ICommandLineRewriter, ICommandLineRewriterOptions, ICommandLineRewriterResult } from "./commandLineRewriter.js";
 export declare class CommandLineSandboxRewriter extends Disposable implements ICommandLineRewriter {
+    private readonly _treeSitterCommandParser;
     private readonly _sandboxService;
-    constructor(_sandboxService: ITerminalSandboxService);
+    constructor(_treeSitterCommandParser: TreeSitterCommandParser, _sandboxService: ITerminalSandboxService);
     rewrite(options: ICommandLineRewriterOptions): Promise<ICommandLineRewriterResult | undefined>;
+    /**
+     * Parses the command line into sandbox command details. If parsing fails,
+     * wrapping continues with the base sandbox config rather than blocking the command.
+     */
+    private _parseCommandDetails;
 }

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineRewriter/commandLineSandboxRewriter.js

@@ -1,13 +1,16 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isPowerShell } from '../../runInTerminalHelpers.js';
+import { TreeSitterCommandParserLanguage } from '../../treeSitterCommandParser.js';
 import '../../../common/terminalSandboxService.js';
 import { TerminalSandboxPrerequisiteCheck } from '../../../../../../../platform/sandbox/common/terminalSandboxService.js';
 import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service';
 
 let CommandLineSandboxRewriter = class CommandLineSandboxRewriter extends Disposable {
-    constructor(_sandboxService) {
+    constructor(_treeSitterCommandParser, _sandboxService) {
         super();
+        this._treeSitterCommandParser = _treeSitterCommandParser;
         this._sandboxService = _sandboxService;
     }
     async rewrite(options) {
@@ -15,7 +18,14 @@ let CommandLineSandboxRewriter = class CommandLineSandboxRewriter extends Dispos
         if (!sandboxPrereqs.enabled || sandboxPrereqs.failedCheck === TerminalSandboxPrerequisiteCheck.Config) {
             return undefined;
         }
-        const wrappedCommand = this._sandboxService.wrapCommand(options.commandLine, options.requestUnsandboxedExecution, options.shell);
+        const commandDetails = await this._parseCommandDetails(options);
+        const wrappedCommand = await this._sandboxService.wrapCommand(
+            options.commandLine,
+            options.requestUnsandboxedExecution,
+            options.shell,
+            options.cwd,
+            commandDetails
+        );
         return {
             rewritten: wrappedCommand.command,
             reasoning: wrappedCommand.requiresUnsandboxConfirmation ? "Switched command to unsandboxed execution because the command includes a domain that is not in the sandbox allowlist" : "Wrapped command for sandbox execution",
@@ -26,7 +36,18 @@ let CommandLineSandboxRewriter = class CommandLineSandboxRewriter extends Dispos
             deniedDomains: wrappedCommand.deniedDomains
         };
     }
+    async _parseCommandDetails(options) {
+        try {
+            if (options.requestUnsandboxedExecution === true) {
+                return [];
+            }
+            const languageId = isPowerShell(options.shell, options.os) ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash;
+            return await this._treeSitterCommandParser.extractCommands(languageId, options.commandLine);
+        } catch {
+            return [];
+        }
+    }
 };
-CommandLineSandboxRewriter = ( __decorate([( __param(0, ITerminalSandboxService))], CommandLineSandboxRewriter));
+CommandLineSandboxRewriter = ( __decorate([( __param(1, ITerminalSandboxService))], CommandLineSandboxRewriter));
 
 export { CommandLineSandboxRewriter };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/outputMonitor.d.ts

@@ -12,6 +12,14 @@ export interface IOutputMonitor extends Disposable {
     readonly outputMonitorTelemetryCounters: IOutputMonitorTelemetryCounters;
     readonly onDidFinishCommand: Event<void>;
     readonly onDidDetectInputNeeded: Event<void>;
+    /**
+     * Fires when the terminal is detected to be waiting for sensitive input
+     * (e.g. a password, passphrase, token, secret or verification code). This
+     * is fired *instead of* {@link onDidDetectInputNeeded} so callers can show
+     * UI that focuses the terminal rather than routing the prompt through the
+     * agent.
+     */
+    readonly onDidDetectSensitiveInputNeeded: Event<void>;
 }
 export interface IOutputMonitorTelemetryCounters {
     inputToolManualAcceptCount: number;
@@ -23,6 +31,10 @@ export interface IOutputMonitorTelemetryCounters {
     inputToolFreeFormInputShownCount: number;
     inputToolFreeFormInputCount: number;
 }
+/**
+ * Returns the last visible line from terminal output after trimming trailing line breaks.
+ */
+export declare function getLastLine(output: string | undefined): string;
 export declare class OutputMonitor extends Disposable implements IOutputMonitor {
     private readonly _execution;
     private readonly _pollFn;
@@ -47,10 +59,21 @@ export declare class OutputMonitor extends Disposable implements IOutputMonitor
     readonly onDidFinishCommand: Event<void>;
     private readonly _onDidDetectInputNeeded;
     readonly onDidDetectInputNeeded: Event<void>;
+    private readonly _onDidDetectSensitiveInputNeeded;
+    readonly onDidDetectSensitiveInputNeeded: Event<void>;
     private _asyncMode;
     private _command;
     private _invocationContext;
     private _currentMonitoringCts;
+    /**
+     * Tracks whether onDidFinishCommand has fired so the event is delivered at
+     * most once. The event must fire synchronously during dispose so consumers
+     * awaiting `Event.toPromise(onDidFinishCommand)` are unblocked before the
+     * underlying emitter is torn down by super.dispose().
+     */
+    private _didFinish;
+    private _fireFinishedOnce;
+    dispose(): void;
     constructor(_execution: IExecution, _pollFn: ((execution: IExecution, token: CancellationToken, taskService: ITaskService) => Promise<IPollingResult | undefined>) | undefined, invocationContext: IToolInvocationContext | undefined, token: CancellationToken, command: string, _taskService: ITaskService, _logService: ITerminalLogService);
     private _startMonitoring;
     /**
@@ -86,10 +109,34 @@ export declare class OutputMonitor extends Disposable implements IOutputMonitor
     private _cleanupIdleInputListener;
     private _isSensitivePrompt;
 }
+/**
+ * Returns true when the terminal's last visible line looks like a prompt for
+ * a sensitive secret (password, passphrase, token, API key, OTP, etc.). Used
+ * to short-circuit the normal "input needed → return to agent" flow so that
+ * the secret is never routed through the model — instead the user is asked
+ * via UI to focus the terminal and type the secret directly.
+ */
+export declare function detectsSensitiveInputPrompt(cursorLine: string): boolean;
 export declare function matchTerminalPromptOption(options: readonly string[], suggestedOption: string): {
     option: string | undefined;
     index: number;
 };
+/**
+ * High-confidence patterns that reliably indicate the terminal is waiting for
+ * input. These are safe to use as a fast-path in `_waitForIdle` to skip normal
+ * idle detection, because they are specific enough to avoid false positives on
+ * normal command output (build logs, headers, etc.).
+ */
+export declare function detectsHighConfidenceInputPattern(cursorLine: string): boolean;
+/**
+ * Full set of input-required patterns including broader heuristics (bare `:` and
+ * `?` with trailing space). These may produce false positives on normal command
+ * output, so they should only be used **after** the terminal has been confirmed
+ * idle through normal polling (consecutive idle events with no data). In
+ * `_waitForIdle`, these are checked only when `recentlyIdle` is true (to handle
+ * active executions that are actually waiting for input). For the unconditional
+ * fast-path, use {@link detectsHighConfidenceInputPattern} instead.
+ */
 export declare function detectsInputRequiredPattern(cursorLine: string): boolean;
 export declare function detectsNonInteractiveHelpPattern(cursorLine: string): boolean;
 /**

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/outputMonitor.js

@@ -9,6 +9,19 @@ import { ITaskService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { OutputMonitorState, PollingConsts } from './types.js';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 
+function getLastLine(output) {
+    if (!output) {
+        return "";
+    }
+    const trimmedOutput = output.replace(/[\r\n]+$/, "");
+    if (!trimmedOutput) {
+        return "";
+    }
+    const lastLineFeed = trimmedOutput.lastIndexOf("\n");
+    const lastLine = lastLineFeed === -1 ? trimmedOutput : trimmedOutput.slice(lastLineFeed + 1);
+    const lastCarriageReturn = lastLine.lastIndexOf("\r");
+    return lastCarriageReturn === -1 ? lastLine : lastLine.slice(lastCarriageReturn + 1);
+}
 let OutputMonitor = class OutputMonitor extends Disposable {
     get state() {
         return this._state;
@@ -17,7 +30,7 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         if (!output) {
             return "<empty>";
         }
-        const lastLine = output.trimEnd().split(/\r?\n/).pop() ?? "";
+        const lastLine = getLastLine(output).trimEnd();
         if (!lastLine) {
             return "<empty>";
         }
@@ -32,6 +45,25 @@ let OutputMonitor = class OutputMonitor extends Disposable {
     get outputMonitorTelemetryCounters() {
         return this._outputMonitorTelemetryCounters;
     }
+    _fireFinishedOnce() {
+        if (this._didFinish) {
+            return;
+        }
+        this._didFinish = true;
+        this._onDidFinishCommand.fire();
+    }
+    dispose() {
+        if (!this._didFinish) {
+            this._pollingResult ??= {
+                state: OutputMonitorState.Cancelled,
+                output: this._execution.getOutput(),
+                pollDurationMs: 0,
+                resources: undefined
+            };
+        }
+        this._fireFinishedOnce();
+        super.dispose();
+    }
     constructor(
         _execution,
         _pollFn,
@@ -63,14 +95,24 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         this.onDidFinishCommand = this._onDidFinishCommand.event;
         this._onDidDetectInputNeeded = this._register(( new Emitter()));
         this.onDidDetectInputNeeded = this._onDidDetectInputNeeded.event;
+        this._onDidDetectSensitiveInputNeeded = this._register(( new Emitter()));
+        this.onDidDetectSensitiveInputNeeded = this._onDidDetectSensitiveInputNeeded.event;
         this._asyncMode = false;
         this._command = "";
+        this._didFinish = false;
         this._command = command;
         this._invocationContext = invocationContext;
-        this._register(toDisposable(() => this._currentMonitoringCts?.dispose()));
+        const cts = ( new CancellationTokenSource(token));
+        this._currentMonitoringCts = cts;
+        this._register(toDisposable(() => {
+            this._currentMonitoringCts?.cancel();
+            this._currentMonitoringCts?.dispose();
+        }));
         timeout(0).then(() => {
-            this._currentMonitoringCts = ( new CancellationTokenSource(token));
-            this._startMonitoring(command, invocationContext, this._currentMonitoringCts.token);
+            if (this._currentMonitoringCts !== cts) {
+                return;
+            }
+            this._startMonitoring(command, invocationContext, cts.token);
         });
     }
     async _startMonitoring(command, invocationContext, token) {
@@ -161,7 +203,7 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                 resources
             };
             this._userInputListener.clear();
-            this._onDidFinishCommand.fire();
+            this._fireFinishedOnce();
         }
     }
     continueMonitoringAsync(token) {
@@ -201,10 +243,11 @@ let OutputMonitor = class OutputMonitor extends Disposable {
     async _handleIdleState(token) {
         const output = this._execution.getOutput();
         const outputTail = output.slice(-1e3);
+        const outputLastLine = getLastLine(outputTail);
         this._logService.trace(
             `OutputMonitor: Idle output summary: len=${output.length}, lastLine=${this._formatLastLineForLog(outputTail)}`
         );
-        if (detectsNonInteractiveHelpPattern(outputTail)) {
+        if (detectsNonInteractiveHelpPattern(outputLastLine)) {
             this._logService.trace("OutputMonitor: Idle -> non-interactive help pattern detected, stopping");
             return {
                 shouldContinuePolling: false,
@@ -240,11 +283,18 @@ let OutputMonitor = class OutputMonitor extends Disposable {
             };
         }
         if (this._asyncMode) {
-            if (detectsInputRequiredPattern(outputTail)) {
-                this._logService.trace(
-                    "OutputMonitor: Async mode - input-required pattern detected, signaling agent"
-                );
-                this._onDidDetectInputNeeded.fire();
+            if (detectsInputRequiredPattern(outputLastLine)) {
+                if (detectsSensitiveInputPrompt(outputLastLine)) {
+                    this._logService.trace(
+                        "OutputMonitor: Async mode - sensitive input prompt detected, signaling sensitive UI"
+                    );
+                    this._onDidDetectSensitiveInputNeeded.fire();
+                } else {
+                    this._logService.trace(
+                        "OutputMonitor: Async mode - input-required pattern detected, signaling agent"
+                    );
+                    this._onDidDetectInputNeeded.fire();
+                }
             }
             this._cleanupIdleInputListener();
             return {
@@ -252,9 +302,14 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                 output
             };
         }
-        if (detectsInputRequiredPattern(outputTail)) {
-            this._logService.trace("OutputMonitor: Input-required pattern detected, signaling agent");
-            this._onDidDetectInputNeeded.fire();
+        if (detectsInputRequiredPattern(outputLastLine)) {
+            if (detectsSensitiveInputPrompt(outputLastLine)) {
+                this._logService.trace("OutputMonitor: Sensitive input prompt detected, signaling sensitive UI");
+                this._onDidDetectSensitiveInputNeeded.fire();
+            } else {
+                this._logService.trace("OutputMonitor: Input-required pattern detected, signaling agent");
+                this._onDidDetectInputNeeded.fire();
+            }
             this._cleanupIdleInputListener();
             return {
                 shouldContinuePolling: false,
@@ -273,7 +328,10 @@ let OutputMonitor = class OutputMonitor extends Disposable {
     }
     async _handleTimeoutState(_command, _invocationContext, _extended, _token) {
         if (_extended) {
-            this._logService.info("OutputMonitor: Extended polling timeout reached after 2 minutes");
+            this._logService.info(
+                "OutputMonitor: Extended polling timeout reached after 2 minutes, signaling potential input needed"
+            );
+            this._onDidDetectInputNeeded.fire();
             this._state = OutputMonitorState.Cancelled;
             return false;
         }
@@ -304,7 +362,8 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                 currentInterval = Math.min(currentInterval * 2, maxInterval);
                 const currentOutput = execution.getOutput();
                 const currentTail = currentOutput.slice(-1000);
-                if (detectsNonInteractiveHelpPattern(currentTail)) {
+                const currentLastLine = getLastLine(currentTail);
+                if (detectsNonInteractiveHelpPattern(currentLastLine)) {
                     this._logService.trace(
                         `OutputMonitor: waitForIdle -> non-interactive help detected (waited=${waited}ms)`
                     );
@@ -312,10 +371,10 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                     this._setupIdleInputListener();
                     return this._state;
                 }
-                const promptResult = detectsInputRequiredPattern(currentTail);
+                const promptResult = detectsHighConfidenceInputPattern(currentLastLine);
                 if (promptResult) {
                     this._logService.trace(
-                        `OutputMonitor: waitForIdle -> input-required pattern detected (waited=${waited}ms, lastLine=${this._formatLastLineForLog(currentTail)})`
+                        `OutputMonitor: waitForIdle -> high-confidence input pattern detected (waited=${waited}ms, lastLine=${this._formatLastLineForLog(currentTail)})`
                     );
                     this._state = OutputMonitorState.Idle;
                     this._setupIdleInputListener();
@@ -340,6 +399,14 @@ let OutputMonitor = class OutputMonitor extends Disposable {
                     this._setupIdleInputListener();
                     return this._state;
                 }
+                if (recentlyIdle && isActive === true && detectsInputRequiredPattern(currentLastLine)) {
+                    this._logService.trace(
+                        `OutputMonitor: waitForIdle -> broad input pattern detected while active+idle (waited=${waited}ms, lastLine=${this._formatLastLineForLog(currentTail)})`
+                    );
+                    this._state = OutputMonitorState.Idle;
+                    this._setupIdleInputListener();
+                    return this._state;
+                }
             }
         } finally {
             onDataDisposable.dispose();
@@ -350,6 +417,9 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         return OutputMonitorState.Timeout;
     }
     _setupIdleInputListener() {
+        if (this._store.isDisposed) {
+            return;
+        }
         this._userInputtedSinceIdleDetected = false;
         this._logService.trace("OutputMonitor: Setting up idle input listener");
         this._userInputListener.value = this._execution.instance.onDidInputData(() => {
@@ -362,22 +432,33 @@ let OutputMonitor = class OutputMonitor extends Disposable {
         this._userInputListener.clear();
     }
     _isSensitivePrompt(prompt) {
-        return /(password|passphrase|token|api\s*key|secret)/i.test(prompt);
+        return detectsSensitiveInputPrompt(prompt);
     }
 };
 OutputMonitor = ( __decorate([( __param(5, ITaskService)), ( __param(6, ITerminalLogService))], OutputMonitor));
-function detectsInputRequiredPattern(cursorLine) {
+function detectsSensitiveInputPrompt(cursorLine) {
+    return /(password|passphrase|token|api\s*key|secret|verification code|otp\b|one[\s-]?time (?:code|password)|2fa|mfa|pin\s*(?:code|number)?[: ]?\s*$|authentication code)/i.test(cursorLine);
+}
+function detectsHighConfidenceInputPattern(cursorLine) {
     return ([
         /\s*(?:\[[^\]]\][^\[]*)+(?:\(default is\s+"[^"]+"\):)?\s+$/,
         /(?:\(|\[)\s*(?:y(?:es)?\s*\/\s*n(?:o)?|n(?:o)?\s*\/\s*y(?:es)?)\s*(?:\]|\))\s+$/i,
         /[?:]\s*(?:\(|\[)?\s*y(?:es)?\s*\/\s*n(?:o)?\s*(?:\]|\))?\s+$/i,
-        /\(y\)\s*$/i,
-        /:\s*$/,
-        /:\s*\([^)]*\)\s*$/,
+        /\(y\) +$/i,
+        /:\s*\([^)]*\) +$/,
         /\(END\)$/,
-        /password[:]?$/i,
-        /\?\s*(?:\([a-z\s]+\))?$/i,
-        /press a(?:ny)? key/i
+        /password(?: for [^:]+)?:\s*$/i,
+        /press a(?:ny)? key/i,
+        /^(?:\s|\x1b\[[0-9;]*m)*\?.*[›❯▸▶]\s*$/
+    ].some(e => e.test(cursorLine)));
+}
+function detectsInputRequiredPattern(cursorLine) {
+    if (detectsHighConfidenceInputPattern(cursorLine)) {
+        return true;
+    }
+    return ([
+        /: +$/,
+        /\? *(?:\([a-z\s]+\))? +$/i
     ].some(e => e.test(cursorLine)));
 }
 function detectsNonInteractiveHelpPattern(cursorLine) {
@@ -394,9 +475,9 @@ function detectsNonInteractiveHelpPattern(cursorLine) {
     ].some(e => e.test(cursorLine)));
 }
 const taskFinishMessages = [(
-localize(14031, "Terminal will be reused by tasks, press any key to close it.")), ( localize(14032, "Terminal will be reused by tasks, press any key to close it.")), (
-localize(14033, "Press any key to close the terminal.")), ( localize(14034, "Press any key to close the terminal.")), (
-localize(14035, "The terminal will be reused by tasks. Press any key to close."))];
+localize(14345, "Terminal will be reused by tasks, press any key to close it.")), ( localize(14346, "Terminal will be reused by tasks, press any key to close it.")), (
+localize(14347, "Press any key to close the terminal.")), ( localize(14348, "Press any key to close the terminal.")), (
+localize(14349, "The terminal will be reused by tasks. Press any key to close."))];
 const normalizedTaskFinishMessages = ( taskFinishMessages.map(msg => msg.replace(/[\s.,:;!?"'`()[\]{}<>\-_/\\]+/g, "").toLowerCase()));
 function detectsVSCodeTaskFinishMessage(cursorLine) {
     const compact = cursorLine.replace(/[\s.,:;!?"'`()[\]{}<>\-_/\\]+/g, "").toLowerCase();
@@ -409,4 +490,4 @@ function detectsGenericPressAnyKeyPattern(cursorLine) {
     return /press a(?:ny)? key/i.test(cursorLine);
 }
 
-export { OutputMonitor, detectsGenericPressAnyKeyPattern, detectsInputRequiredPattern, detectsNonInteractiveHelpPattern, detectsVSCodeTaskFinishMessage };
+export { OutputMonitor, detectsGenericPressAnyKeyPattern, detectsHighConfidenceInputPattern, detectsInputRequiredPattern, detectsNonInteractiveHelpPattern, detectsSensitiveInputPrompt, detectsVSCodeTaskFinishMessage, getLastLine };