@codingame/monaco-vscode-workbench-service-override 37.3.3 → 37.3.4

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

@@ -0,0 +1,741 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+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 { 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';
+import { registerWorkbenchContribution2, WorkbenchPhase, getWorkbenchContribution } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+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 { 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';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { ITerminalProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service';
+import { ISessionTaskRunnerRegistry } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionTaskRunner.service';
+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';
+
+function getSessionTerminalInfo(session, reader) {
+    if (!session) {
+        return undefined;
+    }
+    const workspace = reader ? session.workspace.read(reader) : session.workspace.get();
+    if (workspace?.isVirtualWorkspace !== false) {
+        return undefined;
+    }
+    const folder = workspace.folders[0];
+    const cwd = folder?.workingDirectory;
+    if (!cwd) {
+        return undefined;
+    }
+    if (cwd.scheme === AGENT_HOST_SCHEME) {
+        return {
+            cwd: fromAgentHostUri(cwd),
+            agentHostCwd: cwd
+        };
+    }
+    return {
+        cwd
+    };
+}
+function getSessionWorktreeCwd(session) {
+    const worktree = session.workspace.get()?.folders[0]?.gitRepository?.workTreeUri;
+    return worktree?.scheme === AGENT_HOST_SCHEME ? undefined : worktree;
+}
+let SessionsTerminalContribution = class SessionsTerminalContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessionsTerminal";
+    }
+    constructor(
+        _sessionsManagementService,
+        _sessionsService,
+        _sessionsProvidersService,
+        _terminalService,
+        _agentHostTerminalService,
+        _logService,
+        _pathService,
+        _fileService,
+        _terminalProfileService
+    ) {
+        super();
+        this._sessionsManagementService = _sessionsManagementService;
+        this._sessionsService = _sessionsService;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._terminalService = _terminalService;
+        this._agentHostTerminalService = _agentHostTerminalService;
+        this._logService = _logService;
+        this._pathService = _pathService;
+        this._fileService = _fileService;
+        this._terminalProfileService = _terminalProfileService;
+        this._sessionTerminals = ( new Map());
+        this._standaloneTerminalIds = ( new Set());
+        this._pendingTerminalOperations = ( new Map());
+        this._sessionTerminalGenerations = ( new Map());
+        this._archivedSessionIds = ( new Set());
+        for (const session of this._sessionsManagementService.getSessions()) {
+            if (session.isArchived.get()) {
+                this._archivedSessionIds.add(session.sessionId);
+            }
+        }
+        const profileOverride = derived(reader => {
+            const session = this._sessionsService.activeSession.read(reader);
+            if (!session || session.providerId === LOCAL_AGENT_HOST_PROVIDER_ID) {
+                return;
+            }
+            const address = this._getSessionAgentHostAddress(session);
+            if (!address) {
+                return;
+            }
+            const profiles = this._agentHostTerminalService.profiles.read(reader);
+            return profiles.find(p => p.address === address) ?? this._agentHostTerminalService.getProfileForConnection(address);
+        });
+        this._register(autorun(reader => {
+            const profile = profileOverride.read(reader);
+            if (profile) {
+                reader.store.add(
+                    this._terminalProfileService.overrideDefaultProfile(profile.extensionIdentifier, profile.profileId)
+                );
+            }
+        }));
+        this._register(autorun(reader => {
+            const session = this._sessionsService.activeSession.read(reader);
+            const remoteConnectionStatus = session?.remoteConnectionStatus?.read(reader);
+            const remoteHostAvailable = remoteConnectionStatus === undefined || remoteConnectionStatus.kind === "connected";
+            if (session?.loading.read(reader) || session?.isArchived.read(reader) || session?.worktreePending?.read(reader) || !remoteHostAvailable) {
+                this._agentHostTerminalService.setDefaultCwd(undefined);
+                return;
+            }
+            const info = getSessionTerminalInfo(session, reader);
+            this._agentHostTerminalService.setDefaultCwd(info?.cwd);
+        }));
+        this._register(autorun(reader => {
+            const session = this._sessionsService.activeSession.read(reader);
+            const isArchived = session?.isArchived.read(reader);
+            const worktreePending = session?.worktreePending?.read(reader);
+            const remoteConnectionStatus = session?.remoteConnectionStatus?.read(reader);
+            const remoteHostAvailable = remoteConnectionStatus === undefined || remoteConnectionStatus.kind === "connected";
+            const remoteHostPermanentlyUnavailable = remoteConnectionStatus?.kind === "disconnected" || remoteConnectionStatus?.kind === "incompatible";
+            const preserveActiveTerminalState = !remoteHostPermanentlyUnavailable && !remoteHostAvailable && this._activeSessionId === session?.sessionId;
+            if (session && !isArchived && this._archivedSessionIds.delete(session.sessionId)) {
+                this._invalidateTerminalOperations(session.sessionId);
+            }
+            if (session?.loading.read(reader) || isArchived || worktreePending || !remoteHostAvailable) {
+                if (session && (isArchived || worktreePending || !remoteHostAvailable)) {
+                    this._invalidateTerminalOperations(session.sessionId);
+                }
+                if (!preserveActiveTerminalState) {
+                    this._activeKey = undefined;
+                    this._activeSessionId = undefined;
+                }
+                return;
+            }
+            this._onActiveSessionChanged(session);
+        }));
+        this._register(this._sessionsManagementService.onDidReplaceNewDraftSession((
+            {
+                from,
+                to
+            }
+        ) => {
+            this._onDidReplaceNewDraftSession(from, to);
+        }));
+        this._register(this._sessionsManagementService.onDidReplaceSession((
+            {
+                from,
+                to
+            }
+        ) => {
+            this._transferTerminals(from.sessionId, to.sessionId);
+        }));
+        this._register(this._terminalService.onDidDisposeInstance(instance => {
+            this._removeTerminalFromTrackedSessions(instance.instanceId);
+            this._standaloneTerminalIds.delete(instance.instanceId);
+        }));
+        this._register(this._terminalService.onDidCreateInstance(instance => {
+            if (instance.shellLaunchConfig.hideFromUser) {
+                return;
+            }
+            if (instance.shellLaunchConfig.attachPersistentProcess && this._activeKey) {
+                instance.getInitialCwd().then(cwd => {
+                    if (cwd.toLowerCase() !== this._activeKey) {
+                        const availableInstance = this._getAvailableTerminal(instance, `hide restored terminal for ${cwd}`);
+                        if (!availableInstance) {
+                            return;
+                        }
+                        this._terminalService.moveToBackground(availableInstance);
+                        this._logService.trace(
+                            `[SessionsTerminal] Hid restored terminal ${availableInstance.instanceId} (cwd: ${cwd})`
+                        );
+                    }
+                });
+            }
+        }));
+        this._register(this._sessionsManagementService.onDidChangeSessions(e => {
+            for (const session of e.added) {
+                if (session.isArchived.get()) {
+                    this._archivedSessionIds.add(session.sessionId);
+                }
+            }
+            const justArchived = [];
+            for (const session of e.changed) {
+                if (session.isArchived.get()) {
+                    if (!( this._archivedSessionIds.has(session.sessionId))) {
+                        this._archivedSessionIds.add(session.sessionId);
+                        this._invalidateTerminalOperations(session.sessionId);
+                        justArchived.push(session);
+                    }
+                } else {
+                    if (this._archivedSessionIds.delete(session.sessionId)) {
+                        this._invalidateTerminalOperations(session.sessionId);
+                    }
+                }
+            }
+            for (const session of e.removed) {
+                this._archivedSessionIds.delete(session.sessionId);
+            }
+            if (e.removed.length === 0 && justArchived.length === 0) {
+                return;
+            }
+            this._logService.trace(
+                `[SessionsTerminal] onDidChangeSessions cleanup (removed: ${e.removed.length}, justArchived: ${justArchived.length}, trackedSessions: ${this._sessionTerminals.size}, activeKey: ${this._activeKey ?? "<none>"})`
+            );
+            for (const session of e.removed) {
+                void this._closeTerminalsForSession(session.sessionId, `session removed (${session.sessionId})`).finally(() => this._sessionTerminals.delete(session.sessionId));
+            }
+            for (const session of justArchived) {
+                void this._closeArchivedSessionTerminals(session);
+            }
+        }));
+    }
+    async ensureTerminal(cwd, focus, session) {
+        if (!session) {
+            return this._ensureTerminal(cwd, focus, session);
+        }
+        if (!this._isSessionRemoteHostAvailable(session)) {
+            return [];
+        }
+        const generation = this._getTerminalOperationGeneration(session.sessionId);
+        this._beginTerminalOperation(session.sessionId);
+        try {
+            return await this._ensureTerminal(cwd, focus, session, generation);
+        } finally {
+            this._endTerminalOperation(session.sessionId);
+        }
+    }
+    async _ensureTerminal(cwd, focus, session, generation) {
+        if (session && this._isTerminalOperationCancelled(session, generation)) {
+            return [];
+        }
+        const key = cwd.fsPath.toLowerCase();
+        let existing = session ? this._getTrackedTerminalsForSession(session.sessionId) : [];
+        if (existing.length === 0) {
+            existing = await this._findTerminalsForKey(key, {
+                excludeTracked: !!session
+            });
+            if (session && this._isTerminalOperationCancelled(session, generation)) {
+                return [];
+            }
+        }
+        if (existing.length === 0) {
+            try {
+                const instance = await this._createTerminalForSession(cwd, session);
+                const createdInstance = this._getAvailableTerminal(instance, `activate created terminal for ${cwd.fsPath}`);
+                if (!createdInstance) {
+                    return [];
+                }
+                if (session && this._isTerminalOperationCancelled(session, generation)) {
+                    await this._terminalService.safeDisposeTerminal(createdInstance);
+                    if (!createdInstance.isDisposed) {
+                        this._trackTerminalsForSession(session.sessionId, [createdInstance]);
+                    }
+                    return [];
+                }
+                existing = [createdInstance];
+                this._terminalService.setActiveInstance(createdInstance);
+                this._logService.trace(
+                    `[SessionsTerminal] Created terminal ${createdInstance.instanceId} for ${cwd.fsPath}`
+                );
+            } catch (e) {
+                this._logService.trace(`[SessionsTerminal] Cannot create terminal for ${cwd.fsPath}: ${e}`);
+                return [];
+            }
+        }
+        if (session) {
+            this._trackTerminalsForSession(session.sessionId, existing);
+        }
+        if (focus) {
+            await this._terminalService.focusActiveInstance();
+        }
+        return existing;
+    }
+    _isTerminalOperationCancelled(
+        session,
+        generation = this._getTerminalOperationGeneration(session.sessionId)
+    ) {
+        return this._pendingTerminalOperations.get(session.sessionId)?.replaced === true || this._getTerminalOperationGeneration(session.sessionId) !== generation || ( this._archivedSessionIds.has(session.sessionId)) || session.isArchived.get() || session.worktreePending?.get() === true || !this._isSessionRemoteHostAvailable(session);
+    }
+    _isSessionRemoteHostAvailable(session) {
+        const status = session.remoteConnectionStatus?.get();
+        return status === undefined || status.kind === "connected";
+    }
+    _getTerminalOperationGeneration(sessionId) {
+        return this._sessionTerminalGenerations.get(sessionId) ?? 0;
+    }
+    _invalidateTerminalOperations(sessionId) {
+        this._sessionTerminalGenerations.set(sessionId, this._getTerminalOperationGeneration(sessionId) + 1);
+    }
+    async _createTerminalForSession(cwd, session) {
+        const address = session && this._getSessionAgentHostAddress(session);
+        if (address) {
+            const instance = await this._agentHostTerminalService.createTerminalForEntry(address, {
+                cwd
+            });
+            if (instance) {
+                return instance;
+            }
+        }
+        return this._terminalService.createTerminal({
+            config: {
+                cwd
+            }
+        });
+    }
+    _getSessionAgentHostAddress(session) {
+        if (!session) {
+            return undefined;
+        }
+        const provider = this._sessionsProvidersService.getProvider(session.providerId);
+        if (!provider || !isAgentHostProvider(provider)) {
+            return undefined;
+        }
+        return provider.remoteAddress ?? "__local__";
+    }
+    async _onActiveSessionChanged(session) {
+        if (!session) {
+            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) {
+                return;
+            }
+            this._activeKey = targetKey;
+            this._activeSessionId = session.sessionId;
+            const instances = await this._ensureTerminal(targetPath, false, session, generation);
+            if (this._activeKey !== targetKey || this._activeSessionId !== session.sessionId) {
+                return;
+            }
+            await this._updateTerminalVisibility(session, targetKey, instances.map(instance => instance.instanceId));
+        } finally {
+            this._endTerminalOperation(session.sessionId);
+        }
+    }
+    async _findTerminalsForKey(key, options) {
+        const result = [];
+        for (const instance of this._terminalService.instances) {
+            if (instance.shellLaunchConfig.hideFromUser) {
+                continue;
+            }
+            if (options?.excludeTracked && (this._isTerminalTracked(instance.instanceId) || ( this._standaloneTerminalIds.has(instance.instanceId)))) {
+                continue;
+            }
+            try {
+                const cwd = await instance.getInitialCwd();
+                if (cwd.toLowerCase() === key) {
+                    result.push(instance);
+                }
+            } catch {}
+        }
+        return result;
+    }
+    _trackTerminalsForSession(sessionId, instances) {
+        if (instances.length === 0) {
+            return;
+        }
+        let terminalIds = this._sessionTerminals.get(sessionId);
+        if (!terminalIds) {
+            terminalIds = ( new Set());
+            this._sessionTerminals.set(sessionId, terminalIds);
+        }
+        for (const instance of instances) {
+            terminalIds.add(instance.instanceId);
+        }
+    }
+    _beginTerminalOperation(sessionId) {
+        const operation = this._pendingTerminalOperations.get(sessionId);
+        if (operation) {
+            operation.count++;
+            return;
+        }
+        this._pendingTerminalOperations.set(sessionId, {
+            count: 1,
+            replaced: false
+        });
+    }
+    _endTerminalOperation(sessionId) {
+        const operation = this._pendingTerminalOperations.get(sessionId);
+        if (!operation) {
+            return;
+        }
+        operation.count--;
+        if (operation.count > 0) {
+            return;
+        }
+        this._pendingTerminalOperations.delete(sessionId);
+    }
+    _onDidReplaceNewDraftSession(from, to) {
+        const pendingOperation = this._pendingTerminalOperations.get(from.sessionId);
+        if (pendingOperation) {
+            pendingOperation.replaced = true;
+        }
+        const fromCwd = getSessionTerminalInfo(from)?.cwd.fsPath.toLowerCase();
+        const toCwd = getSessionTerminalInfo(to)?.cwd.fsPath.toLowerCase();
+        const fromAgentHostAddress = this._getSessionAgentHostAddress(from);
+        const toAgentHostAddress = this._getSessionAgentHostAddress(to);
+        if (fromCwd === toCwd && fromAgentHostAddress === toAgentHostAddress) {
+            this._transferTerminals(from.sessionId, to.sessionId);
+        } else {
+            this._rehomeTerminals(from.sessionId);
+        }
+    }
+    _rehomeTerminals(sessionId) {
+        const terminals = this._getTrackedTerminalsForSession(sessionId);
+        for (const terminal of terminals) {
+            this._standaloneTerminalIds.add(terminal.instanceId);
+        }
+        if (terminals.length > 0) {
+            this._logService.trace(
+                `[SessionsTerminal] Rehomed ${terminals.length} terminal(s) from session ${sessionId}`
+            );
+        }
+        this._sessionTerminals.delete(sessionId);
+    }
+    _transferTerminals(fromSessionId, toSessionId) {
+        const terminalIds = this._sessionTerminals.get(fromSessionId);
+        if (terminalIds && terminalIds.size > 0) {
+            let targetIds = this._sessionTerminals.get(toSessionId);
+            if (!targetIds) {
+                targetIds = ( new Set());
+                this._sessionTerminals.set(toSessionId, targetIds);
+            }
+            for (const id of terminalIds) {
+                targetIds.add(id);
+            }
+            this._logService.trace(
+                `[SessionsTerminal] Transferred ${terminalIds.size} terminal(s) from session ${fromSessionId} to ${toSessionId}`
+            );
+        }
+        this._sessionTerminals.delete(fromSessionId);
+    }
+    _getTrackedTerminalsForSession(sessionId) {
+        const terminalIds = this._sessionTerminals.get(sessionId);
+        if (!terminalIds) {
+            return [];
+        }
+        const result = [];
+        for (const instanceId of [...terminalIds]) {
+            const instance = this._terminalService.getInstanceFromId(instanceId);
+            if (!instance || instance.isDisposed || instance.shellLaunchConfig.hideFromUser) {
+                terminalIds.delete(instanceId);
+                continue;
+            }
+            result.push(instance);
+        }
+        if (terminalIds.size === 0) {
+            this._sessionTerminals.delete(sessionId);
+        }
+        return result;
+    }
+    _isTerminalTracked(instanceId) {
+        for (const [sessionId, terminalIds] of this._sessionTerminals) {
+            if (( terminalIds.has(instanceId))) {
+                const instance = this._terminalService.getInstanceFromId(instanceId);
+                if (!instance || instance.isDisposed) {
+                    terminalIds.delete(instanceId);
+                    if (terminalIds.size === 0) {
+                        this._sessionTerminals.delete(sessionId);
+                    }
+                    continue;
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    _removeTerminalFromTrackedSessions(instanceId) {
+        for (const [sessionId, terminalIds] of this._sessionTerminals) {
+            terminalIds.delete(instanceId);
+            if (terminalIds.size === 0) {
+                this._sessionTerminals.delete(sessionId);
+            }
+        }
+    }
+    _getAvailableTerminal(instance, action) {
+        const currentInstance = this._terminalService.getInstanceFromId(instance.instanceId);
+        if (!currentInstance || currentInstance.isDisposed) {
+            this._logService.trace(
+                `[SessionsTerminal] Cannot ${action}; terminal ${instance.instanceId} is no longer available`
+            );
+            return undefined;
+        }
+        return currentInstance;
+    }
+    async _updateTerminalVisibility(activeSession, activeKey, forceForegroundTerminalIds) {
+        const toShow = [];
+        const toHide = [];
+        const trackedTerminalIds = ( new Set(
+            this._getTrackedTerminalsForSession(activeSession.sessionId).map(instance => instance.instanceId)
+        ));
+        for (const instance of [...this._terminalService.instances]) {
+            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));
+            if (!belongsToActiveSession && !this._isTerminalTracked(currentInstance.instanceId)) {
+                try {
+                    cwd = (await currentInstance.getInitialCwd()).toLowerCase();
+                } catch {
+                    continue;
+                }
+                belongsToActiveSession = cwd === activeKey;
+            }
+            if ((belongsToActiveSession || isForceVisible) && !isForeground) {
+                toShow.push(currentInstance);
+            } else if (!belongsToActiveSession && !isForceVisible && isForeground) {
+                toHide.push(currentInstance);
+            }
+        }
+        for (const instance of toShow) {
+            const availableInstance = this._getAvailableTerminal(instance, "show background terminal");
+            if (availableInstance) {
+                await this._terminalService.showBackgroundTerminal(availableInstance, true);
+            }
+        }
+        for (const instance of toHide) {
+            const availableInstance = this._getAvailableTerminal(instance, "move terminal to background");
+            if (availableInstance) {
+                this._logService.debug(
+                    `[SessionsTerminal] Hiding terminal ${availableInstance.instanceId} (does not belong to active key ${activeKey})`
+                );
+                this._terminalService.moveToBackground(availableInstance);
+            }
+        }
+        const foreground = this._terminalService.foregroundInstances;
+        let mostRecent;
+        let mostRecentTimestamp = -1;
+        for (const instance of foreground) {
+            if (( this._standaloneTerminalIds.has(instance.instanceId))) {
+                continue;
+            }
+            const cmdDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
+            const lastCmd = cmdDetection?.commands.at(-1);
+            if (lastCmd && lastCmd.timestamp > mostRecentTimestamp) {
+                mostRecentTimestamp = lastCmd.timestamp;
+                mostRecent = instance;
+            }
+        }
+        if (mostRecent) {
+            this._terminalService.setActiveInstance(mostRecent);
+        }
+    }
+    async _closeTerminalsForSession(sessionId, reason) {
+        const protectedInstanceId = this._terminalService.activeInstance?.instanceId;
+        for (const instance of this._getTrackedTerminalsForSession(sessionId)) {
+            if (protectedInstanceId !== undefined && instance.instanceId === protectedInstanceId) {
+                this._logService.info(
+                    `[SessionsTerminal] Skipping active terminal ${instance.instanceId} for session ${sessionId} (user is working in it)`
+                );
+                continue;
+            }
+            const availableInstance = this._getAvailableTerminal(instance, `close removed session terminal for session ${sessionId}`);
+            if (!availableInstance) {
+                continue;
+            }
+            this._logService.info(
+                `[SessionsTerminal] Killing terminal ${availableInstance.instanceId} (session: ${sessionId}, reason: ${reason})`
+            );
+            await this._terminalService.safeDisposeTerminal(availableInstance);
+            this._removeTerminalFromTrackedSessions(availableInstance.instanceId);
+        }
+    }
+    async _closeArchivedSessionTerminals(session) {
+        const cleanupGeneration = this._getTerminalOperationGeneration(session.sessionId);
+        const terminals = ( new Map(
+            this._getTrackedTerminalsForSession(session.sessionId).map(instance => [instance.instanceId, instance])
+        ));
+        const untrackedWorktreeTerminalIds = ( new Set());
+        const worktreeCwd = getSessionWorktreeCwd(session);
+        const anotherLiveSessionSharesWorktree = worktreeCwd && ( this._sessionsManagementService.getSessions().some(
+            candidate => candidate.sessionId !== session.sessionId && !candidate.isArchived.get() && isEqual(getSessionWorktreeCwd(candidate), worktreeCwd)
+        ));
+        if (worktreeCwd && !anotherLiveSessionSharesWorktree) {
+            for (const instance of await this._findUntrackedTerminalsForResource(worktreeCwd)) {
+                if (instance.instanceId === this._terminalService.activeInstance?.instanceId) {
+                    continue;
+                }
+                terminals.set(instance.instanceId, instance);
+                untrackedWorktreeTerminalIds.add(instance.instanceId);
+            }
+        }
+        if (!this._isArchiveCleanupCurrent(session.sessionId, cleanupGeneration)) {
+            return;
+        }
+        for (const instance of ( terminals.values())) {
+            if (!this._isArchiveCleanupCurrent(session.sessionId, cleanupGeneration)) {
+                return;
+            }
+            if (( untrackedWorktreeTerminalIds.has(instance.instanceId)) && (this._isTerminalTracked(instance.instanceId) || ( this._standaloneTerminalIds.has(instance.instanceId)) || this._terminalService.activeInstance?.instanceId === instance.instanceId)) {
+                continue;
+            }
+            const availableInstance = this._getAvailableTerminal(
+                instance,
+                `close archived session terminal for session ${session.sessionId}`
+            );
+            if (!availableInstance) {
+                continue;
+            }
+            this._logService.info(
+                `[SessionsTerminal] Killing terminal ${availableInstance.instanceId} (session archived: ${session.sessionId})`
+            );
+            await this._terminalService.safeDisposeTerminal(availableInstance);
+            if (availableInstance.isDisposed) {
+                this._removeTerminalFromTrackedSessions(availableInstance.instanceId);
+            }
+            if (!this._isArchiveCleanupCurrent(session.sessionId, cleanupGeneration)) {
+                await this._ensureActiveSessionTerminalAfterLateArchiveCleanup(session.sessionId);
+                return;
+            }
+        }
+    }
+    _isArchiveCleanupCurrent(sessionId, generation) {
+        return ( this._archivedSessionIds.has(sessionId)) && this._getTerminalOperationGeneration(sessionId) === generation;
+    }
+    async _ensureActiveSessionTerminalAfterLateArchiveCleanup(sessionId) {
+        const activeSession = this._sessionsService.activeSession.get();
+        if (!activeSession || activeSession.sessionId !== sessionId || activeSession.isArchived.get() || activeSession.loading.get() || activeSession.worktreePending?.get()) {
+            return;
+        }
+        this._activeKey = undefined;
+        this._activeSessionId = undefined;
+        await this._onActiveSessionChanged(activeSession);
+    }
+    async _findUntrackedTerminalsForResource(resource) {
+        const result = [];
+        for (const instance of this._terminalService.instances) {
+            if (!instance.shellLaunchConfig.attachPersistentProcess || instance.shellLaunchConfig.hideFromUser || this._isTerminalTracked(instance.instanceId) || ( this._standaloneTerminalIds.has(instance.instanceId))) {
+                continue;
+            }
+            try {
+                if (isEqual(URI.file(await instance.getInitialCwd()), resource) && !this._isTerminalTracked(instance.instanceId) && !( this._standaloneTerminalIds.has(instance.instanceId))) {
+                    result.push(instance);
+                }
+            } catch {}
+        }
+        return result;
+    }
+    async dumpTracking() {
+        console.log(`[SessionsTerminal] Active key: ${this._activeKey ?? "<none>"}`);
+        console.log(`[SessionsTerminal] Session terminals: ${JSON.stringify(
+    [...this._sessionTerminals.entries()].map(([sessionId, terminalIds]) => [sessionId, [...terminalIds]])
+)}`);
+        console.log(
+            `[SessionsTerminal] Standalone terminals: ${JSON.stringify([...this._standaloneTerminalIds])}`
+        );
+        console.log("[SessionsTerminal] === All Terminals ===");
+        for (const instance of this._terminalService.instances) {
+            let cwd = "<unknown>";
+            try {
+                cwd = await instance.getInitialCwd();
+            } catch {}
+            const isForeground = this._terminalService.foregroundInstances.includes(instance);
+            console.log(
+                `  ${instance.instanceId} - ${cwd} - ${isForeground ? "foreground" : "background"}`
+            );
+        }
+    }
+    async showAllTerminals() {
+        for (const instance of this._terminalService.instances) {
+            if (!this._terminalService.foregroundInstances.includes(instance)) {
+                await this._terminalService.showBackgroundTerminal(instance, true);
+                this._logService.trace(`[SessionsTerminal] Moved terminal ${instance.instanceId} to foreground`);
+            }
+        }
+    }
+};
+SessionsTerminalContribution = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, ISessionsService)), ( __param(2, ISessionsProvidersService)), ( __param(3, ITerminalService)), ( __param(4, IAgentHostTerminalService)), ( __param(5, ILogService)), ( __param(6, IPathService)), ( __param(7, IFileService)), ( __param(8, ITerminalProfileService))], SessionsTerminalContribution));
+registerWorkbenchContribution2(
+    SessionsTerminalContribution.ID,
+    SessionsTerminalContribution,
+    WorkbenchPhase.AfterRestored
+);
+let RegisterAgentHostSessionTaskRunnerContribution = class RegisterAgentHostSessionTaskRunnerContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessions.registerAgentHostTaskRunner";
+    }
+    constructor(instantiationService, registry) {
+        super();
+        const runner = instantiationService.createInstance(AgentHostSessionTaskRunner);
+        this._register(registry.register(runner));
+    }
+};
+RegisterAgentHostSessionTaskRunnerContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ISessionTaskRunnerRegistry))], RegisterAgentHostSessionTaskRunnerContribution));
+registerWorkbenchContribution2(
+    RegisterAgentHostSessionTaskRunnerContribution.ID,
+    RegisterAgentHostSessionTaskRunnerContribution,
+    WorkbenchPhase.BlockStartup
+);
+class DumpTerminalTrackingAction extends Action2 {
+    constructor() {
+        super({
+            id: "agentSession.dumpTerminalTracking",
+            title: ( localize2(5020, "Dump Terminal Tracking")),
+            f1: true
+        });
+    }
+    async run() {
+        const contribution = getWorkbenchContribution(SessionsTerminalContribution.ID);
+        await contribution.dumpTracking();
+    }
+}
+registerAction2(DumpTerminalTrackingAction);
+class ShowAllTerminalsAction extends Action2 {
+    constructor() {
+        super({
+            id: "agentSession.showAllTerminals",
+            title: ( localize2(5021, "Show All Terminals")),
+            f1: true
+        });
+    }
+    async run() {
+        const contribution = getWorkbenchContribution(SessionsTerminalContribution.ID);
+        await contribution.showAllTerminals();
+    }
+}
+registerAction2(ShowAllTerminalsAction);
+
+export { SessionsTerminalContribution };