@codingame/monaco-vscode-chat-service-override 34.1.2 → 35.0.0

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

@@ -19,7 +19,8 @@ import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
-import { ConfirmationOptionKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import { ConfirmationOptionKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
@@ -53,12 +54,13 @@ import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/
 import { ITerminalChatService, ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
 import { ITerminalProfileResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service';
 import { TerminalChatCommandId } from '@codingame/monaco-vscode-xterm-common/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat';
-import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { TerminalChatAgentToolsSettingId, DEFAULT_IDLE_SILENCE_TIMEOUT_MS } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
 import '../../common/terminalSandboxService.js';
 import { getRecommendedToolsOverRunInTerminal } from '../alternativeRecommendation.js';
 import { BasicExecuteStrategy } from '../executeStrategy/basicExecuteStrategy.js';
 import { NoneExecuteStrategy } from '../executeStrategy/noneExecuteStrategy.js';
 import { RichExecuteStrategy } from '../executeStrategy/richExecuteStrategy.js';
+import { LargeOutputFileWriter } from '../largeOutputFileWriter.js';
 import { getOutput } from '../outputHelpers.js';
 import { isWindowsPowerShell, isPowerShell, isZsh, isFish, normalizeTerminalCommandForDisplay, buildCommandDisplayText, extractCdPrefix } from '../runInTerminalHelpers.js';
 import { RunInTerminalToolTelemetry } from '../runInTerminalToolTelemetry.js';
@@ -82,23 +84,17 @@ import { outputLooksSandboxBlocked, outputLooksSandboxNetworkBlocked, SandboxOut
 import { TerminalCommandArtifactCollector } from './terminalCommandArtifactCollector.js';
 import { isToolEligibleForTerminalAutoApproval, isTerminalAutoApproveAllowed, isSessionAutoApproveLevel } from './terminalToolAutoApprove.js';
 import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
-import { TerminalSandboxPrerequisiteCheck } from '../../../../../../platform/sandbox/common/terminalSandboxService.js';
+import { TerminalSandboxPrerequisiteCheck, TerminalSandboxPreCheckRemediation } from '../../../../../../platform/sandbox/common/terminalSandboxService.js';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service';
 import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
 
-var RunInTerminalTool_1;
+var RunInTerminalTool_1, TerminalProfileFetcher_1;
 const TERMINAL_SANDBOX_DOCUMENTATION_URL = "https://aka.ms/vscode-sandboxing";
 const TOOL_REFERENCE_NAME = "runInTerminal";
 const LEGACY_TOOL_REFERENCE_FULL_NAMES = ["runCommands/runInTerminal"];
 const INPUT_NEEDED_NOTIFICATION_THROTTLE_MS = 5000;
-function createPowerShellModelDescription(
-    shell,
-    isSandboxEnabled,
-    allowToRunUnsandboxedCommands,
-    retryWithAllowNetworkRequests,
-    networkDomains
-) {
+function createPowerShellModelDescription(shell, sandboxingOptions) {
     const isWinPwsh = isWindowsPowerShell(shell);
     const parts = [
         `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.`,
@@ -119,25 +115,22 @@ function createPowerShellModelDescription(
         "- Install modules via Install-Module, Install-Package",
         "- Use Get-Command to verify cmdlet/function availability",
         "",
-        "Async Mode:",
-        "- Use mode=async ONLY for processes that should keep running while you do other work (servers, watchers, dev daemons)",
-        "- For one-shot long-running commands where you have nothing to do until they finish (package installs, builds, downloads, test suites), use mode=sync with a generous timeout (e.g. 600000 / 10 min for installs, longer for big builds) so the command can complete before your turn ends",
+        "Execution Mode:",
+        "- For ALL one-shot commands (builds, tests, installs, compilation, linting, downloads, scripts), use mode=sync and omit timeout. The tool waits for the command to complete and returns full output inline. This is the default and strongly preferred mode.",
+        `- Use mode=async ONLY for processes that must keep running indefinitely while you do other work (servers, watchers, dev daemons). Async waits for an initial idle/output signal, then returns a terminal ID and output snapshot while the process continues running.`,
+        `- In sync mode, the full output is returned when the command completes — you do NOT need to call ${TerminalToolId.GetTerminalOutput} afterward. Only use ${TerminalToolId.GetTerminalOutput} if the tool result explicitly says the command was moved to background, timed out, or needs input.`,
         "- Returns a terminal ID for checking status and runtime later",
         "- Use Start-Job for background PowerShell jobs",
         "",
         `Use ${TerminalToolId.SendToTerminal} to send commands or input to a terminal session.`
     ];
-    if (isSandboxEnabled) {
-        parts.push(...createSandboxLines(
-            allowToRunUnsandboxedCommands,
-            retryWithAllowNetworkRequests,
-            networkDomains
-        ));
+    if (sandboxingOptions.sandboxMode !== "off") {
+        parts.push(...createSandboxLines(sandboxingOptions));
     }
     parts.push(
         "",
         "Output Management:",
-        "- Output is automatically truncated if longer than 60KB to prevent context overflow",
+        "- Output exceeding 20KB is saved to a temp file; the result includes the file path so you can read the full output with readFile or search it with grep",
         "- 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",
@@ -151,6 +144,7 @@ function createPowerShellModelDescription(
         "- Be specific with Select-Object properties to avoid excessive output",
         "- Avoid printing credentials unless absolutely required",
         `- NEVER run Start-Sleep or similar wait commands. You will be automatically notified on your next turn when async terminal commands or timed-out sync commands complete or need input. Do NOT poll for completion.`,
+        "- NEVER pipe interactive commands through Select-Object, Where-Object, or other filters — this hides prompts and prevents the terminal from detecting when input is needed. Run interactive commands without pipes.",
         "",
         "Interactive Input Handling:",
         "- When a terminal command is waiting for interactive input, do NOT suggest alternatives or ask the user whether to proceed. Instead, use the vscode_askQuestions tool to collect the needed values from the user, then send them.",
@@ -161,60 +155,97 @@ function createPowerShellModelDescription(
     );
     return parts.join("\n");
 }
-function createSandboxLines(
-    allowToRunUnsandboxedCommands,
-    retryWithAllowNetworkRequests,
-    networkDomains
-) {
+function createSandboxLines(sandboxingOptions) {
+    const isNetworkAvailable = sandboxingOptions.sandboxMode === "on-network-available";
     const lines = [
         "",
         "Sandboxing:",
-        "- ATTENTION: Terminal sandboxing is enabled, commands run in a sandbox by default",
-        "- When executing commands within the sandboxed environment, all operations requiring a temporary directory must utilize the $TMPDIR environment variable. The /tmp directory is not guaranteed to be accessible or writable and must be avoided",
-        "- Tools and scripts should respect the TMPDIR environment variable, which is automatically set to an appropriate path within the sandbox"
+        isNetworkAvailable ? "- Commands run inside a sandbox by default. The sandbox keeps the filesystem mostly read-only." : "- Commands run inside a sandbox by default. The sandbox restricts two things independently: the filesystem and the network.",
+        "- Filesystem: read-only outside the workspace and $TMPDIR, which stay read-write. Parts of $HOME are hidden for privacy, but common developer tools (git, package managers, language toolchains) still work because their $HOME config and cache paths are automatically made readable.",
+        "- Use $TMPDIR for temporary files; /tmp may not be writable. On macOS and Linux the TMPDIR env var is set to a writable path.",
+        "- If a command needs sandboxed write access to specific file paths outside workspace, pass requestFileValidationCheck with those paths. VS Code checks sandbox access before execution and returns Access Denied without running the command when access is unavailable."
     ];
-    if (retryWithAllowNetworkRequests) {
-        lines.push(
-            "- When a command fails due to network access being blocked by the sandbox, immediately re-run it with requestAllowNetwork=true and provide requestAllowNetworkReason. This keeps the command in the sandbox with unrestricted network access and automatically shows a confirmation prompt to the user",
-            "- Only set requestAllowNetwork=true when there is evidence of network failures caused by the sandbox, e.g. 'Network request failed' errors, API call failures, or other indications of blocked network access in the command output",
-            "- When setting requestAllowNetwork=true, also provide requestAllowNetworkReason explaining why the command needs network access"
-        );
+    if (!isNetworkAvailable) {
+        const deniedDomains = sandboxingOptions.networkDomains?.deniedDomains ?? [];
+        const allowedDomains = sandboxingOptions.networkDomains?.allowedDomains ?? [];
+        const deniedSet = ( new Set(deniedDomains));
+        const effectiveAllowed = allowedDomains.filter(d => !( deniedSet.has(d)));
+        const retrySuffix = sandboxingOptions.retryWithAllowNetworkRequests ? " unless requestAllowNetwork=true is set" : "";
+        if (effectiveAllowed.length === 0) {
+            lines.push(
+                `- Network: blocked in the sandbox; commands that need the network fail${retrySuffix}.`
+            );
+        } else {
+            lines.push(
+                `- Network: only these domains are reachable in the sandbox: ${effectiveAllowed.join(", ")}. Other domains fail${retrySuffix}.`
+            );
+        }
+        if (deniedDomains.length > 0) {
+            lines.push(
+                `- These domains are explicitly blocked in the sandbox: ${deniedDomains.join(", ")}`
+            );
+        }
     }
-    if (allowToRunUnsandboxedCommands) {
+    if (sandboxingOptions.retryWithAllowNetworkRequests || sandboxingOptions.allowToRunUnsandboxedCommands) {
         lines.push(
-            "- When a command fails due to sandbox restrictions, immediately re-run it with requestUnsandboxedExecution=true. Do NOT ask the user for permission — setting this flag automatically shows a confirmation prompt to the user",
-            "- Only set requestUnsandboxedExecution=true when there is evidence of failures caused by the sandbox, e.g. 'Operation not permitted' errors, network failures, or file access errors, etc",
-            "- When setting requestUnsandboxedExecution=true, also provide requestUnsandboxedExecutionReason explaining why the command needs unsandboxed access"
+            "- To get more access (each prompts the user — never ask the user for permission yourself):"
         );
-    } else {
-        lines.push(
-            "- Running commands outside the sandbox is disabled by the current chat.agent.sandbox.allowUnsandboxedCommands setting. Do not set requestUnsandboxedExecution=true."
-        );
-    }
-    if (networkDomains) {
-        const deniedSet = ( new Set(networkDomains.deniedDomains));
-        const effectiveAllowed = networkDomains.allowedDomains.filter(d => !( deniedSet.has(d)));
-        if (effectiveAllowed.length === 0) {
-            lines.push("- All network access is blocked in the sandbox");
-        } else {
+        if (sandboxingOptions.retryWithAllowNetworkRequests) {
             lines.push(
-                `- Only the following domains are accessible in the sandbox (all other network access is blocked): ${effectiveAllowed.join(", ")}`
+                "  - Need a blocked domain? Set requestAllowNetwork=true and provide requestAllowNetworkReason. This keeps the filesystem sandbox in place and only relaxes the network, so prefer it for network-only needs. Do this proactively when network use is obvious (git fetch/pull/push/clone; npm/yarn/pnpm/pip/cargo/go/brew installs; curl; wget), or reactively after a network failure (e.g. 'Network request failed', HTTP code 403)."
             );
         }
-        if (networkDomains.deniedDomains.length > 0) {
+        if (sandboxingOptions.allowToRunUnsandboxedCommands) {
+            const removesAllClause = sandboxingOptions.retryWithAllowNetworkRequests ? "This grants full filesystem AND network access by removing all sandbox protection, so for network-only needs prefer requestAllowNetwork and use this only when filesystem (or other non-network) access is also blocked." : "This grants full filesystem and network access by removing all sandbox protection, so use it only when the command truly needs it.";
             lines.push(
-                `- The following domains are explicitly blocked in the sandbox: ${networkDomains.deniedDomains.join(", ")}`
+                `  - Need filesystem or other access the sandbox blocks? Set requestUnsandboxedExecution=true and provide requestUnsandboxedExecutionReason. ${removesAllClause} Do this proactively when it clearly needs it (writing/deleting files outside the workspace and $TMPDIR like $HOME, /usr, /etc; installing to system locations; elevated privileges), or reactively after a sandbox failure (e.g. \'Operation not permitted\').`
             );
         }
     }
+    if (!sandboxingOptions.allowToRunUnsandboxedCommands) {
+        lines.push(
+            "- Running commands outside the sandbox is disabled by chat.agent.sandbox.allowUnsandboxedCommands. Do not set requestUnsandboxedExecution=true."
+        );
+    }
     return lines;
 }
-function createGenericDescription(
-    isSandboxEnabled,
-    allowToRunUnsandboxedCommands,
-    retryWithAllowNetworkRequests,
-    networkDomains
-) {
+function createSandboxProperties(sandboxingOptions) {
+    const isNetworkAvailable = sandboxingOptions.sandboxMode === "on-network-available";
+    return {
+        ...(sandboxingOptions.allowToRunUnsandboxedCommands ? {
+            requestUnsandboxedExecution: {
+                type: "boolean",
+                description: "Request that this command run outside the terminal sandbox. Only set this when the command clearly needs unsandboxed access. The user will be prompted before the command runs unsandboxed."
+            },
+            requestUnsandboxedExecutionReason: {
+                type: "string",
+                description: "A short explanation of why this command must run outside the terminal sandbox. Only provide this when requestUnsandboxedExecution is true."
+            }
+        } : {}),
+        ...(isNetworkAvailable || !sandboxingOptions.retryWithAllowNetworkRequests ? {} : {
+            requestAllowNetwork: {
+                type: "boolean",
+                description: "Request that this command remain in the terminal sandbox but run with unrestricted network access. Only set this when the command clearly needs network access but the required network access was blocked. The user will be prompted before network restrictions are relaxed."
+            },
+            requestAllowNetworkReason: {
+                type: "string",
+                description: "A short explanation of why this sandboxed command needs unrestricted network access. Only provide this when requestAllowNetwork is true."
+            }
+        }),
+        requestFileValidationCheck: {
+            type: "array",
+            description: "Sandbox write access checks to perform before running the command. Provide the file paths that the command needs to write.",
+            items: {
+                type: "string"
+            }
+        },
+        requestFileValidationCheckReason: {
+            type: "string",
+            description: "A short explanation of why this sandboxed command needs these file paths. Only provide this when requestFileValidationCheck is not empty."
+        }
+    };
+}
+function createGenericDescription(sandboxingOptions) {
     const parts = [`
 Command Execution:
 - Use && to chain simple commands on one line
@@ -233,23 +264,19 @@ Program Execution:
 - Install packages via package managers (brew, apt, etc.)
 - Use which or command -v to verify command availability
 
-Async Mode:
-- Use mode=async ONLY for processes that should keep running while you do other work (servers, watchers, dev daemons)
-- For one-shot long-running commands where you have nothing to do until they finish (package installs, builds, downloads, test suites), use mode=sync with a generous timeout (e.g. 600000 / 10 min for installs, longer for big builds) so the command can complete before your turn ends
-- Returns a terminal ID for checking status and runtime later
+Execution Mode:
+- For ALL one-shot commands (builds, tests, installs, compilation, linting, downloads, scripts), use mode='sync' and omit timeout. The tool waits for the command to complete and returns full output inline. This is the default and strongly preferred mode.
+- Use mode='async' ONLY for processes that must keep running indefinitely while you do other work (servers, watchers, dev daemons). Async waits for an initial idle/output signal, then returns a terminal ID and output snapshot while the process continues running.
+- In sync mode, the full output is returned when the command completes — you do NOT need to call ${TerminalToolId.GetTerminalOutput} afterward. Only use ${TerminalToolId.GetTerminalOutput} if the tool result explicitly says the command was moved to background, timed out, or needs input.
 
 Use ${TerminalToolId.SendToTerminal} to send commands or input to a terminal session.`];
-    if (isSandboxEnabled) {
-        parts.push(createSandboxLines(
-            allowToRunUnsandboxedCommands,
-            retryWithAllowNetworkRequests,
-            networkDomains
-        ).join("\n"));
+    if (sandboxingOptions.sandboxMode !== "off") {
+        parts.push(createSandboxLines(sandboxingOptions).join("\n"));
     }
     parts.push(`
 
 Output Management:
-- Output is automatically truncated if longer than 60KB to prevent context overflow
+- Output exceeding 20KB is saved to a temp file; the result includes the file path so you can read the full output with readFile or search it with grep
 - Use head, tail, grep, awk to filter and limit output size
 - For pager commands, disable paging: git --no-pager or add | cat
 - Use wc -l to count lines before displaying large outputs
@@ -260,6 +287,7 @@ Best Practices:
 - Be specific with commands to avoid excessive output
 - Avoid printing credentials unless absolutely required
 - NEVER run sleep or similar wait commands in a terminal. You will be automatically notified on your next turn when async terminal commands or timed-out sync commands complete or need input. Do NOT poll for completion.
+- NEVER pipe interactive commands through tail, head, grep, or other filters — this hides prompts and prevents the terminal from detecting when input is needed. Run interactive commands without pipes.
 
 Interactive Input Handling:
 - When a terminal command is waiting for interactive input, do NOT suggest alternatives or ask the user whether to proceed. Instead, use the vscode_askQuestions tool to collect the needed values from the user, then send them.
@@ -269,38 +297,18 @@ Interactive Input Handling:
 - Continue one prompt at a time until the command finishes.`);
     return parts.join("");
 }
-function createBashModelDescription(
-    isSandboxEnabled,
-    allowToRunUnsandboxedCommands,
-    retryWithAllowNetworkRequests,
-    networkDomains
-) {
+function createBashModelDescription(sandboxingOptions) {
     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.",
-        createGenericDescription(
-            isSandboxEnabled,
-            allowToRunUnsandboxedCommands,
-            retryWithAllowNetworkRequests,
-            networkDomains
-        ),
+        createGenericDescription(sandboxingOptions),
         "- Use [[ ]] for conditional tests instead of [ ]",
         "- Prefer $() over backticks for command substitution"
     ].join("\n");
 }
-function createZshModelDescription(
-    isSandboxEnabled,
-    allowToRunUnsandboxedCommands,
-    retryWithAllowNetworkRequests,
-    networkDomains
-) {
+function createZshModelDescription(sandboxingOptions) {
     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.",
-        createGenericDescription(
-            isSandboxEnabled,
-            allowToRunUnsandboxedCommands,
-            retryWithAllowNetworkRequests,
-            networkDomains
-        ),
+        createGenericDescription(sandboxingOptions),
         "- Use type to check command type (builtin, function, alias)",
         "- Use jobs, fg, bg for job control",
         "- Use [[ ]] for conditional tests instead of [ ]",
@@ -312,20 +320,10 @@ function createZshModelDescription(
         "- NEVER use status as a variable name (it is read-only in zsh). Use exit_code or ret instead"
     ].join("\n");
 }
-function createFishModelDescription(
-    isSandboxEnabled,
-    allowToRunUnsandboxedCommands,
-    retryWithAllowNetworkRequests,
-    networkDomains
-) {
+function createFishModelDescription(sandboxingOptions) {
     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.",
-        createGenericDescription(
-            isSandboxEnabled,
-            allowToRunUnsandboxedCommands,
-            retryWithAllowNetworkRequests,
-            networkDomains
-        ),
+        createGenericDescription(sandboxingOptions),
         "- Use type to check command type (builtin, function, alias)",
         "- Use jobs, fg, bg for job control",
         "- Use test expressions for conditionals (no [[ ]] syntax)",
@@ -347,38 +345,28 @@ async function createRunInTerminalToolData(accessor) {
         terminalSandboxService.isEnabled(),
         terminalSandboxService.isSandboxAllowNetworkEnabled()
     ]);
-    const retryWithAllowNetworkRequests = isSandboxEnabled && !isSandboxAllowNetworkEnabled && retryWithAllowNetworkRequestsSetting;
-    const networkDomains = isSandboxEnabled && !isSandboxAllowNetworkEnabled ? terminalSandboxService.getResolvedNetworkDomains() : undefined;
+    const sandboxingOptions = (isSandboxEnabled ? (isSandboxAllowNetworkEnabled ? {
+        sandboxMode: "on-network-available",
+        allowToRunUnsandboxedCommands,
+        retryWithAllowNetworkRequests: false,
+        networkDomains: undefined
+    } : {
+        sandboxMode: "on-network-restricted",
+        allowToRunUnsandboxedCommands,
+        retryWithAllowNetworkRequests: retryWithAllowNetworkRequestsSetting,
+        networkDomains: terminalSandboxService.getResolvedNetworkDomains()
+    }) : {
+        sandboxMode: "off"
+    });
     let modelDescription;
     if (shell && os && isPowerShell(shell, os)) {
-        modelDescription = createPowerShellModelDescription(
-            shell,
-            isSandboxEnabled,
-            allowToRunUnsandboxedCommands,
-            retryWithAllowNetworkRequests,
-            networkDomains
-        );
+        modelDescription = createPowerShellModelDescription(shell, sandboxingOptions);
     } else if (shell && os && isZsh(shell, os)) {
-        modelDescription = createZshModelDescription(
-            isSandboxEnabled,
-            allowToRunUnsandboxedCommands,
-            retryWithAllowNetworkRequests,
-            networkDomains
-        );
+        modelDescription = createZshModelDescription(sandboxingOptions);
     } else if (shell && os && isFish(shell, os)) {
-        modelDescription = createFishModelDescription(
-            isSandboxEnabled,
-            allowToRunUnsandboxedCommands,
-            retryWithAllowNetworkRequests,
-            networkDomains
-        );
+        modelDescription = createFishModelDescription(sandboxingOptions);
     } else {
-        modelDescription = createBashModelDescription(
-            isSandboxEnabled,
-            allowToRunUnsandboxedCommands,
-            retryWithAllowNetworkRequests,
-            networkDomains
-        );
+        modelDescription = createBashModelDescription(sandboxingOptions);
     }
     const sharedProperties = {
         command: {
@@ -394,37 +382,14 @@ async function createRunInTerminalToolData(accessor) {
             description: "A short description of the goal or purpose of the command (e.g., \"Install dependencies\", \"Start development server\")."
         }
     };
-    const sandboxProperties = isSandboxEnabled ? {
-        allowToRunUnsandboxedCommands: {
-            type: "boolean",
-            const: allowToRunUnsandboxedCommands,
-            default: allowToRunUnsandboxedCommands,
-            description: "Whether this tool invocation is allowed to run commands outside the terminal sandbox. This value is set by VS Code based on chat.agent.sandbox.allowUnsandboxedCommands."
-        },
-        requestUnsandboxedExecution: {
-            type: "boolean",
-            description: "Request that this command run outside the terminal sandbox. Only set this when the command clearly needs unsandboxed access. The user will be prompted before the command runs unsandboxed."
-        },
-        requestUnsandboxedExecutionReason: {
-            type: "string",
-            description: "A short explanation of why this command must run outside the terminal sandbox. Only provide this when requestUnsandboxedExecution is true."
-        },
-        requestAllowNetwork: {
-            type: "boolean",
-            description: "Request that this command remain in the terminal sandbox but run with unrestricted network access. Only set this when the command clearly needs network access but the required network access was blocked. The user will be prompted before network restrictions are relaxed."
-        },
-        requestAllowNetworkReason: {
-            type: "string",
-            description: "A short explanation of why this sandboxed command needs unrestricted network access. Only provide this when requestAllowNetwork is true."
-        }
-    } : {};
+    const sandboxProperties = sandboxingOptions.sandboxMode === "off" ? {} : createSandboxProperties(sandboxingOptions);
     return {
         id: TerminalToolId.RunInTerminal,
         toolReferenceName: TOOL_REFERENCE_NAME,
         legacyToolReferenceFullNames: LEGACY_TOOL_REFERENCE_FULL_NAMES,
-        displayName: ( localize(14671, "Run in Terminal")),
-        modelDescription: `${modelDescription}\n\nExecution mode:\n- mode='sync': wait for completion (optionally capped by timeout); if still running when timeout elapses, return with a terminal ID.\n- mode='async': wait for an initial idle/output signal, then return with terminal output snapshot and ID. Timeout caps how long to wait for the initial idle/output signal.\n- Prefer mode='sync' for commands that will prompt for interactive input (e.g., npm init, interactive installers, configuration wizards).\n\nTimeout parameter: For one-shot long-running commands, set a generous timeout as a safety net (e.g. 600000 for installs, longer for big builds). Omit timeout only for processes that should run indefinitely (servers, daemons). If the timeout elapses, you get a terminal ID and can check output later.\n\nTerminal notifications: When an async command finishes or a sync command times out, you will be automatically notified on your next turn with the exit code and terminal output. You will also be notified if the terminal needs input. Do NOT poll or sleep to wait for completion.`,
-        userDescription: ( localize(14672, "Run commands in the terminal")),
+        displayName: ( localize(15318, "Run in Terminal")),
+        modelDescription: `${modelDescription}\n\nExecution mode:\n- mode='sync' (strongly preferred): waits for the command to complete and returns full output inline. Use for ALL one-shot commands (builds, tests, installs, compilation, scripts). Omit timeout to let the command run to completion — the tool handles idle detection and input prompts automatically.\n- mode='async': waits for an initial idle/output signal from the command, then returns a terminal ID and output snapshot while the process continues running. Use ONLY for processes that must keep running indefinitely (servers, watchers, daemons). Timeout caps how long to wait for the initial idle/output signal.\n\nTimeout parameter: Usually omit timeout entirely for sync commands — the tool returns automatically on completion, input-needed, or cancellation. Only set a timeout as a safety net for commands you suspect might hang. Use 0 to explicitly indicate no timeout.\n\nSync output is final: When a sync command completes, the full output is returned inline — do NOT call ${TerminalToolId.GetTerminalOutput} afterward. Only use ${TerminalToolId.GetTerminalOutput} if the tool result explicitly indicates the command was moved to background, timed out, or needs input. Do NOT tell the user to check the terminal panel — all command output is already included in the tool result.\n\nTerminal notifications: When an async command finishes or a sync command times out, you will be automatically notified on your next turn with the exit code and terminal output. You will also be notified if the terminal needs input. Do NOT poll or sleep to wait for completion.`,
+        userDescription: ( localize(15319, "Run commands in the terminal")),
         source: ToolDataSource.Internal,
         icon: Codicon.terminal,
         inputSchema: {
@@ -436,10 +401,10 @@ async function createRunInTerminalToolData(accessor) {
                     type: "string",
                     enum: ["sync", "async"],
                     enumDescriptions: [
-                        "Wait for completion up to timeout, then return with collected output. If still running at timeout, the terminal session continues in the background.",
-                        "Wait for an initial idle/output signal, then return with a terminal ID and output snapshot while the session may continue running."
+                        "Wait for command completion and return full output inline. Strongly preferred for all one-shot commands (builds, tests, installs, scripts).",
+                        "Wait for an initial idle/output signal, then return a terminal ID and output snapshot while the process continues running. Timeout caps how long to wait for the initial signal. Use ONLY for processes that must keep running indefinitely (servers, watchers, daemons)."
                     ],
-                    description: "Execution mode for this command."
+                    description: "Execution mode for this command. Use sync (default) for nearly all commands."
                 },
                 isBackground: {
                     type: "boolean",
@@ -447,7 +412,7 @@ async function createRunInTerminalToolData(accessor) {
                 },
                 timeout: {
                     type: "number",
-                    description: "Optional. Hard cap in milliseconds before the tool returns. If you set a timeout, use a generous value (e.g. 600000 = 10 min for installs, 900000 = 15 min for big builds). Too-short timeouts cause the command to continue in the background, which wastes turns on unnecessary polling. Omit entirely to let the command run to completion. Use 0 to explicitly indicate no timeout."
+                    description: "Optional. Usually omit entirely for sync commands — the tool waits for completion automatically. Only set a timeout (in milliseconds) as a safety net if you suspect the command might hang. If the timeout elapses, the command continues in the background and you get a terminal ID to check output later. Use 0 to explicitly indicate no timeout."
                 }
             },
             required: ["command", "explanation", "goal", "mode"]
@@ -490,7 +455,7 @@ function shouldAutomaticallyRetryAllowNetworkInSandboxed(options) {
 const telemetryIgnoredSequences = [
 "\u001b[I",
 "\u001b[O"];
-const altBufferMessage = "\n" + ( localize(14673, "The command opened the alternate buffer."));
+const altBufferMessage = "\n" + ( localize(15320, "The command opened the alternate buffer."));
 function buildCompletionNotificationCommand(command) {
     const firstNewline = command.search(/\r|\n/);
     const hasMoreLines = firstNewline !== -1;
@@ -565,9 +530,6 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
     get _allowUnsandboxedCommands() {
         return this._configurationService.getValue(AgentSandboxSettingId.AgentSandboxAllowUnsandboxedCommands) === true;
     }
-    get _autoApproveUnsandboxedCommands() {
-        return this._allowUnsandboxedCommands && this._configurationService.getValue(AgentSandboxSettingId.AgentSandboxAutoApproveUnsandboxedCommands) === true;
-    }
     get _retryWithAllowNetworkRequests() {
         return this._configurationService.getValue(AgentSandboxSettingId.AgentSandboxRetryWithAllowNetworkRequests) === true;
     }
@@ -585,16 +547,31 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
     }
     _getUnsandboxedExecutionDisabledMessage() {
         return localize(
-            14674,
+            15321,
             "The command was not executed because it requested to run outside the terminal sandbox, but running commands outside the sandbox is disabled by chat.agent.sandbox.allowUnsandboxedCommands. Run the command in the sandbox instead, or enable the setting to allow unsandboxed execution."
         );
     }
     _getAllowNetworkRequestDisabledMessage() {
         return localize(
-            14675,
+            15322,
             "The command was not executed because it requested unrestricted network access in the terminal sandbox, but per-command network access is disabled by chat.agent.sandbox.retryWithAllowNetworkRequests. Run the command with restricted network access instead, or enable the setting to allow network access requests."
         );
     }
+    async _getDeniedSandboxFileAccess(paths, sandboxPrecheckInputs) {
+        if (!paths?.length) {
+            return [];
+        }
+        const result = await this._terminalSandboxService.checkFileAccess("write", paths, sandboxPrecheckInputs);
+        return result.denied;
+    }
+    _buildSandboxFileAccessDeniedMessage(deniedPaths) {
+        const deniedPathsMessage = ( deniedPaths.map(path => `write: ${path}`)).join("\n");
+        return localize(
+            15323,
+            "Access Denied: The command was not executed because the terminal sandbox does not allow access to the requested file paths:\n{0}",
+            deniedPathsMessage
+        );
+    }
     get _enableCommandLineSandboxRewriting() {
         return true;
     }
@@ -650,6 +627,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         this._telemetry = this._instantiationService.createInstance(RunInTerminalToolTelemetry);
         this._commandArtifactCollector = this._instantiationService.createInstance(TerminalCommandArtifactCollector);
         this._profileFetcher = this._instantiationService.createInstance(TerminalProfileFetcher);
+        this._largeOutputFileWriter = this._register(this._instantiationService.createInstance(LargeOutputFileWriter));
         this._commandLineRewriters = [
             this._register(this._instantiationService.createInstance(CommandLineCdPrefixRewriter)),
             this._register(
@@ -711,19 +689,20 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             for (const resource of e.sessionResources) {
                 this._cleanupSessionTerminals(resource);
             }
+            this._largeOutputFileWriter.cleanup();
         }));
     }
     async handleToolStream(context, _token) {
         const partialInput = context.rawInput;
         if (partialInput && typeof partialInput === "object" && partialInput.command) {
             const truncatedCommand = buildCommandDisplayText(partialInput.command);
-            const invocationMessage = ( new MarkdownString(( localize(14676, "Running `{0}`", escapeMarkdownSyntaxTokens(truncatedCommand)))));
+            const invocationMessage = ( new MarkdownString(( localize(15324, "Running `{0}`", escapeMarkdownSyntaxTokens(truncatedCommand)))));
             return {
                 invocationMessage
             };
         }
         return {
-            invocationMessage: ( localize(14677, "Running command"))
+            invocationMessage: ( localize(15325, "Running command"))
         };
     }
     async prepareToolInvocation(context, token) {
@@ -763,13 +742,18 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         let requiresAllowNetworkConfirmation = explicitAllowNetworkRequest;
         let requestAllowNetworkReason = explicitAllowNetworkRequest ? args.requestAllowNetworkReason : undefined;
         const missingDependencies = sandboxPrereqs.failedCheck === TerminalSandboxPrerequisiteCheck.Dependencies && sandboxPrereqs.missingDependencies?.length ? sandboxPrereqs.missingDependencies : undefined;
+        const sandboxRemediations = sandboxPrereqs.failedCheck === TerminalSandboxPrerequisiteCheck.Bubblewrap && sandboxPrereqs.remediations?.length ? [...sandboxPrereqs.remediations] : undefined;
+        const sandboxPrerequisiteFailure = sandboxPrereqs.failedCheck === TerminalSandboxPrerequisiteCheck.Bubblewrap && !sandboxRemediations ? ( localize(
+            15326,
+            "Bubblewrap is installed but cannot create the required sandbox namespace on this system. The command was not executed."
+        )) : undefined;
         const terminalToolSessionId = generateUuid();
         const terminalCommandId = `tool-${generateUuid()}`;
         if (this._shouldRejectUnsandboxedExecutionRequest(isSandboxEnabled, allowUnsandboxedCommands, args)) {
             const commandToDisplay = normalizeTerminalCommandForDisplay(args.command);
             return {
                 invocationMessage: ( new MarkdownString(( localize(
-                    14678,
+                    15327,
                     "Not running `{0}` because unsandboxed execution is disabled",
                     escapeMarkdownSyntaxTokens(buildCommandDisplayText(commandToDisplay))
                 )))),
@@ -795,7 +779,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             const commandToDisplay = normalizeTerminalCommandForDisplay(args.command);
             return {
                 invocationMessage: ( new MarkdownString(( localize(
-                    14679,
+                    15328,
                     "Not running `{0}` because unrestricted network access in the sandbox is disabled",
                     escapeMarkdownSyntaxTokens(buildCommandDisplayText(commandToDisplay))
                 )))),
@@ -853,28 +837,51 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             requestUnsandboxedExecutionReason,
             requestAllowNetwork: requiresAllowNetworkConfirmation,
             requestAllowNetworkReason,
-            missingSandboxDependencies: missingDependencies
+            missingSandboxDependencies: missingDependencies,
+            sandboxRemediations,
+            sandboxPrerequisiteFailure
         };
-        let sandboxConfirmationMessageForMissingDeps = undefined;
+        let sandboxPrerequisiteConfirmation = undefined;
         if (missingDependencies) {
             const depsList = missingDependencies.join(", ");
-            sandboxConfirmationMessageForMissingDeps = {
-                title: ( localize(14680, "Missing Sandbox Dependencies")),
+            sandboxPrerequisiteConfirmation = {
+                title: ( localize(15329, "Missing Sandbox Dependencies")),
                 message: ( new MarkdownString(( localize(
-                    14681,
+                    15330,
                     "The following dependencies required for sandboxed execution are not installed: {0}. Would you like to install them?",
                     depsList
                 )))),
                 customOptions: [{
                     id: "install",
-                    label: ( localize(14682, "Install")),
+                    label: ( localize(15331, "Install")),
                     kind: ConfirmationOptionKind.Approve
                 }, {
                     id: "cancel",
-                    label: ( localize(14683, "Cancel")),
+                    label: ( localize(15332, "Cancel")),
                     kind: ConfirmationOptionKind.Deny
                 }]
             };
+        } else if (sandboxRemediations) {
+            const customOptions = [];
+            if (sandboxRemediations.includes(
+                TerminalSandboxPreCheckRemediation.DisableUnprivilagedusernamespaceRestriction
+            )) {
+                customOptions.push({
+                    id: TerminalSandboxPreCheckRemediation.DisableUnprivilagedusernamespaceRestriction,
+                    label: ( localize(15333, "Apply Fix and Retry")),
+                    kind: ConfirmationOptionKind.Approve
+                });
+            }
+            customOptions.push({
+                id: "cancel",
+                label: ( localize(15334, "Cancel")),
+                kind: ConfirmationOptionKind.Deny
+            });
+            sandboxPrerequisiteConfirmation = {
+                title: ( localize(15335, "Repair Bubblewrap Sandbox")),
+                message: ( new MarkdownString(( localize(15336, "Bubblewrap cannot create the sandbox environment.")))),
+                customOptions
+            };
         }
         const alternativeRecommendation = getRecommendedToolsOverRunInTerminal(args.command, this._languageModelToolsService);
         if (alternativeRecommendation) {
@@ -946,9 +953,8 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         const isAutoApprovedByRules =
         (isAutoApproveAllowed &&
         wouldBeAutoApproved);
-        const isUnsandboxedAutoApproved = isSandboxEnabled && requiresUnsandboxConfirmation === true && this._autoApproveUnsandboxedCommands;
         const isSandboxAutoApproved = isSandboxEnabled && toolSpecificData.commandLine.isSandboxWrapped === true && !requiresAllowNetworkConfirmation && this._allowSandboxAutoApprove;
-        const isFinalAutoApproved = isUnsandboxedAutoApproved || isSandboxAutoApproved || isAutoApprovedByRules || ( commandLineAnalyzerResults.some(e => e.forceAutoApproval));
+        const isFinalAutoApproved = isSandboxAutoApproved || isAutoApprovedByRules || ( commandLineAnalyzerResults.some(e => e.forceAutoApproval));
         if (isFinalAutoApproved || (isAutoApproveEnabled && ( commandLineAnalyzerResults.some(e => e.autoApproveInfo)))) {
             toolSpecificData.autoApproveInfo = commandLineAnalyzerResults.find(e => e.autoApproveInfo)?.autoApproveInfo;
         }
@@ -969,12 +975,12 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 cwdLabel: directoryLabel,
                 cdPrefix
             };
-            confirmationTitle = ( localize(14684, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
+            confirmationTitle = ( localize(15337, "Run `{0}` command within `{1}`?", shellType, directoryLabel));
         } else {
             toolSpecificData.confirmation = {
                 commandLine: commandToDisplay
             };
-            confirmationTitle = ( localize(14685, "Run `{0}` command?", shellType));
+            confirmationTitle = ( localize(15338, "Run `{0}` command?", shellType));
         }
         const commandForPresenter = extractedCd?.command ?? commandToDisplay;
         let presenterInput = commandForPresenter;
@@ -995,7 +1001,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 if (extractedCd && toolSpecificData.confirmation?.cwdLabel) {
                     if (presenterResult.languageDisplayName) {
                         confirmationTitle = ( localize(
-                            14686,
+                            15339,
                             "Run `{0}` command in `{1}` within `{2}`?",
                             presenterResult.languageDisplayName,
                             shellType,
@@ -1003,7 +1009,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                         ));
                     } else {
                         confirmationTitle = ( localize(
-                            14687,
+                            15340,
                             "Run command in `{0}` within `{1}`?",
                             shellType,
                             toolSpecificData.confirmation.cwdLabel
@@ -1012,13 +1018,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 } else {
                     if (presenterResult.languageDisplayName) {
                         confirmationTitle = ( localize(
-                            14688,
+                            15341,
                             "Run `{0}` command in `{1}`?",
                             presenterResult.languageDisplayName,
                             shellType
                         ));
                     } else {
-                        confirmationTitle = ( localize(14689, "Run command in `{0}`?", shellType));
+                        confirmationTitle = ( localize(15342, "Run command in `{0}`?", shellType));
                     }
                 }
                 if (!presenterResult.processOtherPresenters) {
@@ -1029,43 +1035,43 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         }
         if (requiresUnsandboxConfirmation) {
             confirmationTitle = blockedDomains?.length ? ( localize(
-                14690,
+                15343,
                 "Run `{0}` command outside the [sandbox]({1}) to access {2}?",
                 shellType,
                 TERMINAL_SANDBOX_DOCUMENTATION_URL,
                 this._formatBlockedDomainsForTitle(blockedDomains)
             )) : ( localize(
-                14691,
+                15344,
                 "Run `{0}` command outside the [sandbox]({1})?",
                 shellType,
                 TERMINAL_SANDBOX_DOCUMENTATION_URL
             ));
         } else if (requiresAllowNetworkConfirmation) {
             confirmationTitle = ( localize(
-                14692,
+                15345,
                 "Allow the sandbox to run `{0}` command with unrestricted network access.",
                 shellType
             ));
         }
         const shouldShowConfirmation = (!isFinalAutoApproved && (!isSessionAutoApproved || requiresAllowNetworkConfirmation)) || context.forceConfirmationReason !== undefined;
-        const explanation = args.explanation || ( localize(14693, "No explanation provided"));
-        const goal = args.goal || ( localize(14694, "No goal provided"));
+        const explanation = args.explanation || ( localize(15346, "No explanation provided"));
+        const goal = args.goal || ( localize(15347, "No goal provided"));
         const confirmationMessage = requiresUnsandboxConfirmation ? ( new MarkdownString(( localize(
-            14695,
+            15348,
             "Explanation: {0}\n\nGoal: {1}\n\nReason for leaving the sandbox: {2}",
             explanation,
             goal,
-            requestUnsandboxedExecutionReason || ( localize(14696, "The model indicated that this command needs unsandboxed access."))
+            requestUnsandboxedExecutionReason || ( localize(15349, "The model indicated that this command needs unsandboxed access."))
         )))) : requiresAllowNetworkConfirmation ? ( new MarkdownString(( localize(
-            14697,
+            15350,
             "Explanation: {0}\n\nGoal: {1}\n\nReason for allowing unrestricted network access in the sandbox: {2}",
             explanation,
             goal,
             requestAllowNetworkReason || ( localize(
-                14698,
+                15351,
                 "The model indicated that this sandboxed command needs unrestricted network access."
             ))
-        )))) : ( new MarkdownString(( localize(14699, "Explanation: {0}\n\nGoal: {1}", explanation, goal))));
+        )))) : ( new MarkdownString(( localize(15352, "Explanation: {0}\n\nGoal: {1}", explanation, goal))));
         const confirmationMessages = shouldShowConfirmation ? {
             title: confirmationTitle,
             message: confirmationMessage,
@@ -1076,14 +1082,14 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         const rawDisplayCommand = toolSpecificData.commandLine.forDisplay ?? toolSpecificData.commandLine.toolEdited ?? toolSpecificData.commandLine.original;
         const displayCommand = rawDisplayCommand.length > 80 ? rawDisplayCommand.substring(0, 77) + "..." : rawDisplayCommand;
         const invocationMessage = toolSpecificData.commandLine.isSandboxWrapped ? ( new MarkdownString(( localize(
-            14700,
+            15353,
             "Running `{0}` in sandbox",
             escapeMarkdownSyntaxTokens(displayCommand)
-        )))) : ( new MarkdownString(( localize(14701, "Running `{0}`", escapeMarkdownSyntaxTokens(displayCommand)))));
+        )))) : ( new MarkdownString(( localize(15354, "Running `{0}`", escapeMarkdownSyntaxTokens(displayCommand)))));
         return {
             invocationMessage,
             icon: toolSpecificData.commandLine.isSandboxWrapped ? Codicon.terminalSecure : Codicon.terminal,
-            confirmationMessages: sandboxConfirmationMessageForMissingDeps ?? confirmationMessages,
+            confirmationMessages: sandboxPrerequisiteConfirmation ?? confirmationMessages,
             toolSpecificData
         };
     }
@@ -1092,7 +1098,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             return `\`${blockedDomains[0]}\``;
         }
         return localize(
-            14702,
+            15355,
             "`{0}` and {1} more domains",
             blockedDomains[0],
             blockedDomains.length - 1
@@ -1102,13 +1108,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         if (deniedDomains.length === blockedDomains.length && deniedDomains.length > 0) {
             if (blockedDomains.length === 1) {
                 return localize(
-                    14703,
+                    15356,
                     "This command accesses {0}, which is blocked by chat.agent.deniedNetworkDomains.",
                     blockedDomains[0]
                 );
             }
             return localize(
-                14704,
+                15357,
                 "This command accesses {0} and {1} more domains that are blocked by chat.agent.deniedNetworkDomains.",
                 blockedDomains[0],
                 blockedDomains.length - 1
@@ -1117,13 +1123,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         if (deniedDomains.length > 0) {
             if (blockedDomains.length === 1) {
                 return localize(
-                    14705,
+                    15358,
                     "This command accesses {0}, which is blocked by chat.agent.deniedNetworkDomains or not added to chat.agent.allowedNetworkDomains.",
                     blockedDomains[0]
                 );
             }
             return localize(
-                14706,
+                15359,
                 "This command accesses {0} and {1} more domains that are blocked by chat.agent.deniedNetworkDomains or not added to chat.agent.allowedNetworkDomains.",
                 blockedDomains[0],
                 blockedDomains.length - 1
@@ -1131,13 +1137,13 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         }
         if (blockedDomains.length === 1) {
             return localize(
-                14707,
+                15360,
                 "This command accesses {0}, which is not permitted by the current chat.agent.sandbox configuration.",
                 blockedDomains[0]
             );
         }
         return localize(
-            14708,
+            15361,
             "This command accesses {0} and {1} more domains that are not permitted by the current chat.agent.sandbox configuration.",
             blockedDomains[0],
             blockedDomains.length - 1
@@ -1219,9 +1225,6 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         riskAssessment,
         token
     ) {
-        if (retryKind === "unsandboxed" && this._autoApproveUnsandboxedCommands) {
-            return true;
-        }
         const chatModel = sessionResource && this._chatService.getSession(sessionResource);
         if (!(chatModel instanceof ChatModel)) {
             return false;
@@ -1254,11 +1257,11 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 resolve(value);
             };
             const confirmationMessage = retryKind === "allowNetwork" ? ( new MarkdownString(( localize(
-                14709,
+                15362,
                 "`{0}`",
                 escapeMarkdownSyntaxTokens(buildCommandDisplayText(command))
             )))) : ( new MarkdownString(( localize(
-                14710,
+                15363,
                 "`{0}`",
                 escapeMarkdownSyntaxTokens(buildCommandDisplayText(command))
             ))));
@@ -1266,8 +1269,8 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 this._getAutomaticSandboxRetryTitle(retryKind, shellType, blockedDomains),
                 confirmationMessage,
                 "",
-                ( localize(14711, "Allow")),
-                ( localize(14712, "Skip")),
+                ( localize(15364, "Allow")),
+                ( localize(15365, "Skip")),
                 async () => {
                     resolveOnce(true);
                     part.hide();
@@ -1293,22 +1296,22 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
     _getAutomaticSandboxRetryTitle(retryKind, shellType, blockedDomains) {
         if (retryKind === "allowNetwork") {
             return blockedDomains?.length ? ( new MarkdownString(( localize(
-                14713,
+                15366,
                 "Retry `{0}` command in the sandbox by allowing network access to {1}?",
                 shellType,
                 this._formatBlockedDomainsForTitle(blockedDomains)
             )))) : ( new MarkdownString(( localize(
-                14714,
+                15367,
                 "Retry `{0}` command in the sandbox by allowing network access?",
                 shellType
             ))));
         }
         return blockedDomains?.length ? ( new MarkdownString(( localize(
-            14715,
+            15368,
             "Run `{0}` command outside the sandbox to access {1}?",
             shellType,
             this._formatBlockedDomainsForTitle(blockedDomains)
-        )))) : ( new MarkdownString(( localize(14716, "Run `{0}` command outside the sandbox?", shellType))));
+        )))) : ( new MarkdownString(( localize(15369, "Run `{0}` command outside the sandbox?", shellType))));
     }
     _registerSensitiveInputElicitation(
         chatSessionResource,
@@ -1336,10 +1339,10 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 if (chatModel instanceof ChatModel) {
                     const request = chatModel.getRequests().at(-1);
                     if (request) {
-                        const infoPart = ( new ChatElicitationRequestPart(( new MarkdownString(( localize(14717, "Terminal command cancelled — sensitive input required")))), ( new MarkdownString(( localize(
-                            14718,
+                        const infoPart = ( new ChatElicitationRequestPart(( new MarkdownString(( localize(15370, "Terminal command cancelled — sensitive input required")))), ( new MarkdownString(( localize(
+                            15371,
                             "The terminal command was prompting for a password or other secret. Auto-approve / autopilot mode cannot safely supply secrets, so the command was cancelled. Run the command interactively if you want to provide the secret."
-                        )))), "", ( localize(14719, "Dismiss")), "", async () => {
+                        )))), "", ( localize(15372, "Dismiss")), "", async () => {
                             infoPart.hide();
                             return ElicitationState.Accepted;
                         }, async () => {
@@ -1363,10 +1366,10 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             if (!request) {
                 return;
             }
-            const part = ( new ChatElicitationRequestPart(( new MarkdownString(( localize(14720, "Terminal is waiting for sensitive input")))), ( new MarkdownString(( localize(
-                14721,
+            const part = ( new ChatElicitationRequestPart(( new MarkdownString(( localize(15373, "Terminal is waiting for sensitive input")))), ( new MarkdownString(( localize(
+                15374,
                 "The terminal command appears to be prompting for a password or other sensitive value. Focus the terminal to type it directly — secrets must not be sent through chat."
-            )))), "", ( localize(14722, "Focus Terminal")), ( localize(14723, "Cancel Command")), async () => {
+            )))), "", ( localize(15375, "Focus Terminal")), ( localize(15376, "Cancel Command")), async () => {
                 pending = undefined;
                 part.hide();
                 try {
@@ -1412,14 +1415,14 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         const progress = {
             kind: "externalToolInvocationUpdate",
             toolCallId,
-            toolName: ( localize(14671, "Run in Terminal")),
+            toolName: ( localize(15318, "Run in Terminal")),
             isComplete,
             invocationMessage: retryKind === "allowNetwork" ? ( new MarkdownString(( localize(
-                14724,
+                15377,
                 "Running `{0}` in the sandbox with unrestricted network access",
                 escapeMarkdownSyntaxTokens(displayCommand)
             )))) : ( new MarkdownString(( localize(
-                14725,
+                15378,
                 "Running `{0}` outside the sandbox",
                 escapeMarkdownSyntaxTokens(displayCommand)
             )))),
@@ -1545,6 +1548,22 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 }]
             };
         }
+        const sandboxPrerequisiteTerminalOptions = {
+            createTerminal: async () => this._terminalService.createTerminal({}),
+            focusTerminal: async terminal => {
+                this._terminalService.setActiveInstance(terminal);
+                await this._terminalService.revealTerminal(terminal, true);
+                terminal.focus();
+            }
+        };
+        if (toolSpecificData.sandboxPrerequisiteFailure) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: toolSpecificData.sandboxPrerequisiteFailure
+                }]
+            };
+        }
         const isSandboxAllowNetworkEnabled = isSandboxEnabled && (await this._terminalSandboxService.isSandboxAllowNetworkEnabled());
         if (this._shouldRejectAllowNetworkRequest(isSandboxEnabled, isSandboxAllowNetworkEnabled, args)) {
             const message = this._getAllowNetworkRequestDisabledMessage();
@@ -1570,20 +1589,18 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 const sessionResource = invocation.context.sessionResource;
                 const {
                     exitCode
-                } = await this._terminalSandboxService.installMissingSandboxDependencies(toolSpecificData.missingSandboxDependencies, sessionResource, token, {
-                    createTerminal: async () => this._terminalService.createTerminal({}),
-                    focusTerminal: async terminal => {
-                        this._terminalService.setActiveInstance(terminal);
-                        await this._terminalService.revealTerminal(terminal, true);
-                        terminal.focus();
-                    }
-                });
+                } = await this._terminalSandboxService.installMissingSandboxDependencies(
+                    toolSpecificData.missingSandboxDependencies,
+                    sessionResource,
+                    token,
+                    sandboxPrerequisiteTerminalOptions
+                );
                 if (exitCode !== undefined && exitCode !== 0) {
                     return {
                         content: [{
                             kind: "text",
                             value: ( localize(
-                                14726,
+                                15379,
                                 "Sandbox dependency installation failed (exit code {0}). The command was not executed.",
                                 exitCode
                             ))
@@ -1595,12 +1612,30 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                         content: [{
                             kind: "text",
                             value: ( localize(
-                                14727,
+                                15380,
                                 "Could not determine whether sandbox dependency installation succeeded. The command was not executed."
                             ))
                         }]
                     };
                 }
+                const refreshedPrereqs = await this._terminalSandboxService.checkForSandboxingPrereqs(true, sandboxPrecheckInputs);
+                if (refreshedPrereqs.failedCheck !== undefined) {
+                    return {
+                        content: [{
+                            kind: "text",
+                            value: refreshedPrereqs.failedCheck === TerminalSandboxPrerequisiteCheck.Bubblewrap && refreshedPrereqs.remediations?.length ? ( localize(
+                                15381,
+                                "Sandbox dependencies were installed, but bubblewrap cannot create the required sandbox namespace. Run the command again to choose an available repair option."
+                            )) : refreshedPrereqs.failedCheck === TerminalSandboxPrerequisiteCheck.Bubblewrap ? ( localize(
+                                15382,
+                                "Sandbox dependencies were installed, but bubblewrap cannot create the required sandbox namespace on this system. The command was not executed."
+                            )) : ( localize(
+                                15383,
+                                "Sandbox prerequisites are still not satisfied after installation. The command was not executed."
+                            ))
+                        }]
+                    };
+                }
                 this._logService.info(
                     "RunInTerminalTool: Sandbox dependency installation succeeded, proceeding with command execution"
                 );
@@ -1609,11 +1644,60 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 return {
                     content: [{
                         kind: "text",
-                        value: ( localize(14728, "Sandbox dependency installation was cancelled by the user."))
+                        value: ( localize(15384, "Sandbox dependency installation was cancelled by the user."))
                     }]
                 };
             }
         }
+        if (toolSpecificData.sandboxRemediations?.length) {
+            const selectedRemediation = invocation.selectedCustomButton;
+            if (!selectedRemediation || !toolSpecificData.sandboxRemediations.includes(selectedRemediation)) {
+                return {
+                    content: [{
+                        kind: "text",
+                        value: ( localize(15385, "Bubblewrap sandbox repair was cancelled by the user."))
+                    }]
+                };
+            }
+            const {
+                exitCode
+            } = await this._terminalSandboxService.runSandboxRemediation(
+                selectedRemediation,
+                invocation.context.sessionResource,
+                token,
+                sandboxPrerequisiteTerminalOptions
+            );
+            if (exitCode !== 0) {
+                return {
+                    content: [{
+                        kind: "text",
+                        value: exitCode === undefined ? ( localize(
+                            15386,
+                            "Could not determine whether the bubblewrap repair succeeded. The command was not executed."
+                        )) : ( localize(
+                            15387,
+                            "Bubblewrap repair failed (exit code {0}). The command was not executed.",
+                            exitCode
+                        ))
+                    }]
+                };
+            }
+            const refreshedPrereqs = await this._terminalSandboxService.checkForSandboxingPrereqs(true, sandboxPrecheckInputs);
+            if (refreshedPrereqs.failedCheck !== undefined) {
+                return {
+                    content: [{
+                        kind: "text",
+                        value: ( localize(
+                            15388,
+                            "Bubblewrap still cannot create the required sandbox namespace after remediation. The command was not executed."
+                        ))
+                    }]
+                };
+            }
+            this._logService.info(
+                "RunInTerminalTool: Bubblewrap remediation succeeded, proceeding with command execution"
+            );
+        }
         const executionOptions = this._resolveExecutionOptions(args);
         this._logService.debug(`RunInTerminalTool: Invoking with options ${JSON.stringify(args)}`);
         let toolResultMessage;
@@ -1639,13 +1723,35 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         if (token.isCancellationRequested) {
             throw ( new CancellationError());
         }
+        if (didSandboxWrapCommand) {
+            const deniedAccess = await this._getDeniedSandboxFileAccess(args.requestFileValidationCheck, sandboxPrecheckInputs);
+            if (deniedAccess.length > 0) {
+                const message = this._buildSandboxFileAccessDeniedMessage(deniedAccess);
+                return {
+                    toolResultError: message,
+                    toolResultDetails: {
+                        input: args.command,
+                        output: [{
+                            type: "embed",
+                            isText: true,
+                            value: message
+                        }],
+                        isError: true
+                    },
+                    content: [{
+                        kind: "text",
+                        value: message
+                    }]
+                };
+            }
+        }
         let error;
         const automaticUnsandboxRetryReason = ( localize(
-            14729,
+            15389,
             "The sandboxed execution output indicated the sandbox blocked the command."
         ));
         const automaticAllowNetworkRetryReason = ( localize(
-            14730,
+            15390,
             "The sandboxed execution output indicated the sandbox blocked required network access."
         ));
         const isNewSession = !executionOptions.persistentSession && !( this._sessionTerminalAssociations.has(chatSessionResource));
@@ -1847,7 +1953,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 if (timeoutRacePromise) {
                     raceCandidates.push(timeoutRacePromise);
                 }
-                const idleSilenceMs = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdleSilenceTimeoutMs) ?? 60000;
+                const idleSilenceMs = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdleSilenceTimeoutMs) ?? DEFAULT_IDLE_SILENCE_TIMEOUT_MS;
                 if (idleSilenceMs > 0) {
                     const idleSilenceDeferred = ( new DeferredPromise());
                     const idleSilenceScheduler = raceCleanup.add(( new RunOnceScheduler(() => idleSilenceDeferred.complete({
@@ -2158,7 +2264,8 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         if (outputAnalyzerMessage) {
             resultText.push(`${outputAnalyzerMessage}\n`);
         }
-        resultText.push(terminalResult);
+        const processedOutput = await this._largeOutputFileWriter.processOutput(terminalResult);
+        resultText.push(processedOutput);
         const isError = exitCode !== undefined && exitCode !== 0;
         const endCwd = await toolTerminal.instance.getCwdResource();
         const imageContent = await this._extractImagesFromOutput(terminalResult, endCwd);
@@ -2459,18 +2566,28 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
         if (!terminalsToDispose || terminalsToDispose.size === 0) {
             return;
         }
+        const shouldPreserveTerminalsForOutputLocation = this._configurationService.getValue(TerminalChatAgentToolsSettingId.OutputLocation) === "terminal";
         this._logService.debug(
             `RunInTerminalTool: Cleaning up ${terminalsToDispose.size} terminal(s) for ended chat session ${chatSessionResource}`
         );
         this._sessionTerminalAssociations.delete(chatSessionResource);
         this._sessionTerminalInstances.delete(chatSessionResource);
         for (const terminal of terminalsToDispose) {
+            if (this._terminalService.foregroundInstances.includes(terminal) || shouldPreserveTerminalsForOutputLocation) {
+                this._logService.debug(
+                    `RunInTerminalTool: Skipping disposal of preserved terminal ${terminal.instanceId} for session ${chatSessionResource}`
+                );
+                continue;
+            }
             this._terminalsBeingDisposedBySessionCleanup.add(terminal);
             terminal.dispose();
         }
         const terminalToRemove = [];
         for (const [termId, execution] of RunInTerminalTool_1._activeExecutions.entries()) {
             if (( terminalsToDispose.has(execution.instance))) {
+                if (this._terminalService.foregroundInstances.includes(execution.instance) || shouldPreserveTerminalsForOutputLocation) {
+                    continue;
+                }
                 execution.dispose();
                 terminalToRemove.push(termId);
             }
@@ -2642,7 +2759,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                     ...sendOptions,
                     queue: ChatRequestQueueKind.Steering,
                     isSystemInitiated: true,
-                    systemInitiatedLabel: ( localize(14731, "{0} may need input", commandDisplay)),
+                    systemInitiatedLabel: ( localize(15391, "{0} may need input", commandDisplay)),
                     terminalExecutionId: termId
                 }).catch(e => {
                     this._logService.warn(
@@ -2671,7 +2788,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             }
             disposeNotification();
             const exitCode = command.exitCode;
-            const exitCodeText = exitCode !== undefined ? ` with exit code ${exitCode}` : "";
+            const exitCodeText = exitCode !== undefined && exitCode !== 0 ? ` with exit code ${exitCode}` : "";
             const currentOutput = execution.getOutput();
             const isUserVisible = this._terminalService.foregroundInstances.includes(terminalInstance);
             const message = isUserVisible ? `[Terminal ${termId} notification: command completed${exitCodeText}. Use send_to_terminal to send another command or kill_terminal to stop it.]\nTerminal output:\n${currentOutput}` : `[Terminal ${termId} notification: command completed${exitCodeText}. The terminal has been cleaned up.]\nTerminal output:\n${currentOutput}`;
@@ -2682,7 +2799,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 ...sendOptions,
                 queue: ChatRequestQueueKind.Steering,
                 isSystemInitiated: true,
-                systemInitiatedLabel: ( localize(14732, "{0} completed", commandDisplay)),
+                systemInitiatedLabel: ( localize(15392, "{0} completed", commandDisplay)),
                 terminalExecutionId: termId
             }).catch(e => {
                 this._logService.warn(
@@ -2726,7 +2843,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
             }
             const currentOutput = executionForDisposal?.getOutput() ?? "";
             const exitCode = terminalInstance.exitCode;
-            const exitCodeText = exitCode !== undefined ? ` with exit code ${exitCode}` : "";
+            const exitCodeText = exitCode !== undefined && exitCode !== 0 ? ` with exit code ${exitCode}` : "";
             disposeNotification();
             const message = `[Terminal ${termId} notification: terminal exited${exitCodeText}. The terminal process ended before the command could complete normally; further commands cannot be sent to this terminal ID.]\nTerminal output:\n${currentOutput}`;
             this._logService.debug(
@@ -2736,7 +2853,7 @@ let RunInTerminalTool = class RunInTerminalTool extends Disposable {
                 ...sendOptions,
                 queue: ChatRequestQueueKind.Steering,
                 isSystemInitiated: true,
-                systemInitiatedLabel: ( localize(14733, "{0} terminal exited", commandDisplay)),
+                systemInitiatedLabel: ( localize(15393, "{0} terminal exited", commandDisplay)),
                 terminalExecutionId: termId
             }).catch(e => {
                 this._logService.warn(
@@ -2884,14 +3001,24 @@ class RestoredTerminalExecution extends Disposable {
     }
 }
 let TerminalProfileFetcher = class TerminalProfileFetcher {
+    static {
+        TerminalProfileFetcher_1 = this;
+    }
+    static {
+        this._posixShellFallbacks = ["/bin/bash", "/usr/bin/bash", "/bin/sh"];
+    }
     constructor(
         _configurationService,
         _terminalProfileResolverService,
-        _remoteAgentService
+        _remoteAgentService,
+        _fileService,
+        _logService
     ) {
         this._configurationService = _configurationService;
         this._terminalProfileResolverService = _terminalProfileResolverService;
         this._remoteAgentService = _remoteAgentService;
+        this._fileService = _fileService;
+        this._logService = _logService;
         this.osBackend = this._remoteAgentService.getEnvironment().then(remoteEnv => remoteEnv?.os ?? OS);
     }
     async getCopilotProfile() {
@@ -2918,11 +3045,48 @@ let TerminalProfileFetcher = class TerminalProfileFetcher {
                 profileName: "bash"
             };
         }
+        if (os !== OperatingSystem.Windows) {
+            const shellExists = await this._shellExists(defaultProfile.path);
+            if (!shellExists) {
+                const fallbackPath = await this._findFallbackShell();
+                if (fallbackPath) {
+                    this._logService.warn(
+                        `TerminalProfileFetcher: resolved shell "${defaultProfile.path}" does not exist, falling back to "${fallbackPath}"`
+                    );
+                    return {
+                        ...defaultProfile,
+                        path: fallbackPath,
+                        profileName: basename(fallbackPath),
+                        icon: undefined
+                    };
+                }
+            }
+        }
         return {
             ...defaultProfile,
             icon: undefined
         };
     }
+    async _shellExists(shellPath) {
+        try {
+            const remoteAuthority = this._remoteAgentService.getConnection()?.remoteAuthority;
+            const resource = remoteAuthority ? URI.file(shellPath).with({
+                scheme: "vscode-remote",
+                authority: remoteAuthority
+            }) : URI.file(shellPath);
+            return await this._fileService.exists(resource);
+        } catch {
+            return false;
+        }
+    }
+    async _findFallbackShell() {
+        for (const candidate of TerminalProfileFetcher_1._posixShellFallbacks) {
+            if (await this._shellExists(candidate)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
     async getCopilotShell() {
         return (await this.getCopilotProfile()).path;
     }
@@ -2956,6 +3120,6 @@ let TerminalProfileFetcher = class TerminalProfileFetcher {
         return false;
     }
 };
-TerminalProfileFetcher = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ITerminalProfileResolverService)), ( __param(2, IRemoteAgentService))], TerminalProfileFetcher));
+TerminalProfileFetcher = TerminalProfileFetcher_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ITerminalProfileResolverService)), ( __param(2, IRemoteAgentService)), ( __param(3, IFileService)), ( __param(4, ITerminalLogService))], TerminalProfileFetcher));
 
-export { RunInTerminalTool, TerminalProfileFetcher, buildCompletionNotificationCommand, createRunInTerminalToolData, shouldAutomaticallyRetryAllowNetworkInSandboxed, shouldAutomaticallyRetryUnsandboxed };
+export { RunInTerminalTool, TerminalProfileFetcher, buildCompletionNotificationCommand, createRunInTerminalToolData, createSandboxLines, createSandboxProperties, shouldAutomaticallyRetryAllowNetworkInSandboxed, shouldAutomaticallyRetryUnsandboxed };