@codingame/monaco-vscode-workbench-service-override 37.6.1 → 38.0.0

package/vscode/src/vs/sessions/contrib/terminal/browser/agentHostSessionTaskRunner.d.ts

@@ -6,7 +6,7 @@ import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workben
 import { ISessionTaskRunner } from "../../chat/browser/sessionTaskRunner.js";
 import { ITaskEntry } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionsTasksService";
 import { ISessionsTasksService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionsTasksService.service";
-import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { IChat, ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
 import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
 import { IConfigurationResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service";
 /**
@@ -25,9 +25,27 @@ export declare class AgentHostSessionTaskRunner implements ISessionTaskRunner {
     private readonly _logService;
     readonly id = "agentHost";
     readonly priority = 100;
+    /** The terminal that last ran each task, keyed by host, working directory, and task label. */
+    private readonly _taskTerminals;
     constructor(_agentHostTerminalService: IAgentHostTerminalService, _sessionsProvidersService: ISessionsProvidersService, _sessionsTasksService: ISessionsTasksService, _configurationResolverService: IConfigurationResolverService, _terminalService: ITerminalService, _terminalGroupService: ITerminalGroupService, _logService: ILogService);
     canRun(session: ISession): boolean;
-    runTask(task: ITaskEntry, session: ISession): Promise<IDisposable | undefined>;
+    runTask(task: ITaskEntry, session: ISession, chat?: IChat): Promise<IDisposable | undefined>;
+    /**
+     * Returns the terminal that last ran the task identified by {@link key}
+     * when it can run the task again, mirroring how the workbench task system
+     * reuses task terminals. A terminal is only reused when it is known to be
+     * idle, so that the command is never typed into a still running process,
+     * when the shell is still in the directory the terminal started in, so
+     * that the command runs from the task's working directory, and when it is
+     * not hidden in the background (e.g. after switching sessions), since only
+     * foreground terminals can be activated.
+     */
+    private _getReusableTerminal;
+    /**
+     * Reads the task's presentation options, falling back to the legacy
+     * `terminal` property like the workbench task configuration does.
+     */
+    private _getPresentation;
     private _getAddress;
     private _isSessionRemoteHostAvailable;
     private _getCwd;

package/vscode/src/vs/sessions/contrib/terminal/browser/agentHostSessionTaskRunner.js

@@ -2,7 +2,8 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { OS } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { OS, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { AGENT_HOST_SCHEME, fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
@@ -18,6 +19,14 @@ import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/res
 
 const LOG_PREFIX = "[AgentHostSessionTaskRunner]";
 const LOCAL_AGENT_HOST_ADDRESS = "__local__";
+function normalizeCwd(cwd) {
+    return cwd.replace(/(?<=[^\\/:])[\\/]+$/, "");
+}
+function isEqualCwd(a, b, ignoreCase) {
+    a = normalizeCwd(a);
+    b = normalizeCwd(b);
+    return ignoreCase ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
 let AgentHostSessionTaskRunner = class AgentHostSessionTaskRunner {
     constructor(
         _agentHostTerminalService,
@@ -37,11 +46,12 @@ let AgentHostSessionTaskRunner = class AgentHostSessionTaskRunner {
         this._logService = _logService;
         this.id = "agentHost";
         this.priority = 100;
+        this._taskTerminals = ( new Map());
     }
     canRun(session) {
         return this._isSessionRemoteHostAvailable(session) && this._getAddress(session) !== undefined;
     }
-    async runTask(task, session) {
+    async runTask(task, session, chat) {
         if (!this._isSessionRemoteHostAvailable(session)) {
             return undefined;
         }
@@ -49,12 +59,13 @@ let AgentHostSessionTaskRunner = class AgentHostSessionTaskRunner {
         if (!address) {
             return undefined;
         }
-        const allTasks = await this._sessionsTasksService.getAllTasks(session);
+        const owner = chat ?? session;
+        const allTasks = await this._sessionsTasksService.getAllTasks(owner);
         const byLabel = ( new Map());
         for (const entry of allTasks) {
             byLabel.set(entry.task.label, entry.task);
         }
-        const cwd = this._getCwd(session);
+        const cwd = this._getCwd(owner);
         const command = await resolveTaskCommand(task, {
             targetOS: address === LOCAL_AGENT_HOST_ADDRESS ? osToTaskTargetOS(OS) : undefined,
             lookup: label => byLabel.get(label),
@@ -69,23 +80,95 @@ let AgentHostSessionTaskRunner = class AgentHostSessionTaskRunner {
         if (!this._isSessionRemoteHostAvailable(session)) {
             return undefined;
         }
-        const instance = await this._agentHostTerminalService.createTerminalForEntry(address, {
-            cwd,
-            name: ( localize(5021, "Task: {0}", task.label))
-        });
-        if (!instance) {
-            this._logService.warn(
-                `${LOG_PREFIX} Failed to create terminal for task '${task.label}' on '${address}'.`
-            );
-            return undefined;
+        const terminalKey = JSON.stringify([address, cwd?.toString(), task.label]);
+        const presentation = this._getPresentation(task);
+        const shouldReuse = !(typeof presentation?.panel === "string" && presentation.panel.toLowerCase() === "new");
+        let taskTerminal = shouldReuse ? this._getReusableTerminal(terminalKey, address) : undefined;
+        const isReused = !!taskTerminal;
+        if (!taskTerminal) {
+            const instance = await this._agentHostTerminalService.createTerminalForEntry(address, {
+                cwd,
+                name: ( localize(6311, "Task: {0}", task.label))
+            });
+            if (!instance) {
+                this._logService.warn(
+                    `${LOG_PREFIX} Failed to create terminal for task '${task.label}' on '${address}'.`
+                );
+                return undefined;
+            }
+            taskTerminal = {
+                instance,
+                isLaunching: false,
+                executionId: 0
+            };
+            if (shouldReuse) {
+                this._taskTerminals.set(terminalKey, taskTerminal);
+                instance.store.add(instance.onDisposed(() => {
+                    if (this._taskTerminals.get(terminalKey) === taskTerminal) {
+                        this._taskTerminals.delete(terminalKey);
+                    }
+                }));
+            }
+        }
+        const {
+            instance
+        } = taskTerminal;
+        taskTerminal.isLaunching = true;
+        const executionId = ++taskTerminal.executionId;
+        try {
+            this._terminalService.setActiveInstance(instance);
+            await this._terminalGroupService.showPanel(true);
+            if (isReused) {
+                await instance.sendText("\u0003",  false);
+                await timeout(100);
+            }
+            if (isReused && presentation?.clear === true) {
+                instance.clearBuffer();
+            }
+            this._agentHostTerminalService.markCommandPending(instance);
+            await instance.sendText(command,  true);
+        } finally {
+            taskTerminal.isLaunching = false;
         }
-        this._terminalService.setActiveInstance(instance);
-        await this._terminalGroupService.showPanel(true);
-        await instance.sendText(command,  true);
         return toDisposable(() => {
-            instance.dispose(TerminalExitReason.User);
+            if (taskTerminal.executionId === executionId) {
+                instance.dispose(TerminalExitReason.User);
+            }
         });
     }
+    _getReusableTerminal(key, address) {
+        const taskTerminal = this._taskTerminals.get(key);
+        if (!taskTerminal) {
+            return undefined;
+        }
+        const {
+            instance
+        } = taskTerminal;
+        if (instance.isDisposed) {
+            this._taskTerminals.delete(key);
+            return undefined;
+        }
+        if (taskTerminal.isLaunching || this._agentHostTerminalService.isCommandExecuting(instance) !== false) {
+            return undefined;
+        }
+        if (!this._terminalService.foregroundInstances.includes(instance)) {
+            return undefined;
+        }
+        const terminalCwd = this._agentHostTerminalService.getCwd(instance);
+        if (!terminalCwd) {
+            return undefined;
+        }
+        const ignoreCase = address === LOCAL_AGENT_HOST_ADDRESS ? OS !== OperatingSystem.Linux : /^[a-zA-Z]:[\\/]/.test(terminalCwd.initial);
+        return isEqualCwd(terminalCwd.current, terminalCwd.initial, ignoreCase) ? taskTerminal : undefined;
+    }
+    _getPresentation(task) {
+        for (const value of [task.presentation, task.terminal]) {
+            if (typeof value === "object" && value !== null) {
+                return value;
+            }
+        }
+        return undefined;
+    }
     _getAddress(session) {
         const provider = this._sessionsProvidersService.getProvider(session.providerId);
         if (!provider || !isAgentHostProvider(provider)) {

package/vscode/src/vs/sessions/contrib/terminal/browser/sessionsTerminalContribution.d.ts

@@ -6,7 +6,7 @@ import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/w
 import { IAgentHostTerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/agentHostTerminalService.service";
 import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
-import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
+import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService";
 import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
 import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
 import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
@@ -33,8 +33,10 @@ export declare class SessionsTerminalContribution extends Disposable implements
     private readonly _terminalProfileService;
     static readonly ID = "workbench.contrib.sessionsTerminal";
     private _activeKey;
+    private _activeAgentHostAddress;
     private _activeSessionId;
     private readonly _sessionTerminals;
+    private readonly _trackedTerminalScopes;
     private readonly _standaloneTerminalIds;
     /** In-flight terminal work for drafts, retained only until each operation settles. */
     private readonly _pendingTerminalOperations;
@@ -60,6 +62,7 @@ export declare class SessionsTerminalContribution extends Disposable implements
      */
     ensureTerminal(cwd: URI, focus: boolean, session?: ISession): Promise<ITerminalInstance[]>;
     private _ensureTerminal;
+    private _filterTerminalsForScope;
     private _isTerminalOperationCancelled;
     private _isSessionRemoteHostAvailable;
     private _getTerminalOperationGeneration;
@@ -96,6 +99,7 @@ export declare class SessionsTerminalContribution extends Disposable implements
      * session has no tracked terminals yet, falls back to initial cwd matching
      * for compatibility with restored terminals from previous sessions.
      */
+    private _terminalMatchesScope;
     private _updateTerminalVisibility;
     /**
      * Disposes (kills) terminals associated with the given session id. Used

package/vscode/src/vs/sessions/contrib/terminal/browser/sessionsTerminalContribution.js

@@ -7,7 +7,7 @@ import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/netw
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { Action2, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
-import { AGENT_HOST_SCHEME, fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { fromAgentHostUri, AGENT_HOST_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
@@ -15,7 +15,7 @@ import { registerWorkbenchContribution2, WorkbenchPhase, getWorkbenchContributio
 import { IAgentHostTerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/agentHostTerminalService.service';
 import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
 import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
-import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService';
 import { LOCAL_AGENT_HOST_PROVIDER_ID, isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
 import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
 import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
@@ -25,12 +25,25 @@ import { ISessionTaskRunnerRegistry } from '@codingame/monaco-vscode-api/vscode/
 import { AgentHostSessionTaskRunner } from './agentHostSessionTaskRunner.js';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/platform/path/common/pathService.service';
 
+const LOCAL_AGENT_HOST_ADDRESS = "__local__";
 function getSessionTerminalInfo(session, reader) {
     if (!session) {
         return undefined;
     }
-    const workspace = reader ? session.workspace.read(reader) : session.workspace.get();
+    const workspace = session.workspace.get();
+    return getWorkspaceTerminalInfo(workspace);
+}
+function getActiveSessionTerminalInfo(session, reader) {
+    if (!session) {
+        return undefined;
+    }
+    const activeChat = reader ? session.activeChat.read(reader) : session.activeChat.get();
+    const workspace = reader ? activeChat.workspace.read(reader) : activeChat.workspace.get();
+    return getWorkspaceTerminalInfo(workspace);
+}
+function getWorkspaceTerminalInfo(workspace) {
     if (workspace?.isVirtualWorkspace !== false) {
         return undefined;
     }
@@ -39,9 +52,13 @@ function getSessionTerminalInfo(session, reader) {
     if (!cwd) {
         return undefined;
     }
+    const terminalCwd = fromAgentHostUri(cwd);
+    if (terminalCwd.scheme !== Schemas.file && terminalCwd.scheme !== Schemas.vscodeRemote) {
+        return undefined;
+    }
     if (cwd.scheme === AGENT_HOST_SCHEME) {
         return {
-            cwd: fromAgentHostUri(cwd),
+            cwd: terminalCwd,
             agentHostCwd: cwd
         };
     }
@@ -79,6 +96,7 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
         this._fileService = _fileService;
         this._terminalProfileService = _terminalProfileService;
         this._sessionTerminals = ( new Map());
+        this._trackedTerminalScopes = ( new Map());
         this._standaloneTerminalIds = ( new Set());
         this._pendingTerminalOperations = ( new Map());
         this._sessionTerminalGenerations = ( new Map());
@@ -116,7 +134,7 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
                 this._agentHostTerminalService.setDefaultCwd(undefined);
                 return;
             }
-            const info = getSessionTerminalInfo(session, reader);
+            const info = getActiveSessionTerminalInfo(session, reader);
             this._agentHostTerminalService.setDefaultCwd(info?.cwd);
         }));
         this._register(autorun(reader => {
@@ -136,11 +154,13 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
                 }
                 if (!preserveActiveTerminalState) {
                     this._activeKey = undefined;
+                    this._activeAgentHostAddress = undefined;
                     this._activeSessionId = undefined;
                 }
                 return;
             }
-            this._onActiveSessionChanged(session);
+            const info = getActiveSessionTerminalInfo(session, reader);
+            this._onActiveSessionChanged(session, info);
         }));
         this._register(this._sessionsManagementService.onDidReplaceNewDraftSession((
             {
@@ -233,16 +253,20 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
             this._endTerminalOperation(session.sessionId);
         }
     }
-    async _ensureTerminal(cwd, focus, session, generation) {
+    async _ensureTerminal(cwd, focus, session, generation, requireCwdMatch = false) {
         if (session && this._isTerminalOperationCancelled(session, generation)) {
             return [];
         }
         const key = cwd.fsPath.toLowerCase();
+        const agentHostAddress = this._getSessionAgentHostAddress(session);
         let existing = session ? this._getTrackedTerminalsForSession(session.sessionId) : [];
+        if (requireCwdMatch && existing.length > 0) {
+            existing = await this._filterTerminalsForScope(existing, key, agentHostAddress);
+        }
         if (existing.length === 0) {
-            existing = await this._findTerminalsForKey(key, {
+            existing = await this._filterTerminalsForScope(await this._findTerminalsForKey(key, {
                 excludeTracked: !!session
-            });
+            }), key, agentHostAddress);
             if (session && this._isTerminalOperationCancelled(session, generation)) {
                 return [];
             }
@@ -272,13 +296,26 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
             }
         }
         if (session) {
-            this._trackTerminalsForSession(session.sessionId, existing);
+            this._trackTerminalsForSession(session.sessionId, existing, {
+                sessionId: session.sessionId,
+                key,
+                agentHostAddress
+            });
         }
         if (focus) {
             await this._terminalService.focusActiveInstance();
         }
         return existing;
     }
+    async _filterTerminalsForScope(instances, key, agentHostAddress) {
+        const result = [];
+        for (const instance of instances) {
+            if (await this._terminalMatchesScope(instance, key, agentHostAddress)) {
+                result.push(instance);
+            }
+        }
+        return result;
+    }
     _isTerminalOperationCancelled(
         session,
         generation = this._getTerminalOperationGeneration(session.sessionId)
@@ -319,31 +356,43 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
         if (!provider || !isAgentHostProvider(provider)) {
             return undefined;
         }
-        return provider.remoteAddress ?? "__local__";
+        return provider.remoteAddress ?? LOCAL_AGENT_HOST_ADDRESS;
     }
-    async _onActiveSessionChanged(session) {
+    async _onActiveSessionChanged(session, info = getActiveSessionTerminalInfo(session)) {
         if (!session) {
             return;
         }
+        if (!info && session.activeChat.get().workspace.get()?.isVirtualWorkspace === false) {
+            this._logService.trace(
+                `[SessionsTerminal] Waiting for a filesystem working directory for ${session.sessionId}`
+            );
+            return;
+        }
         this._beginTerminalOperation(session.sessionId);
         try {
             const generation = this._getTerminalOperationGeneration(session.sessionId);
-            const info = getSessionTerminalInfo(session);
             if (info?.cwd && !info.agentHostCwd && info.cwd.scheme === Schemas.file && !(await this._fileService.exists(info.cwd))) {
                 return;
             }
             const targetPath = info?.cwd ?? (await this._pathService.userHome());
             const targetKey = targetPath.fsPath.toLowerCase();
-            if (this._activeKey === targetKey && this._activeSessionId === session.sessionId) {
+            const targetAgentHostAddress = this._getSessionAgentHostAddress(session);
+            if (this._activeKey === targetKey && this._activeAgentHostAddress === targetAgentHostAddress && this._activeSessionId === session.sessionId) {
                 return;
             }
             this._activeKey = targetKey;
+            this._activeAgentHostAddress = targetAgentHostAddress;
             this._activeSessionId = session.sessionId;
-            const instances = await this._ensureTerminal(targetPath, false, session, generation);
-            if (this._activeKey !== targetKey || this._activeSessionId !== session.sessionId) {
+            const instances = await this._ensureTerminal(targetPath, false, session, generation, true);
+            if (this._activeKey !== targetKey || this._activeAgentHostAddress !== targetAgentHostAddress || this._activeSessionId !== session.sessionId) {
                 return;
             }
-            await this._updateTerminalVisibility(session, targetKey, instances.map(instance => instance.instanceId));
+            await this._updateTerminalVisibility(
+                session,
+                targetKey,
+                targetAgentHostAddress,
+                instances.map(instance => instance.instanceId)
+            );
         } finally {
             this._endTerminalOperation(session.sessionId);
         }
@@ -366,7 +415,7 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
         }
         return result;
     }
-    _trackTerminalsForSession(sessionId, instances) {
+    _trackTerminalsForSession(sessionId, instances, scope) {
         if (instances.length === 0) {
             return;
         }
@@ -377,6 +426,9 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
         }
         for (const instance of instances) {
             terminalIds.add(instance.instanceId);
+            if (scope) {
+                this._trackedTerminalScopes.set(instance.instanceId, scope);
+            }
         }
     }
     _beginTerminalOperation(sessionId) {
@@ -420,6 +472,7 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
         const terminals = this._getTrackedTerminalsForSession(sessionId);
         for (const terminal of terminals) {
             this._standaloneTerminalIds.add(terminal.instanceId);
+            this._trackedTerminalScopes.delete(terminal.instanceId);
         }
         if (terminals.length > 0) {
             this._logService.trace(
@@ -470,6 +523,7 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
                 const instance = this._terminalService.getInstanceFromId(instanceId);
                 if (!instance || instance.isDisposed) {
                     terminalIds.delete(instanceId);
+                    this._trackedTerminalScopes.delete(instanceId);
                     if (terminalIds.size === 0) {
                         this._sessionTerminals.delete(sessionId);
                     }
@@ -483,6 +537,7 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
     _removeTerminalFromTrackedSessions(instanceId) {
         for (const [sessionId, terminalIds] of this._sessionTerminals) {
             terminalIds.delete(instanceId);
+            this._trackedTerminalScopes.delete(instanceId);
             if (terminalIds.size === 0) {
                 this._sessionTerminals.delete(sessionId);
             }
@@ -498,7 +553,31 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
         }
         return currentInstance;
     }
-    async _updateTerminalVisibility(activeSession, activeKey, forceForegroundTerminalIds) {
+    async _terminalMatchesScope(instance, key, agentHostAddress) {
+        const trackedScope = this._trackedTerminalScopes.get(instance.instanceId);
+        if (trackedScope) {
+            return trackedScope.key === key && trackedScope.agentHostAddress === agentHostAddress;
+        }
+        const instanceAgentHostAddress = this._agentHostTerminalService.getAgentHostAddress(instance);
+        if (instanceAgentHostAddress !== undefined) {
+            if (instanceAgentHostAddress !== agentHostAddress) {
+                return false;
+            }
+        } else if (instance.shellLaunchConfig.customPtyImplementation || (agentHostAddress !== undefined && agentHostAddress !== LOCAL_AGENT_HOST_ADDRESS)) {
+            return false;
+        }
+        try {
+            return (await instance.getInitialCwd()).toLowerCase() === key;
+        } catch {
+            return false;
+        }
+    }
+    async _updateTerminalVisibility(
+        activeSession,
+        activeKey,
+        activeAgentHostAddress,
+        forceForegroundTerminalIds
+    ) {
         const toShow = [];
         const toHide = [];
         const trackedTerminalIds = ( new Set(
@@ -508,21 +587,16 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
             if (instance.shellLaunchConfig.hideFromUser || ( this._standaloneTerminalIds.has(instance.instanceId))) {
                 continue;
             }
-            let cwd;
             const currentInstance = this._getAvailableTerminal(instance, "update terminal visibility");
             if (!currentInstance) {
                 continue;
             }
             const isForeground = this._terminalService.foregroundInstances.includes(currentInstance);
-            const isForceVisible = forceForegroundTerminalIds.includes(currentInstance.instanceId);
-            let belongsToActiveSession = ( trackedTerminalIds.has(currentInstance.instanceId));
+            const matchesActiveScope = await this._terminalMatchesScope(currentInstance, activeKey, activeAgentHostAddress);
+            const isForceVisible = forceForegroundTerminalIds.includes(currentInstance.instanceId) && matchesActiveScope;
+            let belongsToActiveSession = ( trackedTerminalIds.has(currentInstance.instanceId)) && matchesActiveScope;
             if (!belongsToActiveSession && !this._isTerminalTracked(currentInstance.instanceId)) {
-                try {
-                    cwd = (await currentInstance.getInitialCwd()).toLowerCase();
-                } catch {
-                    continue;
-                }
-                belongsToActiveSession = cwd === activeKey;
+                belongsToActiveSession = matchesActiveScope;
             }
             if ((belongsToActiveSession || isForceVisible) && !isForeground) {
                 toShow.push(currentInstance);
@@ -552,6 +626,9 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
             if (( this._standaloneTerminalIds.has(instance.instanceId))) {
                 continue;
             }
+            if (!(await this._terminalMatchesScope(instance, activeKey, activeAgentHostAddress))) {
+                continue;
+            }
             const cmdDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
             const lastCmd = cmdDetection?.commands.at(-1);
             if (lastCmd && lastCmd.timestamp > mostRecentTimestamp) {
@@ -641,6 +718,7 @@ let SessionsTerminalContribution = class SessionsTerminalContribution extends Di
             return;
         }
         this._activeKey = undefined;
+        this._activeAgentHostAddress = undefined;
         this._activeSessionId = undefined;
         await this._onActiveSessionChanged(activeSession);
     }
@@ -713,7 +791,7 @@ class DumpTerminalTrackingAction extends Action2 {
     constructor() {
         super({
             id: "agentSession.dumpTerminalTracking",
-            title: ( localize2(5022, "Dump Terminal Tracking")),
+            title: ( localize2(6312, "Dump Terminal Tracking")),
             f1: true
         });
     }
@@ -727,7 +805,7 @@ class ShowAllTerminalsAction extends Action2 {
     constructor() {
         super({
             id: "agentSession.showAllTerminals",
-            title: ( localize2(5023, "Show All Terminals")),
+            title: ( localize2(6313, "Show All Terminals")),
             f1: true
         });
     }

package/vscode/src/vs/sessions/contrib/workspace/browser/workspaceFolderManagement.d.ts

@@ -6,6 +6,7 @@ import { IWorkspaceEditingService } from "@codingame/monaco-vscode-api/vscode/vs
 import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
 import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
 import { IWorkspaceFolderLabelService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceFolderLabelService.service";
+import { IHistoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/history/common/history.service";
 export declare class WorkspaceFolderManagementContribution extends Disposable implements IWorkbenchContribution {
     private readonly sessionsService;
     private readonly uriIdentityService;
@@ -13,11 +14,12 @@ export declare class WorkspaceFolderManagementContribution extends Disposable im
     private readonly workspaceEditingService;
     private readonly workspaceTrustManagementService;
     private readonly workspaceFolderLabelService;
+    private readonly historyService;
     static readonly ID = "workbench.contrib.workspaceFolderManagement";
     private queue;
-    constructor(sessionsService: ISessionsService, uriIdentityService: IUriIdentityService, workspaceContextService: IWorkspaceContextService, workspaceEditingService: IWorkspaceEditingService, workspaceTrustManagementService: IWorkspaceTrustManagementService, workspaceFolderLabelService: IWorkspaceFolderLabelService);
-    private updateWorkspaceFoldersForSession;
-    private getActiveSessionFolderData;
+    constructor(sessionsService: ISessionsService, uriIdentityService: IUriIdentityService, workspaceContextService: IWorkspaceContextService, workspaceEditingService: IWorkspaceEditingService, workspaceTrustManagementService: IWorkspaceTrustManagementService, workspaceFolderLabelService: IWorkspaceFolderLabelService, historyService: IHistoryService);
+    private updateWorkspaceFolders;
+    private getWorkspaceFolderData;
     /**
      * Whether `uri` may be mounted as the workspace folder. A session that
      * requires workspace trust may only mount a trusted folder; anything else is