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

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

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { timeout, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { timeout, DeferredPromise, RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
@@ -30,6 +30,7 @@ import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platf
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { IHistoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/history/common/history.service';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
 import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
@@ -156,7 +157,6 @@ function createSandboxLines(allowToRunUnsandboxedCommands, networkDomains) {
         lines.push(
             "- When a command fails due to sandbox restrictions, immediately re-run it with requestUnsandboxedExecution=true. Do NOT ask the user for permission — setting this flag automatically shows a confirmation prompt to the user",
             "- Only set requestUnsandboxedExecution=true when there is evidence of failures caused by the sandbox, e.g. 'Operation not permitted' errors, network failures, or file access errors, etc",
-            "- Do NOT set requestUnsandboxedExecution=true without first executing the command in sandbox mode. Always try the command in the sandbox first, and only set requestUnsandboxedExecution=true when retrying after that sandboxed execution failed due to sandbox restrictions.",
             "- When setting requestUnsandboxedExecution=true, also provide requestUnsandboxedExecutionReason explaining why the command needs unsandboxed access"
         );
     } else {
@@ -251,7 +251,11 @@ function createZshModelDescription(isSandboxEnabled, allowToRunUnsandboxedComman
         "- Use jobs, fg, bg for job control",
         "- Use [[ ]] for conditional tests instead of [ ]",
         "- Prefer $() over backticks for command substitution",
-        "- Take advantage of zsh globbing features (**, extended globs)"
+        "- Take advantage of zsh globbing features (**, extended globs). Note: unmatched globs fail by default (zsh: no matches found) — use a glob qualifier like *(N) or quote the glob if it should be literal",
+        "",
+        "zsh pitfalls — these WILL cause errors or hangs:",
+        "- NEVER use bare == or === as separators (e.g. echo === triggers zsh equals expansion). Quote them: echo '==='",
+        "- NEVER use status as a variable name (it is read-only in zsh). Use exit_code or ret instead"
     ].join("\n");
 }
 function createFishModelDescription(isSandboxEnabled, allowToRunUnsandboxedCommands, networkDomains) {
@@ -312,20 +316,20 @@ async function createRunInTerminalToolData(accessor) {
         },
         requestUnsandboxedExecution: {
             type: "boolean",
-            description: "Request that this command run outside the terminal sandbox. Only set this after first executing the command in sandbox and observing that sandboxing caused the failure. The user will be prompted before the command runs unsandboxed."
+            description: "Request that this command run outside the terminal sandbox. Only set this when the command clearly needs unsandboxed access. The user will be prompted before the command runs unsandboxed."
         },
         requestUnsandboxedExecutionReason: {
             type: "string",
-            description: "A short explanation of the sandboxed execution failure or blocked-domain requirement that justifies retrying outside the sandbox. Only provide this when requestUnsandboxedExecution is true."
+            description: "A short explanation of why this command must run outside the terminal sandbox. Only provide this when requestUnsandboxedExecution is true."
         }
     } : {};
     return {
         id: TerminalToolId.RunInTerminal,
         toolReferenceName: TOOL_REFERENCE_NAME,
         legacyToolReferenceFullNames: LEGACY_TOOL_REFERENCE_FULL_NAMES,
-        displayName: ( localize(14352, "Run in Terminal")),
+        displayName: ( localize(14482, "Run in Terminal")),
         modelDescription: `${modelDescription}\n\nExecution mode:\n- mode='sync': wait for completion (optionally capped by timeout); if still running when timeout elapses, return with a terminal ID.\n- mode='async': wait for an initial idle/output signal, then return with terminal output snapshot and ID. Timeout caps how long to wait for the initial idle/output signal.\n- Prefer mode='sync' for commands that will prompt for interactive input (e.g., npm init, interactive installers, configuration wizards).\n\nTimeout parameter: For one-shot long-running commands, set a generous timeout as a safety net (e.g. 600000 for installs, longer for big builds). Omit timeout only for processes that should run indefinitely (servers, daemons). If the timeout elapses, you get a terminal ID and can check output later.\n\nTerminal notifications: When an async command finishes or a sync command times out, you will be automatically notified on your next turn with the exit code and terminal output. You will also be notified if the terminal needs input. Do NOT poll or sleep to wait for completion.`,
-        userDescription: ( localize(14353, "Run commands in the terminal")),
+        userDescription: ( localize(14483, "Run commands in the terminal")),
         source: ToolDataSource.Internal,
         icon: Codicon.terminal,
         inputSchema: {
@@ -365,7 +369,7 @@ function shouldAutomaticallyRetryUnsandboxed(options) {
 const telemetryIgnoredSequences = [
 "\u001b[I",
 "\u001b[O"];
-const altBufferMessage = "\n" + ( localize(14354, "The command opened the alternate buffer."));
+const altBufferMessage = "\n" + ( localize(14484, "The command opened the alternate buffer."));
 let RunInTerminalTool = class RunInTerminalTool extends Disposable {
     static {
         RunInTerminalTool_1 = this;
@@ -433,7 +437,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
     }
     _getUnsandboxedExecutionDisabledMessage() {
         return localize(
-            14355,
+            14485,
             "The command was not executed because it requested to run outside the terminal sandbox, but running commands outside the sandbox is disabled by chat.agent.sandbox.allowUnsandboxedCommands. Run the command in the sandbox instead, or enable the setting to allow unsandboxed execution."
         );
     }
@@ -456,7 +460,8 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         _terminalSandboxService,
         _workspaceContextService,
         _chatWidgetService,
-        _agentSessionsService
+        _agentSessionsService,
+        lifecycleService
     ) {
         super();
         this._chatService = _chatService;
@@ -480,6 +485,10 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         this._sessionTerminalInstances = ( new ResourceMap());
         this._terminalsBeingDisposedBySessionCleanup = ( new Set());
         this._backgroundNotifications = this._register(( new DisposableMap()));
+        this._isShuttingDown = false;
+        this._register(lifecycleService.onWillShutdown(() => {
+            this._isShuttingDown = true;
+        }));
         this._osBackend = this._remoteAgentService.getEnvironment().then(remoteEnv => remoteEnv?.os ?? OS);
         this._terminalToolCreator = this._instantiationService.createInstance(ToolTerminalCreator);
         this._treeSitterCommandParser = this._register(this._instantiationService.createInstance(TreeSitterCommandParser));
@@ -553,13 +562,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         const partialInput = context.rawInput;
         if (partialInput && typeof partialInput === "object" && partialInput.command) {
             const truncatedCommand = buildCommandDisplayText(partialInput.command);
-            const invocationMessage = ( new MarkdownString(( localize(14356, "Running `{0}`", escapeMarkdownSyntaxTokens(truncatedCommand)))));
+            const invocationMessage = ( new MarkdownString(( localize(14486, "Running `{0}`", escapeMarkdownSyntaxTokens(truncatedCommand)))));
             return {
                 invocationMessage
             };
         }
         return {
-            invocationMessage: ( localize(14357, "Running command"))
+            invocationMessage: ( localize(14487, "Running command"))
         };
     }
     async prepareToolInvocation(context, token) {
@@ -600,7 +609,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             const commandToDisplay = normalizeTerminalCommandForDisplay(args.command);
             return {
                 invocationMessage: ( new MarkdownString(( localize(
-                    14358,
+                    14488,
                     "Not running `{0}` because unsandboxed execution is disabled",
                     escapeMarkdownSyntaxTokens(buildCommandDisplayText(commandToDisplay))
                 )))),
@@ -657,19 +666,19 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         if (missingDependencies) {
             const depsList = missingDependencies.join(", ");
             sandboxConfirmationMessageForMissingDeps = {
-                title: ( localize(14359, "Missing Sandbox Dependencies")),
+                title: ( localize(14489, "Missing Sandbox Dependencies")),
                 message: ( new MarkdownString(( localize(
-                    14360,
+                    14490,
                     "The following dependencies required for sandboxed execution are not installed: {0}. Would you like to install them?",
                     depsList
                 )))),
                 customOptions: [{
                     id: "install",
-                    label: ( localize(14361, "Install")),
+                    label: ( localize(14491, "Install")),
                     kind: ConfirmationOptionKind.Approve
                 }, {
                     id: "cancel",
-                    label: ( localize(14362, "Cancel")),
+                    label: ( localize(14492, "Cancel")),
                     kind: ConfirmationOptionKind.Deny
                 }]
             };
@@ -766,12 +775,12 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 cwdLabel: directoryLabel,
                 cdPrefix
             };
-            confirmationTitle = ( localize(14363, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
+            confirmationTitle = ( localize(14493, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
         } else {
             toolSpecificData.confirmation = {
                 commandLine: commandToDisplay
             };
-            confirmationTitle = ( localize(14364, "Run `{0}` command?", shellType));
+            confirmationTitle = ( localize(14494, "Run `{0}` command?", shellType));
         }
         const commandForPresenter = extractedCd?.command ?? commandToDisplay;
         let presenterInput = commandForPresenter;
@@ -792,7 +801,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 if (extractedCd && toolSpecificData.confirmation?.cwdLabel) {
                     if (presenterResult.languageDisplayName) {
                         confirmationTitle = ( localize(
-                            14365,
+                            14495,
                             "Run `{0}` command in `{1}` within `{2}`?",
                             presenterResult.languageDisplayName,
                             shellType,
@@ -800,7 +809,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                         ));
                     } else {
                         confirmationTitle = ( localize(
-                            14366,
+                            14496,
                             "Run command in `{0}` within `{1}`?",
                             shellType,
                             toolSpecificData.confirmation.cwdLabel
@@ -809,13 +818,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 } else {
                     if (presenterResult.languageDisplayName) {
                         confirmationTitle = ( localize(
-                            14367,
+                            14497,
                             "Run `{0}` command in `{1}`?",
                             presenterResult.languageDisplayName,
                             shellType
                         ));
                     } else {
-                        confirmationTitle = ( localize(14368, "Run command in `{0}`?", shellType));
+                        confirmationTitle = ( localize(14498, "Run command in `{0}`?", shellType));
                     }
                 }
                 if (!presenterResult.processOtherPresenters) {
@@ -826,28 +835,28 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         }
         if (requiresUnsandboxConfirmation) {
             confirmationTitle = blockedDomains?.length ? ( localize(
-                14369,
+                14499,
                 "Run `{0}` command outside the [sandbox]({1}) to access {2}?",
                 shellType,
                 TERMINAL_SANDBOX_DOCUMENTATION_URL,
                 this._formatBlockedDomainsForTitle(blockedDomains)
             )) : ( localize(
-                14370,
+                14500,
                 "Run `{0}` command outside the [sandbox]({1})?",
                 shellType,
                 TERMINAL_SANDBOX_DOCUMENTATION_URL
             ));
         }
         const shouldShowConfirmation = (!isFinalAutoApproved && !isSessionAutoApproved) || context.forceConfirmationReason !== undefined;
-        const explanation = args.explanation || ( localize(14371, "No explanation provided"));
-        const goal = args.goal || ( localize(14372, "No goal provided"));
+        const explanation = args.explanation || ( localize(14501, "No explanation provided"));
+        const goal = args.goal || ( localize(14502, "No goal provided"));
         const confirmationMessage = requiresUnsandboxConfirmation ? ( new MarkdownString(( localize(
-            14373,
+            14503,
             "Explanation: {0}\n\nGoal: {1}\n\nReason for leaving the sandbox: {2}",
             explanation,
             goal,
-            requestUnsandboxedExecutionReason || ( localize(14374, "The model indicated that this command needs unsandboxed access."))
-        )))) : ( new MarkdownString(( localize(14375, "Explanation: {0}\n\nGoal: {1}", explanation, goal))));
+            requestUnsandboxedExecutionReason || ( localize(14504, "The model indicated that this command needs unsandboxed access."))
+        )))) : ( new MarkdownString(( localize(14505, "Explanation: {0}\n\nGoal: {1}", explanation, goal))));
         const confirmationMessages = shouldShowConfirmation ? {
             title: confirmationTitle,
             message: confirmationMessage,
@@ -858,10 +867,10 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         const rawDisplayCommand = toolSpecificData.commandLine.forDisplay ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original;
         const displayCommand = rawDisplayCommand.length > 80 ? rawDisplayCommand.substring(0, 77) + "..." : rawDisplayCommand;
         const invocationMessage = toolSpecificData.commandLine.isSandboxWrapped ? ( new MarkdownString(( localize(
-            14376,
+            14506,
             "Running `{0}` in sandbox",
             escapeMarkdownSyntaxTokens(displayCommand)
-        )))) : ( new MarkdownString(( localize(14377, "Running `{0}`", escapeMarkdownSyntaxTokens(displayCommand)))));
+        )))) : ( new MarkdownString(( localize(14507, "Running `{0}`", escapeMarkdownSyntaxTokens(displayCommand)))));
         return {
             invocationMessage,
             icon: toolSpecificData.commandLine.isSandboxWrapped ? Codicon.terminalSecure : Codicon.terminal,
@@ -874,7 +883,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             return `\`${blockedDomains[0]}\``;
         }
         return localize(
-            14378,
+            14508,
             "`{0}` and {1} more domains",
             blockedDomains[0],
             blockedDomains.length - 1
@@ -884,13 +893,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         if (deniedDomains.length === blockedDomains.length && deniedDomains.length > 0) {
             if (blockedDomains.length === 1) {
                 return localize(
-                    14379,
+                    14509,
                     "This command accesses {0}, which is blocked by chat.agent.deniedNetworkDomains.",
                     blockedDomains[0]
                 );
             }
             return localize(
-                14380,
+                14510,
                 "This command accesses {0} and {1} more domains that are blocked by chat.agent.deniedNetworkDomains.",
                 blockedDomains[0],
                 blockedDomains.length - 1
@@ -899,13 +908,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         if (deniedDomains.length > 0) {
             if (blockedDomains.length === 1) {
                 return localize(
-                    14381,
+                    14511,
                     "This command accesses {0}, which is blocked by chat.agent.deniedNetworkDomains or not added to chat.agent.allowedNetworkDomains.",
                     blockedDomains[0]
                 );
             }
             return localize(
-                14382,
+                14512,
                 "This command accesses {0} and {1} more domains that are blocked by chat.agent.deniedNetworkDomains or not added to chat.agent.allowedNetworkDomains.",
                 blockedDomains[0],
                 blockedDomains.length - 1
@@ -913,13 +922,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         }
         if (blockedDomains.length === 1) {
             return localize(
-                14383,
+                14513,
                 "This command accesses {0}, which is not permitted by the current chat.agent.sandbox configuration.",
                 blockedDomains[0]
             );
         }
         return localize(
-            14384,
+            14514,
             "This command accesses {0} and {1} more domains that are not permitted by the current chat.agent.sandbox configuration.",
             blockedDomains[0],
             blockedDomains.length - 1
@@ -1008,13 +1017,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             const part = ( new ChatElicitationRequestPart(
                 this._getAutomaticUnsandboxRetryTitle(shellType, blockedDomains),
                 ( new MarkdownString(( localize(
-                14385,
+                14515,
                 "`{0}`",
                 escapeMarkdownSyntaxTokens(buildCommandDisplayText(command))
             )))),
                 "",
-                ( localize(14386, "Allow")),
-                ( localize(14387, "Skip")),
+                ( localize(14516, "Allow")),
+                ( localize(14517, "Skip")),
                 async () => {
                     resolveOnce(true);
                     part.hide();
@@ -1039,11 +1048,11 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
     }
     _getAutomaticUnsandboxRetryTitle(shellType, blockedDomains) {
         return blockedDomains?.length ? ( new MarkdownString(( localize(
-            14388,
+            14518,
             "Run `{0}` command outside the sandbox to access {1}?",
             shellType,
             this._formatBlockedDomainsForTitle(blockedDomains)
-        )))) : ( new MarkdownString(( localize(14389, "Run `{0}` command outside the sandbox?", shellType))));
+        )))) : ( new MarkdownString(( localize(14519, "Run `{0}` command outside the sandbox?", shellType))));
     }
     _registerSensitiveInputElicitation(
         chatSessionResource,
@@ -1071,10 +1080,10 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 if (chatModel instanceof ChatModel) {
                     const request = chatModel.getRequests().at(-1);
                     if (request) {
-                        const infoPart = ( new ChatElicitationRequestPart(( new MarkdownString(( localize(14390, "Terminal command cancelled — sensitive input required")))), ( new MarkdownString(( localize(
-                            14391,
+                        const infoPart = ( new ChatElicitationRequestPart(( new MarkdownString(( localize(14520, "Terminal command cancelled — sensitive input required")))), ( new MarkdownString(( localize(
+                            14521,
                             "The terminal command was prompting for a password or other secret. Auto-approve / autopilot mode cannot safely supply secrets, so the command was cancelled. Run the command interactively if you want to provide the secret."
-                        )))), "", ( localize(14392, "Dismiss")), "", async () => {
+                        )))), "", ( localize(14522, "Dismiss")), "", async () => {
                             infoPart.hide();
                             return ElicitationState.Accepted;
                         }, async () => {
@@ -1098,10 +1107,10 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             if (!request) {
                 return;
             }
-            const part = ( new ChatElicitationRequestPart(( new MarkdownString(( localize(14393, "Terminal is waiting for sensitive input")))), ( new MarkdownString(( localize(
-                14394,
+            const part = ( new ChatElicitationRequestPart(( new MarkdownString(( localize(14523, "Terminal is waiting for sensitive input")))), ( new MarkdownString(( localize(
+                14524,
                 "The terminal command appears to be prompting for a password or other sensitive value. Focus the terminal to type it directly — secrets must not be sent through chat."
-            )))), "", ( localize(14395, "Focus Terminal")), ( localize(14396, "Cancel Command")), async () => {
+            )))), "", ( localize(14525, "Focus Terminal")), ( localize(14526, "Cancel Command")), async () => {
                 pending = undefined;
                 part.hide();
                 try {
@@ -1146,10 +1155,10 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         const progress = {
             kind: "externalToolInvocationUpdate",
             toolCallId,
-            toolName: ( localize(14352, "Run in Terminal")),
+            toolName: ( localize(14482, "Run in Terminal")),
             isComplete,
             invocationMessage: ( new MarkdownString(( localize(
-                14397,
+                14527,
                 "Running `{0}` outside the sandbox",
                 escapeMarkdownSyntaxTokens(displayCommand)
             )))),
@@ -1215,7 +1224,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                         content: [{
                             kind: "text",
                             value: ( localize(
-                                14398,
+                                14528,
                                 "Sandbox dependency installation failed (exit code {0}). The command was not executed.",
                                 exitCode
                             ))
@@ -1227,7 +1236,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                         content: [{
                             kind: "text",
                             value: ( localize(
-                                14399,
+                                14529,
                                 "Could not determine whether sandbox dependency installation succeeded. The command was not executed."
                             ))
                         }]
@@ -1241,7 +1250,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 return {
                     content: [{
                         kind: "text",
-                        value: ( localize(14400, "Sandbox dependency installation was cancelled by the user."))
+                        value: ( localize(14530, "Sandbox dependency installation was cancelled by the user."))
                     }]
                 };
             }
@@ -1273,7 +1282,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         }
         let error;
         const automaticUnsandboxRetryReason = ( localize(
-            14401,
+            14531,
             "The sandboxed execution output indicated the sandbox blocked the command."
         ));
         const isNewSession = !executionOptions.persistentSession && !( this._sessionTerminalAssociations.has(chatSessionResource));
@@ -1311,6 +1320,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         let exitCode;
         let altBufferResult;
         let didTimeout = false;
+        let didIdleSilence = false;
         let didInputNeeded = false;
         let didSensitiveAutoCancelled = false;
         let isBackgroundExecution = executionOptions.persistentSession;
@@ -1421,7 +1431,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                         resultText += `${outputAnalyzerMessage}\n`;
                     }
                     resultText += pollingResult.output;
-                    resultText += `\n${this._buildInputNeededSteeringText(chatSessionResource, termId,  false)}`;
+                    resultText += `\n${this._buildInputNeededSteeringText(chatSessionResource, termId, "none")}`;
                 } else if (pollingResult) {
                     resultText += `\n The command is still running, with output:\n`;
                     if (outputAnalyzerMessage) {
@@ -1474,8 +1484,22 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 if (timeoutRacePromise) {
                     raceCandidates.push(timeoutRacePromise);
                 }
-                const raceResult = await Promise.race(raceCandidates);
-                raceCleanup.dispose();
+                const idleSilenceMs = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdleSilenceTimeoutMs) ?? 60000;
+                if (idleSilenceMs > 0) {
+                    const idleSilenceDeferred = ( new DeferredPromise());
+                    const idleSilenceScheduler = raceCleanup.add(( new RunOnceScheduler(() => idleSilenceDeferred.complete({
+                        type: "idleSilence"
+                    }), idleSilenceMs)));
+                    raceCleanup.add(toolTerminal.instance.onData(() => idleSilenceScheduler.schedule()));
+                    idleSilenceScheduler.schedule();
+                    raceCandidates.push(idleSilenceDeferred.p);
+                }
+                let raceResult;
+                try {
+                    raceResult = await Promise.race(raceCandidates);
+                } finally {
+                    raceCleanup.dispose();
+                }
                 if (raceResult.type === "inputNeeded") {
                     this._logService.debug(
                         `RunInTerminalTool: Output monitor detected input needed in foreground terminal, returning output to agent`
@@ -1499,6 +1523,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     didTimeout = true;
                     isBackgroundExecution = true;
                     toolTerminal.isBackground = true;
+                    toolSpecificData.didContinueInBackground = true;
                     this._sessionTerminalAssociations.delete(chatSessionResource);
                     await this._associateProcessIdWithSession(
                         toolTerminal.instance,
@@ -1510,6 +1535,26 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     const timeoutOutput = execution.getOutput();
                     outputLineCount = timeoutOutput ? count(timeoutOutput.trim(), "\n") + 1 : 0;
                     terminalResult = timeoutOutput ?? "";
+                } else if (raceResult.type === "idleSilence") {
+                    this._logService.debug(
+                        `RunInTerminalTool: Idle silence reached (${idleSilenceMs}ms), promoting to background`
+                    );
+                    error = "idleSilence";
+                    didIdleSilence = true;
+                    isBackgroundExecution = true;
+                    toolTerminal.isBackground = true;
+                    toolSpecificData.didContinueInBackground = true;
+                    this._sessionTerminalAssociations.delete(chatSessionResource);
+                    await this._associateProcessIdWithSession(
+                        toolTerminal.instance,
+                        chatSessionResource,
+                        termId,
+                        toolTerminal.shellIntegrationQuality,
+                        true
+                    );
+                    const idleSilenceOutput = execution.getOutput();
+                    outputLineCount = idleSilenceOutput ? count(idleSilenceOutput.trim(), "\n") + 1 : 0;
+                    terminalResult = idleSilenceOutput ?? "";
                 } else {
                     const executeResult = raceResult.result;
                     toolTerminal.receivedUserInput = false;
@@ -1573,6 +1618,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 error = "timeout";
                 isBackgroundExecution = true;
                 toolTerminal.isBackground = true;
+                toolSpecificData.didContinueInBackground = true;
                 this._sessionTerminalAssociations.delete(chatSessionResource);
                 const timeoutOutput = getOutput(toolTerminal.instance, undefined);
                 outputLineCount = timeoutOutput ? count(timeoutOutput.trim(), "\n") + 1 : 0;
@@ -1610,6 +1656,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                         termId,
                         chatSessionResource,
                         command,
+                        toolSpecificData,
                         outputMonitor,
                         alreadyNotifiedInputNeededOutput
                     );
@@ -1765,12 +1812,17 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             );
         } else if (didInputNeeded) {
             resultText.push(
-                `Note: The command is running in terminal ID ${termId} and may be waiting for input.\n${this._buildInputNeededSteeringText(chatSessionResource, termId,  false)}\n\n`
+                `Note: The command is running in terminal ID ${termId} and may be waiting for input.\n${this._buildInputNeededSteeringText(chatSessionResource, termId, "none")}\n\n`
             );
         } else if (didTimeout && timeoutValue !== undefined && timeoutValue > 0) {
             const notificationHint = shouldSendNotifications ? " You will be automatically notified on your next turn when it completes." : "";
             resultText.push(
-                `Note: Command timed out after ${timeoutValue}ms. The command may still be running in terminal ID ${termId}.${notificationHint}\n${this._buildInputNeededSteeringText(chatSessionResource, termId,  true)}\n\n`
+                `Note: Command timed out after ${timeoutValue}ms. The command may still be running in terminal ID ${termId}.${notificationHint}\n${this._buildInputNeededSteeringText(chatSessionResource, termId, "timeout")}\n\n`
+            );
+        } else if (didIdleSilence) {
+            const notificationHint = shouldSendNotifications ? " You will be automatically notified on your next turn when it completes." : "";
+            resultText.push(
+                `Note: The command produced no new output for an extended period and was moved to background terminal ID ${termId}; the process is still running and has not been killed.${notificationHint}\n${this._buildInputNeededSteeringText(chatSessionResource, termId, "idleSilence")}\n\n`
             );
         }
         const outputAnalyzerMessage = await this._getOutputAnalyzerMessage(exitCode, terminalResult, command, didSandboxWrapCommand);
@@ -1807,7 +1859,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             }, ...imageContent]
         };
     }
-    _buildInputNeededSteeringText(chatSessionResource, termId, mentionTimeout) {
+    _buildInputNeededSteeringText(chatSessionResource, termId, hungHint) {
         const isAutoApproved = isSessionAutoApproveLevel(
             chatSessionResource,
             this._configurationService,
@@ -1833,10 +1885,14 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 `  2. Only if the output clearly ends with a real non-secret input prompt (Continue? (y/n), Enter selection, etc. — a normal shell prompt like \`$\` or \`#\` does NOT count), call the vscode_askQuestions tool to ask the user, then send each answer using ${TerminalToolId.SendToTerminal} with id="${termId}" (which returns the next few lines of output). Repeat one prompt at a time. NEVER route secret prompts (passwords, passphrases, tokens, API keys, etc.) through vscode_askQuestions — answers to that tool are sent through the model. For secret prompts, tell the user to type the value directly into the terminal and stop.`
             );
         }
-        if (mentionTimeout) {
+        if (hungHint === "timeout") {
             lines.push(
                 `  3. A timeout does not mean the command failed — call ${TerminalToolId.GetTerminalOutput} with id="${termId}" to continue polling. Only call ${TerminalToolId.KillTerminal} if the command is genuinely hung and you need to retry with a different approach.`
             );
+        } else if (hungHint === "idleSilence") {
+            lines.push(
+                `  3. Producing no output for an extended period does not mean the command failed — call ${TerminalToolId.GetTerminalOutput} with id="${termId}" to continue polling. Only call ${TerminalToolId.KillTerminal} if the command is genuinely hung and you need to retry with a different approach.`
+            );
         }
         return lines.join("\n");
     }
@@ -2153,6 +2209,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         termId,
         chatSessionResource,
         commandName,
+        toolSpecificData,
         outputMonitor,
         alreadyNotifiedInputNeededOutput
     ) {
@@ -2224,6 +2281,12 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     );
                     return;
                 }
+                if (terminalInstance.isDisposed) {
+                    this._logService.debug(
+                        `RunInTerminalTool: Suppressing input-needed notification for terminal ${termId} because the terminal is disposed`
+                    );
+                    return;
+                }
                 if (handleSessionCancelled()) {
                     return;
                 }
@@ -2239,7 +2302,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 }
                 lastInputNeededOutput = currentOutput;
                 lastInputNeededNotificationTime = now;
-                const inputAction = this._buildInputNeededSteeringText(chatSessionResource, termId,  false);
+                const inputAction = this._buildInputNeededSteeringText(chatSessionResource, termId, "none");
                 const message = `[Terminal ${termId} notification: command may be waiting for input — assess the output below.]\n${inputAction}\nTerminal output:\n${currentOutput}`;
                 this._logService.debug(
                     `RunInTerminalTool: Input needed in background terminal ${termId}, notifying chat session`
@@ -2248,7 +2311,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     ...sendOptions,
                     queue: ChatRequestQueueKind.Steering,
                     isSystemInitiated: true,
-                    systemInitiatedLabel: ( localize(14402, "`{0}` may need input", commandName)),
+                    systemInitiatedLabel: ( localize(14532, "`{0}` may need input", commandName)),
                     terminalExecutionId: termId
                 }).catch(e => {
                     this._logService.warn(
@@ -2279,7 +2342,8 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             const exitCode = command.exitCode;
             const exitCodeText = exitCode !== undefined ? ` with exit code ${exitCode}` : "";
             const currentOutput = execution.getOutput();
-            const message = `[Terminal ${termId} notification: command completed${exitCodeText}. Use send_to_terminal to send another command or kill_terminal to stop it.]\nTerminal output:\n${currentOutput}`;
+            const isUserVisible = this._terminalService.foregroundInstances.includes(terminalInstance);
+            const message = isUserVisible ? `[Terminal ${termId} notification: command completed${exitCodeText}. Use send_to_terminal to send another command or kill_terminal to stop it.]\nTerminal output:\n${currentOutput}` : `[Terminal ${termId} notification: command completed${exitCodeText}. The terminal has been cleaned up.]\nTerminal output:\n${currentOutput}`;
             this._logService.debug(
                 `RunInTerminalTool: Command completed in background terminal ${termId}, notifying chat session`
             );
@@ -2287,7 +2351,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 ...sendOptions,
                 queue: ChatRequestQueueKind.Steering,
                 isSystemInitiated: true,
-                systemInitiatedLabel: ( localize(14403, "`{0}` completed", commandName)),
+                systemInitiatedLabel: ( localize(14533, "`{0}` completed", commandName)),
                 terminalExecutionId: termId
             }).catch(e => {
                 this._logService.warn(
@@ -2295,6 +2359,19 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     e
                 );
             });
+            this._commandArtifactCollector.capture(toolSpecificData, terminalInstance, command.id).then(() => {
+                if (this._terminalService.foregroundInstances.includes(terminalInstance)) {
+                    this._logService.debug(
+                        `RunInTerminalTool: Background terminal ${termId} was revealed by user, skipping disposal`
+                    );
+                    return;
+                }
+                this._logService.debug(`RunInTerminalTool: Disposing finished background terminal ${termId}`);
+                RunInTerminalTool_1._killedByTool.add(termId);
+                execution.dispose();
+                RunInTerminalTool_1._activeExecutions.delete(termId);
+                terminalInstance.dispose();
+            });
         }));
         const executionForDisposal = RunInTerminalTool_1._activeExecutions.get(termId);
         store.add(terminalInstance.onDisposed(() => {
@@ -2302,6 +2379,10 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 disposeNotification();
                 return;
             }
+            if (this._isShuttingDown) {
+                disposeNotification();
+                return;
+            }
             if (handleSessionCancelled()) {
                 return;
             }
@@ -2317,7 +2398,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 ...sendOptions,
                 queue: ChatRequestQueueKind.Steering,
                 isSystemInitiated: true,
-                systemInitiatedLabel: ( localize(14404, "`{0}` terminal exited", commandName)),
+                systemInitiatedLabel: ( localize(14534, "`{0}` terminal exited", commandName)),
                 terminalExecutionId: termId
             }).catch(e => {
                 this._logService.warn(
@@ -2369,7 +2450,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         }
     }
 };
-RunInTerminalTool = RunInTerminalTool_1 = ( __decorate([( __param(0, IChatService)), ( __param(1, IConfigurationService)), ( __param(2, IFileService)), ( __param(3, IHistoryService)), ( __param(4, IInstantiationService)), ( __param(5, ILabelService)), ( __param(6, ILanguageModelToolsService)), ( __param(7, IRemoteAgentService)), ( __param(8, IStorageService)), ( __param(9, ITerminalChatService)), ( __param(10, ITerminalLogService)), ( __param(11, ITerminalService)), ( __param(12, ITerminalSandboxService)), ( __param(13, IWorkspaceContextService)), ( __param(14, IChatWidgetService)), ( __param(15, IAgentSessionsService))], RunInTerminalTool));
+RunInTerminalTool = RunInTerminalTool_1 = ( __decorate([( __param(0, IChatService)), ( __param(1, IConfigurationService)), ( __param(2, IFileService)), ( __param(3, IHistoryService)), ( __param(4, IInstantiationService)), ( __param(5, ILabelService)), ( __param(6, ILanguageModelToolsService)), ( __param(7, IRemoteAgentService)), ( __param(8, IStorageService)), ( __param(9, ITerminalChatService)), ( __param(10, ITerminalLogService)), ( __param(11, ITerminalService)), ( __param(12, ITerminalSandboxService)), ( __param(13, IWorkspaceContextService)), ( __param(14, IChatWidgetService)), ( __param(15, IAgentSessionsService)), ( __param(16, ILifecycleService))], RunInTerminalTool));
 let ActiveTerminalExecution = class ActiveTerminalExecution extends Disposable {
     get completionPromise() {
         return this._completionDeferred.p;