@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -1,19 +1,21 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { timeout, DeferredPromise } 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';
 import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { basename, win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import { OS, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { count } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
@@ -31,18 +33,26 @@ import { BasicExecuteStrategy } from '../executeStrategy/basicExecuteStrategy.js
 import { NoneExecuteStrategy } from '../executeStrategy/noneExecuteStrategy.js';
 import { RichExecuteStrategy } from '../executeStrategy/richExecuteStrategy.js';
 import { getOutput } from '../outputHelpers.js';
-import { isWindowsPowerShell, isPowerShell, isZsh, isFish } from '../runInTerminalHelpers.js';
+import { isWindowsPowerShell, isPowerShell, isZsh, isFish, extractCdPrefix } from '../runInTerminalHelpers.js';
+import { NodeCommandLinePresenter } from './commandLinePresenter/nodeCommandLinePresenter.js';
+import { PythonCommandLinePresenter } from './commandLinePresenter/pythonCommandLinePresenter.js';
+import { RubyCommandLinePresenter } from './commandLinePresenter/rubyCommandLinePresenter.js';
+import { SandboxedCommandLinePresenter } from './commandLinePresenter/sandboxedCommandLinePresenter.js';
 import { RunInTerminalToolTelemetry } from '../runInTerminalToolTelemetry.js';
 import { ToolTerminalCreator, ShellIntegrationQuality } from '../toolTerminalCreator.js';
 import { TreeSitterCommandParser, TreeSitterCommandParserLanguage } from '../treeSitterCommandParser.js';
 import { CommandLineAutoApproveAnalyzer } from './commandLineAnalyzer/commandLineAutoApproveAnalyzer.js';
 import { CommandLineFileWriteAnalyzer } from './commandLineAnalyzer/commandLineFileWriteAnalyzer.js';
+import { CommandLineSandboxAnalyzer } from './commandLineAnalyzer/commandLineSandboxAnalyzer.js';
 import { OutputMonitor } from './monitoring/outputMonitor.js';
 import { OutputMonitorState } from './monitoring/types.js';
-import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { LocalChatSessionUri, chatSessionResourceToId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { TerminalToolId } from './toolIds.js';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { CommandLineCdPrefixRewriter } from './commandLineRewriter/commandLineCdPrefixRewriter.js';
 import { CommandLinePreventHistoryRewriter } from './commandLineRewriter/commandLinePreventHistoryRewriter.js';
 import { CommandLinePwshChainOperatorRewriter } from './commandLineRewriter/commandLinePwshChainOperatorRewriter.js';
+import { CommandLineSandboxRewriter } from './commandLineRewriter/commandLineSandboxRewriter.js';
 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 { TerminalCommandArtifactCollector } from './terminalCommandArtifactCollector.js';
@@ -50,50 +60,52 @@ import { isNumber, isString } from '@codingame/monaco-vscode-api/vscode/vs/base/
 import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { TerminalChatCommandId } from '@codingame/monaco-vscode-xterm-common/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat';
+import { clamp } from '@codingame/monaco-vscode-api/vscode/vs/base/common/numbers';
 
 var RunInTerminalTool_1;
-const TOOL_REFERENCE_NAME = 'runInTerminal';
-const LEGACY_TOOL_REFERENCE_FULL_NAMES = ['runCommands/runInTerminal'];
+const TOOL_REFERENCE_NAME = "runInTerminal";
+const LEGACY_TOOL_REFERENCE_FULL_NAMES = ["runCommands/runInTerminal"];
 function createPowerShellModelDescription(shell) {
     const isWinPwsh = isWindowsPowerShell(shell);
     return [
-        `This tool allows you to execute ${isWinPwsh ? 'Windows PowerShell 5.1' : 'PowerShell'} commands in a persistent terminal session, preserving environment variables, working directory, and other context across multiple commands.`,
-        '',
-        'Command Execution:',
-        isWinPwsh ? '- Use semicolons ; to chain commands on one line, NEVER use && even when asked explicitly' : '- Prefer ; when chaining commands on one line',
-        '- Prefer pipelines | for object-based data flow',
-        '- Never create a sub-shell (eg. powershell -c "command") unless explicitly asked',
-        '',
-        'Directory Management:',
-        '- Must use absolute paths to avoid navigation issues',
-        '- Use $PWD or Get-Location for current directory',
-        '- Use Push-Location/Pop-Location for directory stack',
-        '',
-        'Program Execution:',
-        '- Supports .NET, Python, Node.js, and other executables',
-        '- Install modules via Install-Module, Install-Package',
-        '- Use Get-Command to verify cmdlet/function availability',
-        '',
-        'Background Processes:',
-        '- For long-running tasks (e.g., servers), set isBackground=true',
-        '- Returns a terminal ID for checking status and runtime later',
-        '- Use Start-Job for background PowerShell jobs',
-        '',
-        'Output Management:',
-        '- Output is automatically truncated if longer than 60KB to prevent context overflow',
-        '- Use Select-Object, Where-Object, Format-Table to filter output',
-        '- Use -First/-Last parameters to limit results',
-        '- For pager commands, add | Out-String or | Format-List',
-        '',
-        'Best Practices:',
-        '- Use proper cmdlet names instead of aliases in scripts',
-        '- Quote paths with spaces: "C:\\Path With Spaces"',
-        '- Prefer PowerShell cmdlets over external commands when available',
-        '- Prefer idiomatic PowerShell like Get-ChildItem instead of dir or ls for file listings',
-        '- Use Test-Path to check file/directory existence',
-        '- Be specific with Select-Object properties to avoid excessive output',
-        '- Avoid printing credentials unless absolutely required',
-    ].join('\n');
+        `This tool allows you to execute ${isWinPwsh ? "Windows PowerShell 5.1" : "PowerShell"} commands in a persistent terminal session, preserving environment variables, working directory, and other context across multiple commands.`,
+        "",
+        "Command Execution:",
+        isWinPwsh ? "- Use semicolons ; to chain commands on one line, NEVER use && even when asked explicitly" : "- Prefer ; when chaining commands on one line",
+        "- Prefer pipelines | for object-based data flow",
+        "- Never create a sub-shell (eg. powershell -c \"command\") unless explicitly asked",
+        "",
+        "Directory Management:",
+        "- Prefer relative paths when navigating directories, only use absolute when the path is far away or the current cwd is not expected",
+        "- Remember when isBackground=false is specified, that the shell and cwd are reused until it is moved to the background",
+        "- Use $PWD or Get-Location for current directory",
+        "- Use Push-Location/Pop-Location for directory stack",
+        "",
+        "Program Execution:",
+        "- Supports .NET, Python, Node.js, and other executables",
+        "- Install modules via Install-Module, Install-Package",
+        "- Use Get-Command to verify cmdlet/function availability",
+        "",
+        "Background Processes:",
+        "- For long-running tasks (e.g., servers), set isBackground=true",
+        "- Returns a terminal ID for checking status and runtime later",
+        "- Use Start-Job for background PowerShell jobs",
+        "",
+        "Output Management:",
+        "- Output is automatically truncated if longer than 60KB to prevent context overflow",
+        "- Use Select-Object, Where-Object, Format-Table to filter output",
+        "- Use -First/-Last parameters to limit results",
+        "- For pager commands, add | Out-String or | Format-List",
+        "",
+        "Best Practices:",
+        "- Use proper cmdlet names instead of aliases in scripts",
+        "- Quote paths with spaces: \"C:\\Path With Spaces\"",
+        "- Prefer PowerShell cmdlets over external commands when available",
+        "- Prefer idiomatic PowerShell like Get-ChildItem instead of dir or ls for file listings",
+        "- Use Test-Path to check file/directory existence",
+        "- Be specific with Select-Object properties to avoid excessive output",
+        "- Avoid printing credentials unless absolutely required"
+    ].join("\n");
 }
 const genericDescription = `
 Command Execution:
@@ -102,7 +114,8 @@ Command Execution:
 - Never create a sub-shell (eg. bash -c "command") unless explicitly asked
 
 Directory Management:
-- Must use absolute paths to avoid navigation issues
+- Prefer relative paths when navigating directories, only use absolute when the path is far away or the current cwd is not expected
+- Remember when isBackground=false is specified, that shell and cwd is reused until it is moved to the background
 - Use $PWD for current directory references
 - Consider using pushd/popd for directory stack management
 - Supports directory shortcuts like ~ and -
@@ -129,37 +142,37 @@ Best Practices:
 - Avoid printing credentials unless absolutely required`;
 function createBashModelDescription() {
     return [
-        'This tool allows you to execute shell commands in a persistent bash terminal session, preserving environment variables, working directory, and other context across multiple commands.',
+        "This tool allows you to execute shell commands in a persistent bash terminal session, preserving environment variables, working directory, and other context across multiple commands.",
         genericDescription,
-        '- Use [[ ]] for conditional tests instead of [ ]',
-        '- Prefer $() over backticks for command substitution',
-        '- Use set -e at start of complex commands to exit on errors'
-    ].join('\n');
+        "- Use [[ ]] for conditional tests instead of [ ]",
+        "- Prefer $() over backticks for command substitution",
+        "- Use set -e at start of complex commands to exit on errors"
+    ].join("\n");
 }
 function createZshModelDescription() {
     return [
-        'This tool allows you to execute shell commands in a persistent zsh terminal session, preserving environment variables, working directory, and other context across multiple commands.',
+        "This tool allows you to execute shell commands in a persistent zsh terminal session, preserving environment variables, working directory, and other context across multiple commands.",
         genericDescription,
-        '- Use type to check command type (builtin, function, alias)',
-        '- Use jobs, fg, bg for job control',
-        '- Use [[ ]] for conditional tests instead of [ ]',
-        '- Prefer $() over backticks for command substitution',
-        '- Use setopt errexit for strict error handling',
-        '- Take advantage of zsh globbing features (**, extended globs)'
-    ].join('\n');
+        "- Use type to check command type (builtin, function, alias)",
+        "- Use jobs, fg, bg for job control",
+        "- Use [[ ]] for conditional tests instead of [ ]",
+        "- Prefer $() over backticks for command substitution",
+        "- Use setopt errexit for strict error handling",
+        "- Take advantage of zsh globbing features (**, extended globs)"
+    ].join("\n");
 }
 function createFishModelDescription() {
     return [
-        'This tool allows you to execute shell commands in a persistent fish terminal session, preserving environment variables, working directory, and other context across multiple commands.',
+        "This tool allows you to execute shell commands in a persistent fish terminal session, preserving environment variables, working directory, and other context across multiple commands.",
         genericDescription,
-        '- Use type to check command type (builtin, function, alias)',
-        '- Use jobs, fg, bg for job control',
-        '- Use test expressions for conditionals (no [[ ]] syntax)',
-        '- Prefer command substitution with () syntax',
-        '- Variables are arrays by default, use $var[1] for first element',
-        '- Use set -e for strict error handling',
-        '- Take advantage of fish\'s autosuggestions and completions'
-    ].join('\n');
+        "- Use type to check command type (builtin, function, alias)",
+        "- Use jobs, fg, bg for job control",
+        "- Use test expressions for conditionals (no [[ ]] syntax)",
+        "- Prefer command substitution with () syntax",
+        "- Variables are arrays by default, use $var[1] for first element",
+        "- Use set -e for strict error handling",
+        "- Take advantage of fish's autosuggestions and completions"
+    ].join("\n");
 }
 async function createRunInTerminalToolData(accessor) {
     const instantiationService = accessor.get(IInstantiationService);
@@ -169,74 +182,105 @@ async function createRunInTerminalToolData(accessor) {
     let modelDescription;
     if (shell && os && isPowerShell(shell, os)) {
         modelDescription = createPowerShellModelDescription(shell);
-    }
-    else if (shell && os && isZsh(shell, os)) {
+    } else if (shell && os && isZsh(shell, os)) {
         modelDescription = createZshModelDescription();
-    }
-    else if (shell && os && isFish(shell, os)) {
+    } else if (shell && os && isFish(shell, os)) {
         modelDescription = createFishModelDescription();
-    }
-    else {
+    } else {
         modelDescription = createBashModelDescription();
     }
     return {
-        id: 'run_in_terminal',
+        id: TerminalToolId.RunInTerminal,
         toolReferenceName: TOOL_REFERENCE_NAME,
         legacyToolReferenceFullNames: LEGACY_TOOL_REFERENCE_FULL_NAMES,
-        displayName: ( localize(12058, 'Run in Terminal')),
+        displayName: ( localize(12392, "Run in Terminal")),
         modelDescription,
-        userDescription: ( localize(12059, 'Run commands in the terminal')),
+        userDescription: ( localize(12393, "Run commands in the terminal")),
         source: ToolDataSource.Internal,
         icon: Codicon.terminal,
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
                 command: {
-                    type: 'string',
-                    description: 'The command to run in the terminal.'
+                    type: "string",
+                    description: "The command to run in the terminal."
                 },
                 explanation: {
-                    type: 'string',
-                    description: 'A one-sentence description of what the command does. This will be shown to the user before the command is run.'
+                    type: "string",
+                    description: "A one-sentence description of what the command does. This will be shown to the user before the command is run."
+                },
+                goal: {
+                    type: "string",
+                    description: "A short description of the goal or purpose of the command (e.g., \"Install dependencies\", \"Start development server\")."
                 },
                 isBackground: {
-                    type: 'boolean',
-                    description: 'Whether the command starts a background process. If true, the command will run in the background and you will not see the output. If false, the tool call will block on the command finishing, and then you will get the output. Examples of background processes: building in watch mode, starting a server. You can check the output of a background process later on by using get_terminal_output.'
+                    type: "boolean",
+                    description: `Whether the command starts a background process.\n\n- If true, a new shell will be spawned where the cwd is the workspace directory and will run asynchronously in the background and you will not see the output.\n\n- If false, a single shell is shared between all non-background terminals where the cwd starts at the workspace directory and is remembered until that terminal is moved to the background, the tool call will block on the command finishing and only then you will get the output.\n\nExamples of background processes: building in watch mode, starting a server. You can check the output of a background process later on by using ${TerminalToolId.GetTerminalOutput}.`
                 },
+                timeout: {
+                    type: "number",
+                    description: "An optional timeout in milliseconds. When provided, the tool will stop tracking the command after this duration and return the output collected so far. Be conservative with the timeout duration, give enough time that the command would complete on a low-end machine. Use 0 for no timeout. If it's not clear how long the command will take then use 0 to avoid prematurely terminating it, never guess too low."
+                }
             },
-            required: [
-                'command',
-                'explanation',
-                'isBackground',
-            ]
+            required: ["command", "explanation", "goal", "isBackground", "timeout"]
         }
     };
 }
 var TerminalToolStorageKeysInternal;
-(function (TerminalToolStorageKeysInternal) {
+(function(TerminalToolStorageKeysInternal) {
     TerminalToolStorageKeysInternal["TerminalSession"] = "chat.terminalSessions";
 })(TerminalToolStorageKeysInternal || (TerminalToolStorageKeysInternal = {}));
 const telemetryIgnoredSequences = [
-    '\x1b[I',
-    '\x1b[O',
-];
-const altBufferMessage = ( localize(12060, "The command opened the alternate buffer."));
+"\u001b[I",
+"\u001b[O"];
+const altBufferMessage = ( localize(12394, "The command opened the alternate buffer."));
 let RunInTerminalTool = class RunInTerminalTool extends Disposable {
-    static { RunInTerminalTool_1 = this; }
-    static { this._backgroundExecutions = ( new Map()); }
+    static {
+        RunInTerminalTool_1 = this;
+    }
+    static {
+        this._activeExecutions = ( new Map());
+    }
     static getBackgroundOutput(id) {
-        const backgroundExecution = RunInTerminalTool_1._backgroundExecutions.get(id);
-        if (!backgroundExecution) {
-            throw ( new Error('Invalid terminal ID'));
+        const execution = RunInTerminalTool_1._activeExecutions.get(id);
+        if (!execution) {
+            throw ( new Error("Invalid terminal ID"));
+        }
+        return execution.getOutput();
+    }
+    static getExecution(id) {
+        return RunInTerminalTool_1._activeExecutions.get(id);
+    }
+    static removeExecution(id) {
+        const execution = RunInTerminalTool_1._activeExecutions.get(id);
+        if (!execution) {
+            return false;
         }
-        return backgroundExecution.getOutput();
+        execution.dispose();
+        RunInTerminalTool_1._activeExecutions.delete(id);
+        return true;
     }
-    constructor(_chatService, _configurationService, _historyService, _instantiationService, _languageModelToolsService, _remoteAgentService, _storageService, _terminalChatService, _logService, _terminalService, _workspaceContextService, _chatWidgetService) {
+    constructor(
+        _chatService,
+        _configurationService,
+        _historyService,
+        _instantiationService,
+        _labelService,
+        _languageModelToolsService,
+        _remoteAgentService,
+        _storageService,
+        _terminalChatService,
+        _logService,
+        _terminalService,
+        _workspaceContextService,
+        _chatWidgetService
+    ) {
         super();
         this._chatService = _chatService;
         this._configurationService = _configurationService;
         this._historyService = _historyService;
         this._instantiationService = _instantiationService;
+        this._labelService = _labelService;
         this._languageModelToolsService = _languageModelToolsService;
         this._remoteAgentService = _remoteAgentService;
         this._storageService = _storageService;
@@ -245,7 +289,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         this._terminalService = _terminalService;
         this._workspaceContextService = _workspaceContextService;
         this._chatWidgetService = _chatWidgetService;
-        this._sessionTerminalAssociations = ( new Map());
+        this._sessionTerminalAssociations = ( new ResourceMap());
         this._osBackend = this._remoteAgentService.getEnvironment().then(remoteEnv => remoteEnv?.os ?? OS);
         this._terminalToolCreator = this._instantiationService.createInstance(ToolTerminalCreator);
         this._treeSitterCommandParser = this._register(this._instantiationService.createInstance(TreeSitterCommandParser));
@@ -254,57 +298,80 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         this._profileFetcher = this._instantiationService.createInstance(TerminalProfileFetcher);
         this._commandLineRewriters = [
             this._register(this._instantiationService.createInstance(CommandLineCdPrefixRewriter)),
-            this._register(this._instantiationService.createInstance(CommandLinePwshChainOperatorRewriter, this._treeSitterCommandParser)),
-            this._register(this._instantiationService.createInstance(CommandLinePreventHistoryRewriter)),
+            this._register(
+                this._instantiationService.createInstance(CommandLinePwshChainOperatorRewriter, this._treeSitterCommandParser)
+            ),
+            this._register(
+                this._instantiationService.createInstance(CommandLinePreventHistoryRewriter)
+            ),
+            this._register(this._instantiationService.createInstance(CommandLineSandboxRewriter))
         ];
-        this._commandLineAnalyzers = [
-            this._register(this._instantiationService.createInstance(CommandLineFileWriteAnalyzer, this._treeSitterCommandParser, (message, args) => this._logService.info(`RunInTerminalTool#CommandLineFileWriteAnalyzer: ${message}`, args))),
-            this._register(this._instantiationService.createInstance(CommandLineAutoApproveAnalyzer, this._treeSitterCommandParser, this._telemetry, (message, args) => this._logService.info(`RunInTerminalTool#CommandLineAutoApproveAnalyzer: ${message}`, args))),
+        this._commandLineAnalyzers = [this._register(this._instantiationService.createInstance(
+            CommandLineFileWriteAnalyzer,
+            this._treeSitterCommandParser,
+            (message, args) => this._logService.info(`RunInTerminalTool#CommandLineFileWriteAnalyzer: ${message}`, args)
+        )), this._register(this._instantiationService.createInstance(
+            CommandLineAutoApproveAnalyzer,
+            this._treeSitterCommandParser,
+            this._telemetry,
+            (message, args) => this._logService.info(`RunInTerminalTool#CommandLineAutoApproveAnalyzer: ${message}`, args)
+        )), this._register(this._instantiationService.createInstance(CommandLineSandboxAnalyzer))];
+        this._commandLinePresenters = [
+            this._instantiationService.createInstance(SandboxedCommandLinePresenter),
+            ( new NodeCommandLinePresenter()),
+            ( new PythonCommandLinePresenter()),
+            ( new RubyCommandLinePresenter())
         ];
-        this._register(Event.runAndSubscribe(this._configurationService.onDidChangeConfiguration, e => {
-            if (!e || e.affectsConfiguration(TerminalChatAgentToolsSettingId.EnableAutoApprove)) {
-                if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) !== true) {
-                    this._storageService.remove(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION);
+        this._register(
+            Event.runAndSubscribe(this._configurationService.onDidChangeConfiguration, e => {
+                if (!e || e.affectsConfiguration(TerminalChatAgentToolsSettingId.EnableAutoApprove)) {
+                    if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) !== true) {
+                        this._storageService.remove(
+                            TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted,
+                            StorageScope.APPLICATION
+                        );
+                    }
                 }
-            }
-        }));
+            })
+        );
         this._restoreTerminalAssociations();
         this._register(this._terminalService.onDidDisposeInstance(e => {
-            for (const [sessionId, toolTerminal] of this._sessionTerminalAssociations.entries()) {
+            for (const [sessionResource, toolTerminal] of this._sessionTerminalAssociations.entries()) {
                 if (e === toolTerminal.instance) {
-                    this._sessionTerminalAssociations.delete(sessionId);
+                    this._sessionTerminalAssociations.delete(sessionResource);
                 }
             }
         }));
         this._register(this._chatService.onDidDisposeSession(e => {
             for (const resource of e.sessionResource) {
-                const localSessionId = LocalChatSessionUri.parseLocalSessionId(resource);
-                if (localSessionId) {
-                    this._cleanupSessionTerminals(localSessionId);
-                }
+                this._cleanupSessionTerminals(resource);
             }
         }));
     }
     async prepareToolInvocation(context, token) {
         const args = context.parameters;
-        const instance = context.chatSessionId ? this._sessionTerminalAssociations.get(context.chatSessionId)?.instance : undefined;
-        const [os, shell, cwd] = await Promise.all([
-            this._osBackend,
-            this._profileFetcher.getCopilotShell(),
-            (async () => {
-                let cwd = await instance?.getCwdResource();
-                if (!cwd) {
-                    const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot();
-                    const workspaceFolder = activeWorkspaceRootUri ? this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
-                    cwd = workspaceFolder?.uri;
-                }
-                return cwd;
-            })()
-        ]);
-        const language = os === OperatingSystem.Windows ? 'pwsh' : 'sh';
+        const chatSessionResource = context.chatSessionResource ?? (context.chatSessionId ? LocalChatSessionUri.forSession(context.chatSessionId) : undefined);
+        let instance;
+        if (chatSessionResource) {
+            const toolTerminal = this._sessionTerminalAssociations.get(chatSessionResource);
+            if (toolTerminal && !toolTerminal.isBackground) {
+                instance = toolTerminal.instance;
+            }
+        }
+        const [os, shell, cwd] = await Promise.all([this._osBackend, this._profileFetcher.getCopilotShell(), (async () => {
+            let cwd = await instance?.getCwdResource();
+            if (!cwd) {
+                const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot();
+                const workspaceFolder = activeWorkspaceRootUri ? this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
+                cwd = workspaceFolder?.uri;
+            }
+            return cwd;
+        })()]);
+        const language = os === OperatingSystem.Windows ? "pwsh" : "sh";
         const terminalToolSessionId = generateUuid();
         const terminalCommandId = `tool-${generateUuid()}`;
         let rewrittenCommand = args.command;
+        let forDisplayCommand = undefined;
         for (const rewriter of this._commandLineRewriters) {
             const rewriteResult = await rewriter.rewrite({
                 commandLine: rewrittenCommand,
@@ -314,18 +381,24 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             });
             if (rewriteResult) {
                 rewrittenCommand = rewriteResult.rewritten;
-                this._logService.info(`RunInTerminalTool: Command rewritten by ${rewriter.constructor.name}: ${rewriteResult.reasoning}`);
+                forDisplayCommand = rewriteResult.forDisplay;
+                this._logService.info(
+                    `RunInTerminalTool: Command rewritten by ${rewriter.constructor.name}: ${rewriteResult.reasoning}`
+                );
             }
         }
         const toolSpecificData = {
-            kind: 'terminal',
+            kind: "terminal",
             terminalToolSessionId,
             terminalCommandId,
             commandLine: {
                 original: args.command,
-                toolEdited: rewrittenCommand === args.command ? undefined : rewrittenCommand
+                toolEdited: rewrittenCommand === args.command ? undefined : rewrittenCommand,
+                forDisplay: forDisplayCommand
             },
+            cwd,
             language,
+            isBackground: args.isBackground
         };
         const alternativeRecommendation = getRecommendedToolsOverRunInTerminal(args.command, this._languageModelToolsService);
         if (alternativeRecommendation) {
@@ -333,13 +406,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             return {
                 confirmationMessages: undefined,
                 presentation: ToolInvocationPresentation.Hidden,
-                toolSpecificData,
+                toolSpecificData
             };
         }
         const commandLine = rewrittenCommand ?? args.command;
         const isEligibleForAutoApproval = () => {
             const config = this._configurationService.getValue(ChatConfiguration.EligibleForAutoApproval);
-            if (config && typeof config === 'object') {
+            if (config && typeof config === "object") {
                 if (Object.prototype.hasOwnProperty.call(config, TOOL_REFERENCE_NAME)) {
                     return config[TOOL_REFERENCE_NAME];
                 }
@@ -352,7 +425,11 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             return true;
         };
         const isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
-        const isAutoApproveWarningAccepted = this._storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
+        const isAutoApproveWarningAccepted = this._storageService.getBoolean(
+            TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted,
+            StorageScope.APPLICATION,
+            false
+        );
         const isAutoApproveAllowed = isEligibleForAutoApproval() && isAutoApproveEnabled && isAutoApproveWarningAccepted;
         const commandLineAnalyzerOptions = {
             commandLine,
@@ -361,90 +438,175 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             shell,
             treeSitterLanguage: isPowerShell(shell, os) ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
             terminalToolSessionId,
-            chatSessionId: context.chatSessionId,
+            chatSessionResource
         };
         const commandLineAnalyzerResults = await Promise.all(( this._commandLineAnalyzers.map(e => e.analyze(commandLineAnalyzerOptions))));
         const disclaimersRaw = ( commandLineAnalyzerResults.map(e => e.disclaimers)).filter(e => !!e).flatMap(e => e);
         let disclaimer;
         if (disclaimersRaw.length > 0) {
-            const disclaimerTexts = ( disclaimersRaw.map(d => typeof d === 'string' ? d : d.value));
-            const hasMarkdownDisclaimer = ( disclaimersRaw.some(d => typeof d !== 'string'));
-            const mdOptions = hasMarkdownDisclaimer
-                ? { supportThemeIcons: true, isTrusted: { enabledCommands: [TerminalChatCommandId.OpenTerminalSettingsLink] } }
-                : { supportThemeIcons: true };
-            disclaimer = ( new MarkdownString(`$(${Codicon.info.id}) ` + disclaimerTexts.join(' '), mdOptions));
+            const disclaimerTexts = ( disclaimersRaw.map(d => typeof d === "string" ? d : d.value));
+            const hasMarkdownDisclaimer = ( disclaimersRaw.some(d => typeof d !== "string"));
+            const mdOptions = hasMarkdownDisclaimer ? {
+                supportThemeIcons: true,
+                isTrusted: {
+                    enabledCommands: [TerminalChatCommandId.OpenTerminalSettingsLink]
+                }
+            } : {
+                supportThemeIcons: true
+            };
+            disclaimer = ( new MarkdownString(`$(${Codicon.info.id}) ` + disclaimerTexts.join(" "), mdOptions));
         }
         const analyzersIsAutoApproveAllowed = commandLineAnalyzerResults.every(e => e.isAutoApproveAllowed);
         const customActions = isEligibleForAutoApproval() && analyzersIsAutoApproveAllowed ? ( commandLineAnalyzerResults.map(e => e.customActions ?? [])).flat() : undefined;
-        let shellType = basename(shell, '.exe');
-        if (shellType === 'powershell') {
-            shellType = 'pwsh';
+        let shellType = basename(shell, ".exe");
+        if (shellType === "powershell") {
+            shellType = "pwsh";
         }
-        const wouldBeAutoApproved = (
+        const wouldBeAutoApproved =
         (( commandLineAnalyzerResults.some(e => e.isAutoApproved)) &&
-            commandLineAnalyzerResults.every(e => e.isAutoApproved !== false) &&
-        analyzersIsAutoApproveAllowed));
-        const isFinalAutoApproved = (
+        commandLineAnalyzerResults.every(e => e.isAutoApproved !== false) &&
+        analyzersIsAutoApproveAllowed);
+        const isFinalAutoApproved =
         (isAutoApproveAllowed &&
-        wouldBeAutoApproved));
+        wouldBeAutoApproved) || ( commandLineAnalyzerResults.some(e => e.forceAutoApproval));
         if (isFinalAutoApproved || (isAutoApproveEnabled && ( commandLineAnalyzerResults.some(e => e.autoApproveInfo)))) {
             toolSpecificData.autoApproveInfo = commandLineAnalyzerResults.find(e => e.autoApproveInfo)?.autoApproveInfo;
         }
+        const commandToDisplay = (toolSpecificData.commandLine.userEdited ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original).trimStart();
+        const extractedCd = extractCdPrefix(commandToDisplay, shell, os);
+        let confirmationTitle;
+        if (extractedCd && cwd) {
+            const isAbsolutePath = os === OperatingSystem.Windows ? win32.isAbsolute(extractedCd.directory) : posix.isAbsolute(extractedCd.directory);
+            const directoryUri = isAbsolutePath ? ( URI.from({
+                scheme: cwd.scheme,
+                authority: cwd.authority,
+                path: extractedCd.directory
+            })) : URI.joinPath(cwd, extractedCd.directory);
+            const directoryLabel = this._labelService.getUriLabel(directoryUri);
+            const cdPrefix = commandToDisplay.substring(0, commandToDisplay.length - extractedCd.command.length);
+            toolSpecificData.confirmation = {
+                commandLine: extractedCd.command,
+                cwdLabel: directoryLabel,
+                cdPrefix
+            };
+            confirmationTitle = args.isBackground ? ( localize(
+                12395,
+                "Run `{0}` command in background within `{1}`?",
+                shellType,
+                directoryLabel
+            )) : ( localize(12396, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
+        } else {
+            toolSpecificData.confirmation = {
+                commandLine: commandToDisplay
+            };
+            confirmationTitle = args.isBackground ? ( localize(12397, "Run `{0}` command in background?", shellType)) : ( localize(12398, "Run `{0}` command?", shellType));
+        }
+        const commandForPresenter = extractedCd?.command ?? commandToDisplay;
+        let presenterInput = commandForPresenter;
+        for (const presenter of this._commandLinePresenters) {
+            const presenterResult = await presenter.present({
+                commandLine: {
+                    original: args.command,
+                    forDisplay: presenterInput
+                },
+                shell,
+                os
+            });
+            if (presenterResult) {
+                toolSpecificData.presentationOverrides = {
+                    commandLine: presenterResult.commandLine,
+                    language: presenterResult.language ?? undefined
+                };
+                if (extractedCd && toolSpecificData.confirmation?.cwdLabel) {
+                    confirmationTitle = args.isBackground ? ( localize(
+                        12399,
+                        "Run `{0}` command in `{1}` in background within `{2}`?",
+                        presenterResult.languageDisplayName,
+                        shellType,
+                        toolSpecificData.confirmation.cwdLabel
+                    )) : ( localize(
+                        12400,
+                        "Run `{0}` command in `{1}` within `{2}`?",
+                        presenterResult.languageDisplayName,
+                        shellType,
+                        toolSpecificData.confirmation.cwdLabel
+                    ));
+                } else {
+                    confirmationTitle = args.isBackground ? ( localize(
+                        12401,
+                        "Run `{0}` command in `{1}` in background?",
+                        presenterResult.languageDisplayName,
+                        shellType
+                    )) : ( localize(
+                        12402,
+                        "Run `{0}` command in `{1}`?",
+                        presenterResult.languageDisplayName,
+                        shellType
+                    ));
+                }
+                if (!presenterResult.processOtherPresenters) {
+                    break;
+                }
+                presenterInput = presenterResult.commandLine;
+            }
+        }
         const confirmationMessages = isFinalAutoApproved ? undefined : {
-            title: args.isBackground
-                ? ( localize(12061, "Run `{0}` command? (background terminal)", shellType))
-                : ( localize(12062, "Run `{0}` command?", shellType)),
-            message: ( new MarkdownString(args.explanation)),
+            title: confirmationTitle,
+            message: ( new MarkdownString(( localize(12403, "Explanation: {0}\n\nGoal: {1}", args.explanation, args.goal)))),
             disclaimer,
-            terminalCustomActions: customActions,
+            terminalCustomActions: customActions
         };
         return {
             confirmationMessages,
-            toolSpecificData,
+            toolSpecificData
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
         const toolSpecificData = invocation.toolSpecificData;
         if (!toolSpecificData) {
-            throw ( new Error('toolSpecificData must be provided for this tool'));
+            throw ( new Error("toolSpecificData must be provided for this tool"));
         }
         const commandId = toolSpecificData.terminalCommandId;
         if (toolSpecificData.alternativeRecommendation) {
             return {
                 content: [{
-                        kind: 'text',
-                        value: toolSpecificData.alternativeRecommendation
-                    }]
+                    kind: "text",
+                    value: toolSpecificData.alternativeRecommendation
+                }]
             };
         }
         const args = invocation.parameters;
         this._logService.debug(`RunInTerminalTool: Invoking with options ${JSON.stringify(args)}`);
         let toolResultMessage;
-        const chatSessionId = invocation.context?.sessionId ?? 'no-chat-session';
+        const chatSessionResource = invocation.context?.sessionResource ?? LocalChatSessionUri.forSession(invocation.context?.sessionId ?? "no-chat-session");
+        const chatSessionId = chatSessionResourceToId(chatSessionResource);
         const command = toolSpecificData.commandLine.userEdited ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original;
-        const didUserEditCommand = (toolSpecificData.commandLine.userEdited !== undefined &&
-            toolSpecificData.commandLine.userEdited !== toolSpecificData.commandLine.original);
-        const didToolEditCommand = (!didUserEditCommand &&
-            toolSpecificData.commandLine.toolEdited !== undefined &&
-            toolSpecificData.commandLine.toolEdited !== toolSpecificData.commandLine.original);
+        const didUserEditCommand = (toolSpecificData.commandLine.userEdited !== undefined && toolSpecificData.commandLine.userEdited !== toolSpecificData.commandLine.original);
+        const didToolEditCommand = (!didUserEditCommand && toolSpecificData.commandLine.toolEdited !== undefined && toolSpecificData.commandLine.toolEdited !== toolSpecificData.commandLine.original);
         if (token.isCancellationRequested) {
             throw ( new CancellationError());
         }
         let error;
-        const isNewSession = !args.isBackground && !( this._sessionTerminalAssociations.has(chatSessionId));
+        const isNewSession = !args.isBackground && !( this._sessionTerminalAssociations.has(chatSessionResource));
         const timingStart = Date.now();
         const termId = generateUuid();
         const terminalToolSessionId = toolSpecificData.terminalToolSessionId;
         const store = ( new DisposableStore());
-        this._logService.debug(`RunInTerminalTool: Creating ${args.isBackground ? 'background' : 'foreground'} terminal. termId=${termId}, chatSessionId=${chatSessionId}`);
-        const toolTerminal = await (args.isBackground
-            ? this._initBackgroundTerminal(chatSessionId, termId, terminalToolSessionId, token)
-            : this._initForegroundTerminal(chatSessionId, termId, terminalToolSessionId, token));
-        this._handleTerminalVisibility(toolTerminal, chatSessionId);
+        this._logService.debug(
+            `RunInTerminalTool: Creating ${args.isBackground ? "background" : "foreground"} terminal. termId=${termId}, chatSessionId=${chatSessionId}`
+        );
+        const toolTerminal = await this._initTerminal(
+            chatSessionResource,
+            termId,
+            terminalToolSessionId,
+            args.isBackground,
+            token
+        );
+        this._handleTerminalVisibility(toolTerminal, chatSessionResource);
         const timingConnectMs = Date.now() - timingStart;
         const xterm = await toolTerminal.instance.xtermReadyPromise;
         if (!xterm) {
-            throw ( new Error('Instance was disposed before xterm.js was ready'));
+            throw ( new Error("Instance was disposed before xterm.js was ready"));
         }
         const commandDetection = toolTerminal.instance.capabilities.get(TerminalCapability.CommandDetection);
         let inputUserChars = 0;
@@ -453,34 +615,94 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             if (!telemetryIgnoredSequences.includes(data)) {
                 inputUserChars += data.length;
             }
-            inputUserSigint ||= data === '\x03';
+            inputUserSigint ||= data === "\u0003";
         }));
+        let terminalResult = "";
+        let outputLineCount = -1;
+        let exitCode;
+        let altBufferResult;
+        let didTimeout = false;
+        let didMoveToBackground = args.isBackground;
+        let timeoutPromise;
         let outputMonitor;
-        if (args.isBackground) {
-            let pollingResult;
-            try {
+        let pollingResult;
+        const executeCancellation = store.add(( new CancellationTokenSource(token)));
+        const timeoutValue = args.timeout !== undefined ? clamp(args.timeout, 0, Number.MAX_SAFE_INTEGER) : undefined;
+        if (!args.isBackground && timeoutValue !== undefined && timeoutValue > 0) {
+            const shouldEnforceTimeout = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnforceTimeoutFromModel) === true;
+            if (shouldEnforceTimeout) {
+                timeoutPromise = timeout(timeoutValue);
+                timeoutPromise.then(() => {
+                    if (!executeCancellation.token.isCancellationRequested) {
+                        didTimeout = true;
+                        executeCancellation.cancel();
+                    }
+                });
+            }
+        }
+        let continueInBackgroundResolve;
+        const continueInBackgroundPromise = ( new Promise(resolve => {
+            continueInBackgroundResolve = resolve;
+        }));
+        if (terminalToolSessionId) {
+            store.add(this._terminalChatService.onDidContinueInBackground(sessionId => {
+                if (sessionId === terminalToolSessionId) {
+                    const execution = RunInTerminalTool_1._activeExecutions.get(termId);
+                    if (execution) {
+                        execution.setBackground();
+                    }
+                    didMoveToBackground = true;
+                    continueInBackgroundResolve?.();
+                }
+            }));
+        }
+        let executionPromise;
+        try {
+            const execution = this._instantiationService.createInstance(
+                ActiveTerminalExecution,
+                chatSessionId,
+                termId,
+                toolTerminal,
+                commandDetection,
+                args.isBackground
+            );
+            if (toolTerminal.shellIntegrationQuality === ShellIntegrationQuality.None) {
+                toolResultMessage = "$(info) Enable [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) to improve command detection";
+            }
+            this._logService.debug(
+                `RunInTerminalTool: Using \`${execution.strategy.type}\` execute strategy for command \`${command}\``
+            );
+            store.add(execution);
+            RunInTerminalTool_1._activeExecutions.set(termId, execution);
+            const startMarkerPromise = Event.toPromise(execution.strategy.onDidCreateStartMarker);
+            store.add(execution.strategy.onDidCreateStartMarker(startMarker => {
+                if (!outputMonitor) {
+                    outputMonitor = store.add(this._instantiationService.createInstance(OutputMonitor, {
+                        instance: toolTerminal.instance,
+                        sessionId: invocation.context?.sessionId,
+                        getOutput: marker => execution.getOutput(marker ?? startMarker)
+                    }, undefined, invocation.context, token, command));
+                }
+            }));
+            executionPromise = execution.start(command, executeCancellation.token, commandId);
+            if (args.isBackground) {
                 this._logService.debug(`RunInTerminalTool: Starting background execution \`${command}\``);
-                const execution = ( new BackgroundTerminalExecution(toolTerminal.instance, xterm, command, chatSessionId, commandId));
-                RunInTerminalTool_1._backgroundExecutions.set(termId, execution);
-                outputMonitor = store.add(this._instantiationService.createInstance(OutputMonitor, execution, undefined, invocation.context, token, command));
-                await Event.toPromise(outputMonitor.onDidFinishCommand);
-                const pollingResult = outputMonitor.pollingResult;
+                await startMarkerPromise;
+                if (outputMonitor) {
+                    await Event.toPromise(outputMonitor.onDidFinishCommand);
+                    pollingResult = outputMonitor.pollingResult;
+                }
+                await this._commandArtifactCollector.capture(toolSpecificData, toolTerminal.instance, commandId);
                 if (token.isCancellationRequested) {
                     throw ( new CancellationError());
                 }
-                await this._commandArtifactCollector.capture(toolSpecificData, toolTerminal.instance, commandId);
                 const state = toolSpecificData.terminalCommandState ?? {};
                 state.timestamp = state.timestamp ?? timingStart;
                 toolSpecificData.terminalCommandState = state;
-                let resultText = (didUserEditCommand
-                    ? `Note: The user manually edited the command to \`${command}\`, and that command is now running in terminal with ID=${termId}`
-                    : didToolEditCommand
-                        ? `Note: The tool simplified the command to \`${command}\`, and that command is now running in terminal with ID=${termId}`
-                        : `Command is running in terminal with ID=${termId}`);
+                let resultText = (didUserEditCommand ? `Note: The user manually edited the command to \`${command}\`, and that command is now running in terminal with ID=${termId}` : didToolEditCommand ? `Note: The tool simplified the command to \`${command}\`, and that command is now running in terminal with ID=${termId}` : `Command is running in terminal with ID=${termId}`);
                 if (pollingResult && pollingResult.modelOutputEvalResponse) {
                     resultText += `\n\ The command became idle with output:\n${pollingResult.modelOutputEvalResponse}`;
-                }
-                else if (pollingResult) {
+                } else if (pollingResult) {
                     resultText += `\n\ The command is still running, with output:\n${pollingResult.output}`;
                 }
                 return {
@@ -488,230 +710,211 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                         exitCode: undefined
                     },
                     content: [{
-                            kind: 'text',
-                            value: resultText,
-                        }],
+                        kind: "text",
+                        value: resultText
+                    }]
                 };
-            }
-            catch (e) {
-                if (termId) {
-                    RunInTerminalTool_1._backgroundExecutions.get(termId)?.dispose();
-                    RunInTerminalTool_1._backgroundExecutions.delete(termId);
-                }
-                error = e instanceof CancellationError ? 'canceled' : 'unexpectedException';
-                throw e;
-            }
-            finally {
-                store.dispose();
-                this._logService.debug(`RunInTerminalTool: Finished polling \`${pollingResult?.output.length}\` lines of output in \`${pollingResult?.pollDurationMs}\``);
-                const timingExecuteMs = Date.now() - timingStart;
-                this._telemetry.logInvoke(toolTerminal.instance, {
-                    terminalToolSessionId: toolSpecificData.terminalToolSessionId,
-                    didUserEditCommand,
-                    didToolEditCommand,
-                    shellIntegrationQuality: toolTerminal.shellIntegrationQuality,
-                    isBackground: true,
-                    error,
-                    exitCode: undefined,
-                    isNewSession: true,
-                    timingExecuteMs,
-                    timingConnectMs,
-                    terminalExecutionIdleBeforeTimeout: pollingResult?.state === OutputMonitorState.Idle,
-                    outputLineCount: 0,
-                    pollDurationMs: pollingResult?.pollDurationMs,
-                    inputUserChars,
-                    inputUserSigint,
-                    inputToolManualAcceptCount: outputMonitor?.outputMonitorTelemetryCounters.inputToolManualAcceptCount,
-                    inputToolManualRejectCount: outputMonitor?.outputMonitorTelemetryCounters.inputToolManualRejectCount,
-                    inputToolManualChars: outputMonitor?.outputMonitorTelemetryCounters.inputToolManualChars,
-                    inputToolAutoAcceptCount: outputMonitor?.outputMonitorTelemetryCounters.inputToolAutoAcceptCount,
-                    inputToolAutoChars: outputMonitor?.outputMonitorTelemetryCounters.inputToolAutoChars,
-                    inputToolManualShownCount: outputMonitor?.outputMonitorTelemetryCounters.inputToolManualShownCount,
-                    inputToolFreeFormInputCount: outputMonitor?.outputMonitorTelemetryCounters.inputToolFreeFormInputCount,
-                    inputToolFreeFormInputShownCount: outputMonitor?.outputMonitorTelemetryCounters.inputToolFreeFormInputShownCount
-                });
-            }
-        }
-        else {
-            let terminalResult = '';
-            let outputLineCount = -1;
-            let exitCode;
-            let altBufferResult;
-            const executeCancellation = store.add(( new CancellationTokenSource(token)));
-            try {
-                let strategy;
-                switch (toolTerminal.shellIntegrationQuality) {
-                    case ShellIntegrationQuality.None: {
-                        strategy = this._instantiationService.createInstance(NoneExecuteStrategy, toolTerminal.instance, () => toolTerminal.receivedUserInput ?? false);
-                        toolResultMessage = '$(info) Enable [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) to improve command detection';
-                        break;
-                    }
-                    case ShellIntegrationQuality.Basic: {
-                        strategy = this._instantiationService.createInstance(BasicExecuteStrategy, toolTerminal.instance, () => toolTerminal.receivedUserInput ?? false, commandDetection);
-                        break;
+            } else {
+                const raceResult = await Promise.race([executionPromise.then(result => ({
+                    type: "completed",
+                    result
+                })), continueInBackgroundPromise.then(() => ({
+                    type: "background"
+                }))]);
+                if (raceResult.type === "background") {
+                    this._logService.debug(
+                        `RunInTerminalTool: Continue in background triggered, returning output collected so far`
+                    );
+                    error = "continueInBackground";
+                    const backgroundOutput = execution.getOutput();
+                    outputLineCount = backgroundOutput ? count(backgroundOutput.trim(), "\n") + 1 : 0;
+                    terminalResult = backgroundOutput;
+                } else {
+                    const executeResult = raceResult.result;
+                    toolTerminal.receivedUserInput = false;
+                    if (token.isCancellationRequested) {
+                        throw ( new CancellationError());
                     }
-                    case ShellIntegrationQuality.Rich: {
-                        strategy = this._instantiationService.createInstance(RichExecuteStrategy, toolTerminal.instance, commandDetection);
-                        break;
-                    }
-                }
-                this._logService.debug(`RunInTerminalTool: Using \`${strategy.type}\` execute strategy for command \`${command}\``);
-                store.add(strategy.onDidCreateStartMarker(startMarker => {
-                    if (!outputMonitor) {
-                        outputMonitor = store.add(this._instantiationService.createInstance(OutputMonitor, { instance: toolTerminal.instance, sessionId: invocation.context?.sessionId, getOutput: (marker) => getOutput(toolTerminal.instance, marker ?? startMarker) }, undefined, invocation.context, token, command));
-                    }
-                }));
-                const executeResult = await strategy.execute(command, executeCancellation.token, commandId);
-                toolTerminal.receivedUserInput = false;
-                if (token.isCancellationRequested) {
-                    throw ( new CancellationError());
-                }
-                if (executeResult.didEnterAltBuffer) {
-                    const state = toolSpecificData.terminalCommandState ?? {};
-                    state.timestamp = state.timestamp ?? timingStart;
-                    toolSpecificData.terminalCommandState = state;
-                    toolResultMessage = altBufferMessage;
-                    outputLineCount = 0;
-                    error = executeResult.error ?? 'alternateBuffer';
-                    altBufferResult = {
-                        toolResultMessage,
-                        toolMetadata: {
-                            exitCode: undefined
-                        },
-                        content: [{
-                                kind: 'text',
-                                value: altBufferMessage,
-                            }]
-                    };
-                }
-                else {
-                    await this._commandArtifactCollector.capture(toolSpecificData, toolTerminal.instance, commandId);
-                    {
+                    if (executeResult.didEnterAltBuffer) {
                         const state = toolSpecificData.terminalCommandState ?? {};
                         state.timestamp = state.timestamp ?? timingStart;
-                        if (executeResult.exitCode !== undefined) {
-                            state.exitCode = executeResult.exitCode;
-                            if (state.timestamp !== undefined) {
-                                state.duration = state.duration ?? Math.max(0, Date.now() - state.timestamp);
+                        toolSpecificData.terminalCommandState = state;
+                        toolResultMessage = altBufferMessage;
+                        outputLineCount = 0;
+                        error = executeResult.error ?? "alternateBuffer";
+                        altBufferResult = {
+                            toolResultMessage,
+                            toolMetadata: {
+                                exitCode: undefined
+                            },
+                            content: [{
+                                kind: "text",
+                                value: altBufferMessage
+                            }]
+                        };
+                    } else {
+                        await this._commandArtifactCollector.capture(toolSpecificData, toolTerminal.instance, commandId);
+                        {
+                            const state = toolSpecificData.terminalCommandState ?? {};
+                            state.timestamp = state.timestamp ?? timingStart;
+                            if (executeResult.exitCode !== undefined) {
+                                state.exitCode = executeResult.exitCode;
+                                if (state.timestamp !== undefined) {
+                                    state.duration = state.duration ?? Math.max(0, Date.now() - state.timestamp);
+                                }
                             }
+                            toolSpecificData.terminalCommandState = state;
                         }
-                        toolSpecificData.terminalCommandState = state;
-                    }
-                    this._logService.debug(`RunInTerminalTool: Finished \`${strategy.type}\` execute strategy with exitCode \`${executeResult.exitCode}\`, result.length \`${executeResult.output?.length}\`, error \`${executeResult.error}\``);
-                    outputLineCount = executeResult.output === undefined ? 0 : count(executeResult.output.trim(), '\n') + 1;
-                    exitCode = executeResult.exitCode;
-                    error = executeResult.error;
-                    const resultArr = [];
-                    if (executeResult.output !== undefined) {
-                        resultArr.push(executeResult.output);
-                    }
-                    if (executeResult.additionalInformation) {
-                        resultArr.push(executeResult.additionalInformation);
+                        this._logService.debug(
+                            `RunInTerminalTool: Finished \`${execution.strategy.type}\` execute strategy with exitCode \`${executeResult.exitCode}\`, result.length \`${executeResult.output?.length}\`, error \`${executeResult.error}\``
+                        );
+                        outputLineCount = executeResult.output === undefined ? 0 : count(executeResult.output.trim(), "\n") + 1;
+                        exitCode = executeResult.exitCode;
+                        error = executeResult.error;
+                        const resultArr = [];
+                        if (executeResult.output !== undefined) {
+                            resultArr.push(executeResult.output);
+                        }
+                        if (executeResult.additionalInformation) {
+                            resultArr.push(executeResult.additionalInformation);
+                        }
+                        terminalResult = resultArr.join("\n\n");
                     }
-                    terminalResult = resultArr.join('\n\n');
                 }
             }
-            catch (e) {
+        } catch (e) {
+            if (didTimeout && e instanceof CancellationError) {
+                this._logService.debug(`RunInTerminalTool: Timeout reached, returning output collected so far`);
+                error = "timeout";
+                const timeoutOutput = getOutput(toolTerminal.instance, undefined);
+                outputLineCount = timeoutOutput ? count(timeoutOutput.trim(), "\n") + 1 : 0;
+                terminalResult = timeoutOutput ?? "";
+            } else {
                 this._logService.debug(`RunInTerminalTool: Threw exception`);
+                if (e instanceof CancellationError) {
+                    await this._commandArtifactCollector.capture(toolSpecificData, toolTerminal.instance, commandId);
+                }
+                RunInTerminalTool_1._activeExecutions.get(termId)?.dispose();
+                RunInTerminalTool_1._activeExecutions.delete(termId);
                 toolTerminal.instance.dispose();
-                error = e instanceof CancellationError ? 'canceled' : 'unexpectedException';
+                error = e instanceof CancellationError ? "canceled" : "unexpectedException";
                 throw e;
             }
-            finally {
-                store.dispose();
-                const timingExecuteMs = Date.now() - timingStart;
-                this._telemetry.logInvoke(toolTerminal.instance, {
-                    terminalToolSessionId: toolSpecificData.terminalToolSessionId,
-                    didUserEditCommand,
-                    didToolEditCommand,
-                    isBackground: false,
-                    shellIntegrationQuality: toolTerminal.shellIntegrationQuality,
-                    error,
-                    isNewSession,
-                    outputLineCount,
-                    exitCode,
-                    timingExecuteMs,
-                    timingConnectMs,
-                    inputUserChars,
-                    inputUserSigint,
-                    terminalExecutionIdleBeforeTimeout: undefined,
-                    pollDurationMs: undefined,
-                    inputToolManualAcceptCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualAcceptCount,
-                    inputToolManualRejectCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualRejectCount,
-                    inputToolManualChars: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualChars,
-                    inputToolAutoAcceptCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolAutoAcceptCount,
-                    inputToolAutoChars: outputMonitor?.outputMonitorTelemetryCounters?.inputToolAutoChars,
-                    inputToolManualShownCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualShownCount,
-                    inputToolFreeFormInputCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolFreeFormInputCount,
-                    inputToolFreeFormInputShownCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolFreeFormInputShownCount
+        } finally {
+            timeoutPromise?.cancel();
+            if (didMoveToBackground && executionPromise) {
+                executionPromise.catch(e => {
+                    if (!(e instanceof CancellationError)) {
+                        this._logService.error(`RunInTerminalTool: Background execution error`, e);
+                    }
                 });
+            } else {
+                RunInTerminalTool_1._activeExecutions.get(termId)?.dispose();
+                RunInTerminalTool_1._activeExecutions.delete(termId);
             }
-            if (altBufferResult) {
-                return altBufferResult;
-            }
-            const resultText = [];
-            if (didUserEditCommand) {
-                resultText.push(`Note: The user manually edited the command to \`${command}\`, and this is the output of running that command instead:\n`);
-            }
-            else if (didToolEditCommand) {
-                resultText.push(`Note: The tool simplified the command to \`${command}\`, and this is the output of running that command instead:\n`);
-            }
-            resultText.push(terminalResult);
-            return {
-                toolResultMessage,
-                toolMetadata: {
-                    exitCode: exitCode
-                },
-                content: [{
-                        kind: 'text',
-                        value: resultText.join(''),
-                    }]
-            };
+            store.dispose();
+            const timingExecuteMs = Date.now() - timingStart;
+            this._telemetry.logInvoke(toolTerminal.instance, {
+                terminalToolSessionId: toolSpecificData.terminalToolSessionId,
+                didUserEditCommand,
+                didToolEditCommand,
+                isBackground: args.isBackground,
+                shellIntegrationQuality: toolTerminal.shellIntegrationQuality,
+                error,
+                isNewSession,
+                outputLineCount,
+                exitCode,
+                timingExecuteMs,
+                timingConnectMs,
+                inputUserChars,
+                inputUserSigint,
+                terminalExecutionIdleBeforeTimeout: pollingResult?.state === OutputMonitorState.Idle,
+                pollDurationMs: pollingResult?.pollDurationMs,
+                inputToolManualAcceptCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualAcceptCount,
+                inputToolManualRejectCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualRejectCount,
+                inputToolManualChars: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualChars,
+                inputToolAutoAcceptCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolAutoAcceptCount,
+                inputToolAutoChars: outputMonitor?.outputMonitorTelemetryCounters?.inputToolAutoChars,
+                inputToolManualShownCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolManualShownCount,
+                inputToolFreeFormInputCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolFreeFormInputCount,
+                inputToolFreeFormInputShownCount: outputMonitor?.outputMonitorTelemetryCounters?.inputToolFreeFormInputShownCount
+            });
+        }
+        if (altBufferResult) {
+            return altBufferResult;
+        }
+        const resultText = [];
+        if (didUserEditCommand) {
+            resultText.push(
+                `Note: The user manually edited the command to \`${command}\`, and this is the output of running that command instead:\n`
+            );
+        } else if (didToolEditCommand) {
+            resultText.push(
+                `Note: The tool simplified the command to \`${command}\`, and this is the output of running that command instead:\n`
+            );
+        }
+        if (didMoveToBackground && !args.isBackground) {
+            resultText.push(
+                `Note: This terminal execution was moved to the background using the ID ${termId}\n`
+            );
         }
+        resultText.push(terminalResult);
+        const isError = exitCode !== undefined && exitCode !== 0;
+        return {
+            toolResultMessage,
+            toolMetadata: {
+                exitCode: exitCode
+            },
+            toolResultDetails: isError ? {
+                input: command,
+                output: [{
+                    type: "embed",
+                    isText: true,
+                    value: terminalResult
+                }],
+                isError: true
+            } : undefined,
+            content: [{
+                kind: "text",
+                value: resultText.join("")
+            }]
+        };
     }
-    _handleTerminalVisibility(toolTerminal, chatSessionId) {
-        const chatSessionOpenInWidget = !!this._chatWidgetService.getWidgetBySessionResource(LocalChatSessionUri.forSession(chatSessionId));
-        if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.OutputLocation) === 'terminal' && chatSessionOpenInWidget) {
+    _handleTerminalVisibility(toolTerminal, chatSessionResource) {
+        const chatSessionOpenInWidget = !!this._chatWidgetService.getWidgetBySessionResource(chatSessionResource);
+        if (this._configurationService.getValue(TerminalChatAgentToolsSettingId.OutputLocation) === "terminal" && chatSessionOpenInWidget) {
             this._terminalService.setActiveInstance(toolTerminal.instance);
             this._terminalService.revealTerminal(toolTerminal.instance, true);
         }
     }
-    async _initBackgroundTerminal(chatSessionId, termId, terminalToolSessionId, token) {
-        this._logService.debug(`RunInTerminalTool: Creating background terminal with ID=${termId}`);
-        const profile = await this._profileFetcher.getCopilotProfile();
-        const os = await this._osBackend;
-        const toolTerminal = await this._terminalToolCreator.createTerminal(profile, os, token);
-        this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, toolTerminal.instance);
-        this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionId, toolTerminal.instance);
-        this._registerInputListener(toolTerminal);
-        this._sessionTerminalAssociations.set(chatSessionId, toolTerminal);
-        if (token.isCancellationRequested) {
-            toolTerminal.instance.dispose();
-            throw ( new CancellationError());
-        }
-        await this._setupProcessIdAssociation(toolTerminal, chatSessionId, termId, true);
-        return toolTerminal;
-    }
-    async _initForegroundTerminal(chatSessionId, termId, terminalToolSessionId, token) {
-        const cachedTerminal = this._sessionTerminalAssociations.get(chatSessionId);
-        if (cachedTerminal) {
-            this._logService.debug(`RunInTerminalTool: Using cached foreground terminal with session ID \`${chatSessionId}\``);
-            this._terminalToolCreator.refreshShellIntegrationQuality(cachedTerminal);
-            this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, cachedTerminal.instance);
-            return cachedTerminal;
+    async _initTerminal(chatSessionResource, termId, terminalToolSessionId, isBackground, token) {
+        if (!isBackground) {
+            const cachedTerminal = this._sessionTerminalAssociations.get(chatSessionResource);
+            if (cachedTerminal && !cachedTerminal.isBackground) {
+                this._logService.debug(
+                    `RunInTerminalTool: Using cached terminal with session resource \`${chatSessionResource}\``
+                );
+                this._terminalToolCreator.refreshShellIntegrationQuality(cachedTerminal);
+                this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, cachedTerminal.instance);
+                return cachedTerminal;
+            }
         }
+        this._logService.debug(
+            `RunInTerminalTool: Creating ${isBackground ? "background" : "foreground"} terminal with ID=${termId}`
+        );
         const profile = await this._profileFetcher.getCopilotProfile();
         const os = await this._osBackend;
         const toolTerminal = await this._terminalToolCreator.createTerminal(profile, os, token);
+        toolTerminal.isBackground = isBackground;
         this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, toolTerminal.instance);
-        this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionId, toolTerminal.instance);
+        this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionResource, toolTerminal.instance);
         this._registerInputListener(toolTerminal);
-        this._sessionTerminalAssociations.set(chatSessionId, toolTerminal);
+        this._sessionTerminalAssociations.set(chatSessionResource, toolTerminal);
         if (token.isCancellationRequested) {
             toolTerminal.instance.dispose();
             throw ( new CancellationError());
         }
-        await this._setupProcessIdAssociation(toolTerminal, chatSessionId, termId, false);
+        await this._setupProcessIdAssociation(toolTerminal, chatSessionResource, termId, isBackground);
         return toolTerminal;
     }
     _registerInputListener(toolTerminal) {
@@ -723,48 +926,68 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         this._register(toolTerminal.instance.onDisposed(() => disposable.dispose()));
     }
     _restoreTerminalAssociations() {
-        const storedAssociations = this._storageService.get(TerminalToolStorageKeysInternal.TerminalSession, StorageScope.WORKSPACE, '{}');
+        const storedAssociations = this._storageService.get(
+            TerminalToolStorageKeysInternal.TerminalSession,
+            StorageScope.WORKSPACE,
+            "{}"
+        );
         try {
             const associations = JSON.parse(storedAssociations);
             for (const instance of this._terminalService.instances) {
                 if (instance.processId) {
                     const association = associations[instance.processId];
                     if (association) {
-                        this._logService.debug(`RunInTerminalTool: Restored terminal association for PID ${instance.processId}, session ${association.sessionId}`);
+                        const chatSessionResource = LocalChatSessionUri.forSession(association.sessionId);
+                        this._logService.debug(
+                            `RunInTerminalTool: Restored terminal association for PID ${instance.processId}, session ${association.sessionId}`
+                        );
                         const toolTerminal = {
                             instance,
-                            shellIntegrationQuality: association.shellIntegrationQuality
+                            shellIntegrationQuality: association.shellIntegrationQuality,
+                            isBackground: association.isBackground
                         };
-                        this._sessionTerminalAssociations.set(association.sessionId, toolTerminal);
-                        this._terminalChatService.registerTerminalInstanceWithChatSession(association.sessionId, instance);
+                        this._sessionTerminalAssociations.set(chatSessionResource, toolTerminal);
+                        this._terminalChatService.registerTerminalInstanceWithChatSession(chatSessionResource, instance);
                         this._register(instance.onDisposed(() => {
                             this._removeProcessIdAssociation(instance.processId);
                         }));
                     }
                 }
             }
-        }
-        catch (error) {
+        } catch (error) {
             this._logService.debug(`RunInTerminalTool: Failed to restore terminal associations: ${error}`);
         }
     }
-    async _setupProcessIdAssociation(toolTerminal, chatSessionId, termId, isBackground) {
-        await this._associateProcessIdWithSession(toolTerminal.instance, chatSessionId, termId, toolTerminal.shellIntegrationQuality, isBackground);
+    async _setupProcessIdAssociation(toolTerminal, chatSessionResource, termId, isBackground) {
+        await this._associateProcessIdWithSession(
+            toolTerminal.instance,
+            chatSessionResource,
+            termId,
+            toolTerminal.shellIntegrationQuality,
+            isBackground
+        );
         this._register(toolTerminal.instance.onDisposed(() => {
             if (toolTerminal.instance.processId) {
                 this._removeProcessIdAssociation(toolTerminal.instance.processId);
             }
         }));
     }
-    async _associateProcessIdWithSession(terminal, sessionId, id, shellIntegrationQuality, isBackground) {
+    async _associateProcessIdWithSession(terminal, chatSessionResource, id, shellIntegrationQuality, isBackground) {
         try {
             const pid = await Promise.race([
                 terminal.processReady.then(() => terminal.processId),
-                timeout(5000).then(() => { throw ( new Error('Timeout')); })
+                timeout(5000).then(() => {
+                    throw ( new Error("Timeout"));
+                })
             ]);
             if (isNumber(pid)) {
-                const storedAssociations = this._storageService.get(TerminalToolStorageKeysInternal.TerminalSession, StorageScope.WORKSPACE, '{}');
+                const storedAssociations = this._storageService.get(
+                    TerminalToolStorageKeysInternal.TerminalSession,
+                    StorageScope.WORKSPACE,
+                    "{}"
+                );
                 const associations = JSON.parse(storedAssociations);
+                const sessionId = chatSessionResourceToId(chatSessionResource);
                 const existingAssociation = associations[pid] || {};
                 associations[pid] = {
                     ...existingAssociation,
@@ -773,77 +996,145 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     id,
                     isBackground
                 };
-                this._storageService.store(TerminalToolStorageKeysInternal.TerminalSession, JSON.stringify(associations), StorageScope.WORKSPACE, StorageTarget.USER);
-                this._logService.debug(`RunInTerminalTool: Associated terminal PID ${pid} with session ${sessionId}`);
+                this._storageService.store(
+                    TerminalToolStorageKeysInternal.TerminalSession,
+                    JSON.stringify(associations),
+                    StorageScope.WORKSPACE,
+                    StorageTarget.USER
+                );
+                this._logService.debug(
+                    `RunInTerminalTool: Associated terminal PID ${pid} with session ${sessionId}`
+                );
             }
-        }
-        catch (error) {
+        } catch (error) {
             this._logService.debug(`RunInTerminalTool: Failed to associate terminal with session: ${error}`);
         }
     }
     async _removeProcessIdAssociation(pid) {
         try {
-            const storedAssociations = this._storageService.get(TerminalToolStorageKeysInternal.TerminalSession, StorageScope.WORKSPACE, '{}');
+            const storedAssociations = this._storageService.get(
+                TerminalToolStorageKeysInternal.TerminalSession,
+                StorageScope.WORKSPACE,
+                "{}"
+            );
             const associations = JSON.parse(storedAssociations);
             if (associations[pid]) {
                 delete associations[pid];
-                this._storageService.store(TerminalToolStorageKeysInternal.TerminalSession, JSON.stringify(associations), StorageScope.WORKSPACE, StorageTarget.USER);
+                this._storageService.store(
+                    TerminalToolStorageKeysInternal.TerminalSession,
+                    JSON.stringify(associations),
+                    StorageScope.WORKSPACE,
+                    StorageTarget.USER
+                );
                 this._logService.debug(`RunInTerminalTool: Removed terminal association for PID ${pid}`);
             }
-        }
-        catch (error) {
+        } catch (error) {
             this._logService.debug(`RunInTerminalTool: Failed to remove terminal association: ${error}`);
         }
     }
-    _cleanupSessionTerminals(sessionId) {
-        const toolTerminal = this._sessionTerminalAssociations.get(sessionId);
+    _cleanupSessionTerminals(chatSessionResource) {
+        const toolTerminal = this._sessionTerminalAssociations.get(chatSessionResource);
         if (toolTerminal) {
-            this._logService.debug(`RunInTerminalTool: Cleaning up terminal for disposed chat session ${sessionId}`);
-            this._sessionTerminalAssociations.delete(sessionId);
+            this._logService.debug(
+                `RunInTerminalTool: Cleaning up terminal for disposed chat session ${chatSessionResource}`
+            );
+            this._sessionTerminalAssociations.delete(chatSessionResource);
             toolTerminal.instance.dispose();
             const terminalToRemove = [];
-            for (const [termId, execution] of RunInTerminalTool_1._backgroundExecutions.entries()) {
+            for (const [termId, execution] of RunInTerminalTool_1._activeExecutions.entries()) {
                 if (execution.instance === toolTerminal.instance) {
                     execution.dispose();
                     terminalToRemove.push(termId);
                 }
             }
             for (const termId of terminalToRemove) {
-                RunInTerminalTool_1._backgroundExecutions.delete(termId);
+                RunInTerminalTool_1._activeExecutions.delete(termId);
             }
         }
     }
 };
-RunInTerminalTool = RunInTerminalTool_1 = ( __decorate([
-    ( __param(0, IChatService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IHistoryService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ILanguageModelToolsService)),
-    ( __param(5, IRemoteAgentService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, ITerminalChatService)),
-    ( __param(8, ITerminalLogService)),
-    ( __param(9, ITerminalService)),
-    ( __param(10, IWorkspaceContextService)),
-    ( __param(11, IChatWidgetService))
-], RunInTerminalTool));
-class BackgroundTerminalExecution extends Disposable {
-    constructor(instance, _xterm, _commandLine, sessionId, commandId) {
+RunInTerminalTool = RunInTerminalTool_1 = ( __decorate([( __param(0, IChatService)), ( __param(1, IConfigurationService)), ( __param(2, IHistoryService)), ( __param(3, IInstantiationService)), ( __param(4, ILabelService)), ( __param(5, ILanguageModelToolsService)), ( __param(6, IRemoteAgentService)), ( __param(7, IStorageService)), ( __param(8, ITerminalChatService)), ( __param(9, ITerminalLogService)), ( __param(10, ITerminalService)), ( __param(11, IWorkspaceContextService)), ( __param(12, IChatWidgetService))], RunInTerminalTool));
+let ActiveTerminalExecution = class ActiveTerminalExecution extends Disposable {
+    get completionPromise() {
+        return this._completionDeferred.p;
+    }
+    get isBackground() {
+        return this._isBackground;
+    }
+    get startMarker() {
+        return this._startMarker;
+    }
+    get instance() {
+        return this._toolTerminal.instance;
+    }
+    constructor(
+        sessionId,
+        termId,
+        toolTerminal,
+        commandDetection,
+        isBackground,
+        _instantiationService
+    ) {
         super();
-        this.instance = instance;
-        this._xterm = _xterm;
-        this._commandLine = _commandLine;
         this.sessionId = sessionId;
-        this._startMarker = this._register(this._xterm.raw.registerMarker());
-        this.instance.runCommand(this._commandLine, true, commandId);
+        this.termId = termId;
+        this._instantiationService = _instantiationService;
+        this._toolTerminal = toolTerminal;
+        this._isBackground = isBackground;
+        this._completionDeferred = ( new DeferredPromise());
+        this.strategy = this._register(this._createStrategy(commandDetection));
+        this._register(this.strategy.onDidCreateStartMarker(marker => {
+            if (marker) {
+                this._startMarker = marker;
+            }
+        }));
+    }
+    _createStrategy(commandDetection) {
+        switch (this._toolTerminal.shellIntegrationQuality) {
+        case ShellIntegrationQuality.None:
+            return this._instantiationService.createInstance(
+                NoneExecuteStrategy,
+                this._toolTerminal.instance,
+                () => this._toolTerminal.receivedUserInput ?? false
+            );
+        case ShellIntegrationQuality.Basic:
+            return this._instantiationService.createInstance(
+                BasicExecuteStrategy,
+                this._toolTerminal.instance,
+                () => this._toolTerminal.receivedUserInput ?? false,
+                commandDetection
+            );
+        case ShellIntegrationQuality.Rich:
+            return this._instantiationService.createInstance(RichExecuteStrategy, this._toolTerminal.instance, commandDetection);
+        }
+    }
+    async start(commandLine, token, commandId) {
+        try {
+            const result = await this.strategy.execute(commandLine, token, commandId);
+            this._completionDeferred.complete(result);
+            return result;
+        } catch (e) {
+            this._completionDeferred.error(e);
+            throw e;
+        }
+    }
+    setForeground() {
+        this._isBackground = false;
+    }
+    setBackground() {
+        this._isBackground = true;
     }
     getOutput(marker) {
         return getOutput(this.instance, marker ?? this._startMarker);
     }
-}
+};
+ActiveTerminalExecution = ( __decorate([( __param(5, IInstantiationService))], ActiveTerminalExecution));
 let TerminalProfileFetcher = class TerminalProfileFetcher {
-    constructor(_configurationService, _terminalProfileResolverService, _remoteAgentService) {
+    constructor(
+        _configurationService,
+        _terminalProfileResolverService,
+        _remoteAgentService
+    ) {
         this._configurationService = _configurationService;
         this._terminalProfileResolverService = _terminalProfileResolverService;
         this._remoteAgentService = _remoteAgentService;
@@ -859,14 +1150,17 @@ let TerminalProfileFetcher = class TerminalProfileFetcher {
             os,
             remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority
         });
-        if (basename(defaultProfile.path) === 'cmd.exe') {
+        if (basename(defaultProfile.path) === "cmd.exe") {
             return {
                 ...defaultProfile,
-                path: 'C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe',
-                profileName: 'PowerShell'
+                path: "C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
+                profileName: "PowerShell"
             };
         }
-        return { ...defaultProfile, icon: undefined };
+        return {
+            ...defaultProfile,
+            icon: undefined
+        };
     }
     async getCopilotShell() {
         return (await this.getCopilotProfile()).path;
@@ -874,16 +1168,16 @@ let TerminalProfileFetcher = class TerminalProfileFetcher {
     _getChatTerminalProfile(os) {
         let profileSetting;
         switch (os) {
-            case OperatingSystem.Windows:
-                profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileWindows;
-                break;
-            case OperatingSystem.Macintosh:
-                profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileMacOs;
-                break;
-            case OperatingSystem.Linux:
-            default:
-                profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileLinux;
-                break;
+        case OperatingSystem.Windows:
+            profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileWindows;
+            break;
+        case OperatingSystem.Macintosh:
+            profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileMacOs;
+            break;
+        case OperatingSystem.Linux:
+        default:
+            profileSetting = TerminalChatAgentToolsSettingId.TerminalProfileLinux;
+            break;
         }
         const profile = this._configurationService.getValue(profileSetting);
         if (this._isValidChatAgentTerminalProfile(profile)) {
@@ -892,19 +1186,15 @@ let TerminalProfileFetcher = class TerminalProfileFetcher {
         return undefined;
     }
     _isValidChatAgentTerminalProfile(profile) {
-        if (profile === null || profile === undefined || typeof profile !== 'object') {
+        if (profile === null || profile === undefined || typeof profile !== "object") {
             return false;
         }
-        if ('path' in profile && isString(profile.path)) {
+        if ("path" in profile && isString(profile.path)) {
             return true;
         }
         return false;
     }
 };
-TerminalProfileFetcher = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, ITerminalProfileResolverService)),
-    ( __param(2, IRemoteAgentService))
-], TerminalProfileFetcher));
+TerminalProfileFetcher = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ITerminalProfileResolverService)), ( __param(2, IRemoteAgentService))], TerminalProfileFetcher));
 
 export { RunInTerminalTool, TerminalProfileFetcher, createRunInTerminalToolData };