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

package/vscode/src/vs/sessions/contrib/workspace/browser/workspaceFolderManagement.js

@@ -11,6 +11,7 @@ import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/plat
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { Queue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 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';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 let WorkspaceFolderManagementContribution = class WorkspaceFolderManagementContribution extends Disposable {
@@ -23,7 +24,8 @@ let WorkspaceFolderManagementContribution = class WorkspaceFolderManagementContr
         workspaceContextService,
         workspaceEditingService,
         workspaceTrustManagementService,
-        workspaceFolderLabelService
+        workspaceFolderLabelService,
+        historyService
     ) {
         super();
         this.sessionsService = sessionsService;
@@ -32,64 +34,74 @@ let WorkspaceFolderManagementContribution = class WorkspaceFolderManagementContr
         this.workspaceEditingService = workspaceEditingService;
         this.workspaceTrustManagementService = workspaceTrustManagementService;
         this.workspaceFolderLabelService = workspaceFolderLabelService;
+        this.historyService = historyService;
         this.queue = this._register(( new Queue()));
+        this._register(this.workspaceContextService.onDidChangeWorkspaceFolders(event => {
+            if (event.removed.length > 0) {
+                this.historyService.clearRecentlyOpened();
+            }
+        }));
         this._register(autorun(reader => {
             const activeSession = this.sessionsService.activeSession.read(reader);
-            activeSession?.workspace.read(reader);
-            this.queue.queue(() => this.updateWorkspaceFoldersForSession(activeSession));
+            const activeChat = activeSession?.activeChat.read(reader);
+            const workspace = activeChat?.workspace.read(reader);
+            this.queue.queue(() => this.updateWorkspaceFolders(workspace));
         }));
     }
-    async updateWorkspaceFoldersForSession(session) {
-        await ensureSessionWorktreesTrusted(session?.workspace.get(), this.workspaceTrustManagementService);
-        const activeSessionFolderData = this.getActiveSessionFolderData(session);
-        const currentRepo = this.workspaceContextService.getWorkspace().folders[0]?.uri;
-        if (activeSessionFolderData && !(await this.isFolderMountable(session, activeSessionFolderData.uri))) {
-            if (currentRepo) {
-                await this.workspaceEditingService.removeFolders([currentRepo], true);
+    async updateWorkspaceFolders(workspace) {
+        await ensureSessionWorktreesTrusted(workspace, this.workspaceTrustManagementService);
+        const activeSessionFolders = this.getWorkspaceFolderData(workspace);
+        const currentFolders = this.workspaceContextService.getWorkspace().folders;
+        const mountable = await Promise.all(
+            activeSessionFolders.map(folder => this.isFolderMountable(workspace, folder.uri))
+        );
+        if (( mountable.some(isMountable => !isMountable))) {
+            if (currentFolders.length > 0) {
+                await this.workspaceEditingService.removeFolders(currentFolders.map(folder => folder.uri), true);
             }
             return;
         }
-        if (!activeSessionFolderData) {
-            if (currentRepo) {
-                await this.workspaceEditingService.removeFolders([currentRepo], true);
+        if (activeSessionFolders.length === 0) {
+            if (currentFolders.length > 0) {
+                await this.workspaceEditingService.removeFolders(currentFolders.map(folder => folder.uri), true);
             }
             return;
         }
-        if (!currentRepo) {
-            await this.workspaceEditingService.addFolders([activeSessionFolderData], true);
+        if (currentFolders.length === 0) {
+            await this.workspaceEditingService.addFolders(activeSessionFolders, true);
             return;
         }
-        if (this.uriIdentityService.extUri.isEqual(currentRepo, activeSessionFolderData.uri)) {
+        const foldersMatch = currentFolders.length === activeSessionFolders.length && currentFolders.every(
+            (folder, index) => this.uriIdentityService.extUri.isEqual(folder.uri, activeSessionFolders[index].uri) && folder.name === activeSessionFolders[index].name
+        );
+        if (foldersMatch) {
             return;
         }
-        await this.workspaceEditingService.updateFolders(0, 1, [activeSessionFolderData], true);
+        await this.workspaceEditingService.updateFolders(0, currentFolders.length, activeSessionFolders, true);
     }
-    getActiveSessionFolderData(session) {
-        if (!session) {
-            return undefined;
-        }
-        const workspace = session.workspace.get();
-        const folder = workspace?.folders[0];
-        if (!folder) {
-            return undefined;
+    getWorkspaceFolderData(workspace) {
+        if (!workspace) {
+            return [];
         }
-        return {
-            uri: folder.workingDirectory,
-            name: this.workspaceFolderLabelService.getWorkspaceFolderLabel(( new WorkspaceFolder({
+        return workspace.folders.map((folder, index) => {
+            const name = index === 0 ? workspace.label : folder.name;
+            return {
                 uri: folder.workingDirectory,
-                name: workspace.label,
-                index: 0
-            })), true) ?? workspace.label
-        };
+                name: this.workspaceFolderLabelService.getWorkspaceFolderLabel(( new WorkspaceFolder({
+                    uri: folder.workingDirectory,
+                    name,
+                    index
+                })), true) ?? name
+            };
+        });
     }
-    async isFolderMountable(session, uri) {
-        const workspace = session?.workspace.get();
+    async isFolderMountable(workspace, uri) {
         if (!workspace?.requiresWorkspaceTrust) {
             return true;
         }
         return (await this.workspaceTrustManagementService.getUriTrustInfo(uri)).trusted;
     }
 };
-WorkspaceFolderManagementContribution = ( __decorate([( __param(0, ISessionsService)), ( __param(1, IUriIdentityService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IWorkspaceEditingService)), ( __param(4, IWorkspaceTrustManagementService)), ( __param(5, IWorkspaceFolderLabelService))], WorkspaceFolderManagementContribution));
+WorkspaceFolderManagementContribution = ( __decorate([( __param(0, ISessionsService)), ( __param(1, IUriIdentityService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IWorkspaceEditingService)), ( __param(4, IWorkspaceTrustManagementService)), ( __param(5, IWorkspaceFolderLabelService)), ( __param(6, IHistoryService))], WorkspaceFolderManagementContribution));
 
 export { WorkspaceFolderManagementContribution };

package/vscode/src/vs/sessions/services/agentHostFilter/browser/agentHostFilterService.d.ts

@@ -1,6 +1,7 @@
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { IAgentHostGroup } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider";
 import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
@@ -10,18 +11,22 @@ export declare class AgentHostFilterService extends Disposable implements IAgent
     private readonly _sessionsProvidersService;
     private readonly _remoteAgentHostService;
     private readonly _storageService;
+    private readonly _configurationService;
     readonly _serviceBrand: undefined;
     private readonly _onDidChange;
     readonly onDidChange: Event<void>;
     private readonly _onDidChangeDiscovering;
     readonly onDidChangeDiscovering: Event<void>;
     private _selectedHostId;
+    /** Last explicit choice, retained while its host has not been discovered yet. */
+    private _preferredHostId;
     /**
      * `true` while {@link _selectedHostId} comes from the fallback rather than
      * from the user. An automatic choice is provisional and can be replaced.
      */
     private _selectionIsAutomatic;
     private _hosts;
+    private _pickerHosts;
     /**
      * Discovery handlers contributed by host providers (e.g. dev tunnels).
      * {@link rediscover} fans out to every handler and waits for them to
@@ -45,17 +50,17 @@ export declare class AgentHostFilterService extends Disposable implements IAgent
      * changes so we always observe the live set.
      */
     private readonly _providerWatchers;
-    constructor(_sessionsProvidersService: ISessionsProvidersService, _remoteAgentHostService: IRemoteAgentHostService, _storageService: IStorageService);
+    constructor(_sessionsProvidersService: ISessionsProvidersService, _remoteAgentHostService: IRemoteAgentHostService, _storageService: IStorageService, _configurationService: IConfigurationService);
     get selectedHostId(): string | undefined;
     get selectedHost(): IAgentHostFilterEntry | undefined;
     get hosts(): readonly IAgentHostFilterEntry[];
     get isDiscovering(): boolean;
-    rediscover(): Promise<void>;
+    rediscover(): Promise<boolean>;
     registerDiscoveryHandler(handler: () => Promise<void>): IDisposable;
     registerHostGroup(group: IAgentHostGroup): IDisposable;
     setSelectedHostId(hostId: string): void;
-    reconnect(hostId: string): void;
-    disconnect(hostId: string): void;
+    reconnect(hostId: string): Promise<void>;
+    disconnect(hostId: string): Promise<void>;
     /**
      * Resolve a selection against the live entry list. A selection made by the
      * fallback is provisional and is replaced once a connectable entry shows

package/vscode/src/vs/sessions/services/agentHostFilter/browser/agentHostFilterService.js

@@ -1,11 +1,13 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { RemoteAgentHostsEnabledSettingId, getEntryAddress } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
 import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
@@ -13,6 +15,7 @@ import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sess
 import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
 import { AgentHostFilterConnectionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 const STORAGE_KEY = "sessions.agentHostFilter.selectedProviderId";
@@ -47,26 +50,42 @@ function isRemoteAgentHostProvider(provider) {
     return isAgentHostProvider(p) && p.connectionStatus !== undefined && typeof p.remoteAddress === "string";
 }
 let AgentHostFilterService = class AgentHostFilterService extends Disposable {
-    constructor(_sessionsProvidersService, _remoteAgentHostService, _storageService) {
+    constructor(
+        _sessionsProvidersService,
+        _remoteAgentHostService,
+        _storageService,
+        _configurationService
+    ) {
         super();
         this._sessionsProvidersService = _sessionsProvidersService;
         this._remoteAgentHostService = _remoteAgentHostService;
         this._storageService = _storageService;
+        this._configurationService = _configurationService;
         this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
         this._onDidChangeDiscovering = this._register(( new Emitter()));
         this.onDidChangeDiscovering = this._onDidChangeDiscovering.event;
         this._selectionIsAutomatic = false;
         this._hosts = [];
+        this._pickerHosts = [];
         this._discoveryHandlers = ( new Set());
         this._discoveringCount = 0;
         this._declaredGroups = ( new Map());
         this._providerWatchers = this._register(( new DisposableStore()));
-        this._selectedHostId = this._storageService.get(STORAGE_KEY, StorageScope.PROFILE, undefined);
+        this._preferredHostId = this._storageService.get(STORAGE_KEY, StorageScope.PROFILE, undefined);
+        this._selectedHostId = this._preferredHostId;
         this._rewatchProviders();
         this._register(
             this._sessionsProvidersService.onDidChangeProviders(() => this._rewatchProviders())
         );
+        this._register(
+            this._remoteAgentHostService.onDidChangeConfiguredEntries(() => this._rewatchProviders())
+        );
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(RemoteAgentHostsEnabledSettingId)) {
+                this._rewatchProviders();
+            }
+        }));
     }
     get selectedHostId() {
         return this._selectedHostId;
@@ -78,21 +97,22 @@ let AgentHostFilterService = class AgentHostFilterService extends Disposable {
         return this._hosts.find(h => h.id === this._selectedHostId);
     }
     get hosts() {
-        return this._hosts;
+        return this._pickerHosts;
     }
     get isDiscovering() {
         return this._discoveringCount > 0;
     }
     async rediscover() {
         if (this._discoveryHandlers.size === 0) {
-            return;
+            return true;
         }
         this._discoveringCount++;
         if (this._discoveringCount === 1) {
             this._onDidChangeDiscovering.fire();
         }
         try {
-            await Promise.allSettled([...this._discoveryHandlers].map(h => h().catch(() => {})));
+            const results = await Promise.allSettled([...this._discoveryHandlers].map(handler => handler()));
+            return results.every(result => result.status === "fulfilled");
         } finally {
             this._discoveringCount--;
             if (this._discoveringCount === 0) {
@@ -114,47 +134,55 @@ let AgentHostFilterService = class AgentHostFilterService extends Disposable {
         });
     }
     setSelectedHostId(hostId) {
-        if (!( this._hosts.some(h => h.id === hostId))) {
+        if (!( this._pickerHosts.some(h => h.id === hostId))) {
             return;
         }
         const changed = hostId !== this._selectedHostId;
         this._selectedHostId = hostId;
+        this._preferredHostId = hostId;
         this._selectionIsAutomatic = false;
         this._persist(hostId);
         if (changed) {
             this._onDidChange.fire();
         }
     }
-    reconnect(hostId) {
+    async reconnect(hostId) {
         const host = this._hosts.find(h => h.id === hostId);
         if (!host) {
             return;
         }
-        for (const providerId of host.providerIds) {
+        await Promise.all(host.providerIds.map(async providerId => {
             const provider = this._sessionsProvidersService.getProvider(providerId);
             if (provider && isAgentHostProvider(provider) && provider.connect) {
-                provider.connect().catch(() => {});
-                continue;
+                await provider.connect();
+                return;
             }
             const address = provider && isAgentHostProvider(provider) ? provider.remoteAddress : host.address;
             if (address) {
                 this._remoteAgentHostService.reconnect(address);
             }
-        }
+        }));
     }
-    disconnect(hostId) {
+    async disconnect(hostId) {
         const host = this._hosts.find(h => h.id === hostId);
         if (!host) {
             return;
         }
-        for (const providerId of host.providerIds) {
+        await Promise.all(host.providerIds.map(async providerId => {
             const provider = this._sessionsProvidersService.getProvider(providerId);
             if (provider && isAgentHostProvider(provider) && provider.disconnect) {
-                provider.disconnect().catch(() => {});
+                await provider.disconnect();
             }
-        }
+        }));
     }
     _validate(hostId) {
+        const preferred = this._hosts.find(h => h.id === this._preferredHostId);
+        if (preferred) {
+            return {
+                id: preferred.id,
+                automatic: false
+            };
+        }
         if (this._hosts.length === 0) {
             return {
                 id: undefined,
@@ -168,16 +196,21 @@ let AgentHostFilterService = class AgentHostFilterService extends Disposable {
                 automatic: this._selectionIsAutomatic
             };
         }
-        const connectable = this._hosts.find(h => h.connectable);
+        const connectable = this._pickerHosts.find(h => h.connectable);
+        const fallback = connectable ?? current ?? this._pickerHosts[0];
         return {
-            id: (connectable ?? current ?? this._hosts[0]).id,
-            automatic: true
+            id: fallback?.id,
+            automatic: fallback !== undefined
         };
     }
     _rewatchProviders() {
         this._providerWatchers.clear();
         const providers = this._sessionsProvidersService.getProviders().filter(isRemoteAgentHostProvider);
+        const providerLabelsChanged = observableSignalFromEvent(this, Event.any(
+            ...providers.map(provider => provider.onDidChangeSessionTypes ?? Event.None)
+        ));
         this._providerWatchers.add(autorun(reader => {
+            providerLabelsChanged.read(reader);
             const grouped = ( new Map());
             const entries = [];
             const groupEntry = group => {
@@ -185,13 +218,14 @@ let AgentHostFilterService = class AgentHostFilterService extends Disposable {
                 if (!entry) {
                     entry = {
                         id: group.id,
-                        providerIds: [],
+                        providerIds: group.sessionCreationProviderId && this._sessionsProvidersService.getProvider(group.sessionCreationProviderId) ? [group.sessionCreationProviderId] : [],
                         label: group.label,
                         grouped: true,
                         address: undefined,
                         icon: group.icon ?? Codicon.remote,
                         status: AgentHostFilterConnectionStatus.Disconnected,
                         connectable: group.connectable !== false,
+                        sessionCreationProviderId: group.sessionCreationProviderId,
                         order: group.order ?? 0
                     };
                     grouped.set(group.id, entry);
@@ -202,7 +236,11 @@ let AgentHostFilterService = class AgentHostFilterService extends Disposable {
             for (const group of ( this._declaredGroups.values())) {
                 groupEntry(group);
             }
+            const hiddenProviderIds = ( new Set());
             for (const provider of providers) {
+                if (provider.isVisibleInEnvironmentPicker?.read(reader) === false) {
+                    hiddenProviderIds.add(provider.id);
+                }
                 const status = mapStatus(provider.connectionStatus.read(reader));
                 const group = provider.hostGroup;
                 if (!group) {
@@ -210,6 +248,7 @@ let AgentHostFilterService = class AgentHostFilterService extends Disposable {
                         id: provider.id,
                         providerIds: [provider.id],
                         label: provider.label,
+                        description: provider.hostDescription?.read(reader),
                         grouped: false,
                         address: provider.remoteAddress,
                         icon: provider.icon,
@@ -223,20 +262,31 @@ let AgentHostFilterService = class AgentHostFilterService extends Disposable {
                 entry.providerIds.push(provider.id);
                 entry.status = rollupStatus([entry.status, status]);
             }
+            const selectedHost = this.selectedHost;
+            if (isWeb && selectedHost?.address && this._configurationService.getValue(RemoteAgentHostsEnabledSettingId) && selectedHost.id === this._preferredHostId && !( entries.some(entry => entry.id === selectedHost.id)) && ( this._remoteAgentHostService.configuredEntries.some(entry => getEntryAddress(entry) === selectedHost.address))) {
+                entries.push({
+                    ...selectedHost,
+                    providerIds: [...selectedHost.providerIds],
+                    status: AgentHostFilterConnectionStatus.Disconnected,
+                    order: 0
+                });
+            }
             entries.sort((a, b) => a.order - b.order || a.label.localeCompare(b.label));
             this._applyHosts(entries.map((
                 {
                     order,
                     ...entry
                 }
-            ) => entry));
+            ) => entry), hiddenProviderIds);
         }));
     }
-    _applyHosts(hosts) {
-        const changed = hosts.length !== this._hosts.length || ( hosts.some(
-            (h, i) => h.id !== this._hosts[i].id || h.label !== this._hosts[i].label || h.address !== this._hosts[i].address || h.status !== this._hosts[i].status || h.providerIds.length !== this._hosts[i].providerIds.length || ( h.providerIds.some((p, j) => p !== this._hosts[i].providerIds[j]))
+    _applyHosts(hosts, hiddenProviderIds) {
+        const pickerHosts = hosts.filter(host => !( hiddenProviderIds.has(host.id)));
+        const changed = pickerHosts.length !== this._pickerHosts.length || ( pickerHosts.some((host, i) => host.id !== this._pickerHosts[i].id)) || hosts.length !== this._hosts.length || ( hosts.some(
+            (h, i) => h.id !== this._hosts[i].id || h.label !== this._hosts[i].label || h.description !== this._hosts[i].description || h.address !== this._hosts[i].address || h.status !== this._hosts[i].status || h.sessionCreationProviderId !== this._hosts[i].sessionCreationProviderId || h.providerIds.length !== this._hosts[i].providerIds.length || ( h.providerIds.some((p, j) => p !== this._hosts[i].providerIds[j]))
         ));
         this._hosts = hosts;
+        this._pickerHosts = pickerHosts;
         const validated = isWeb ? this._validate(this._selectedHostId) : {
             id: undefined,
             automatic: false
@@ -254,6 +304,6 @@ let AgentHostFilterService = class AgentHostFilterService extends Disposable {
         this._storageService.store(STORAGE_KEY, hostId, StorageScope.PROFILE, StorageTarget.USER);
     }
 };
-AgentHostFilterService = ( __decorate([( __param(0, ISessionsProvidersService)), ( __param(1, IRemoteAgentHostService)), ( __param(2, IStorageService))], AgentHostFilterService));
+AgentHostFilterService = ( __decorate([( __param(0, ISessionsProvidersService)), ( __param(1, IRemoteAgentHostService)), ( __param(2, IStorageService)), ( __param(3, IConfigurationService))], AgentHostFilterService));
 
 export { AgentHostFilterService };

package/vscode/src/vs/sessions/services/customView/browser/customViewService.d.ts

@@ -1,21 +1,28 @@
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IObservable, ITransaction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { ICustomViewDescriptor } from "./customView.js";
 import { ICustomViewService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/customView/browser/customViewService.service";
+export interface ICustomViewOpenRequest {
+    readonly descriptor: ICustomViewDescriptor;
+    readonly source: "explicit" | "history" | "restore";
+}
 export declare class CustomViewService extends Disposable implements ICustomViewService {
     private readonly _logService;
     private readonly _storageService;
     readonly _serviceBrand: undefined;
     private readonly _descriptors;
     private _desiredCustomViewId;
-    private readonly _activeCustomView;
+    private readonly _activeCustomViewOpen;
+    readonly activeCustomViewOpen: IObservable<ICustomViewOpenRequest | undefined>;
     readonly activeCustomView: IObservable<ICustomViewDescriptor | undefined>;
     constructor(_logService: ILogService, _storageService: IStorageService);
     registerCustomView(descriptor: ICustomViewDescriptor, options?: {
         readonly restore?: boolean;
     }): IDisposable;
-    showCustomView(id: string): void;
-    hideCustomView(): void;
+    showCustomView(id: string, options?: {
+        readonly source: "history";
+    }): void;
+    hideCustomView(tx?: ITransaction): void;
 }

package/vscode/src/vs/sessions/services/customView/browser/customViewService.js

@@ -8,6 +8,7 @@ import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 
 const ACTIVE_CUSTOM_VIEW_STORAGE_KEY = "sessions.activeCustomView";
 let CustomViewService = class CustomViewService extends Disposable {
@@ -16,8 +17,9 @@ let CustomViewService = class CustomViewService extends Disposable {
         this._logService = _logService;
         this._storageService = _storageService;
         this._descriptors = ( new Map());
-        this._activeCustomView = observableValue(this, undefined);
-        this.activeCustomView = this._activeCustomView;
+        this._activeCustomViewOpen = observableValue(this, undefined);
+        this.activeCustomViewOpen = this._activeCustomViewOpen;
+        this.activeCustomView = derived(this, reader => this._activeCustomViewOpen.read(reader)?.descriptor);
         this._desiredCustomViewId = this._storageService.get(ACTIVE_CUSTOM_VIEW_STORAGE_KEY, StorageScope.WORKSPACE);
     }
     registerCustomView(descriptor, options) {
@@ -30,17 +32,20 @@ let CustomViewService = class CustomViewService extends Disposable {
                 this._desiredCustomViewId = undefined;
                 this._storageService.remove(ACTIVE_CUSTOM_VIEW_STORAGE_KEY, StorageScope.WORKSPACE);
             } else {
-                this._activeCustomView.set(descriptor, undefined);
+                this._activeCustomViewOpen.set({
+                    descriptor,
+                    source: "restore"
+                }, undefined);
             }
         }
         return toDisposable(() => {
             this._descriptors.delete(descriptor.id);
-            if (this._activeCustomView.get() === descriptor) {
-                this._activeCustomView.set(undefined, undefined);
+            if (this.activeCustomView.get() === descriptor) {
+                this._activeCustomViewOpen.set(undefined, undefined);
             }
         });
     }
-    showCustomView(id) {
+    showCustomView(id, options) {
         const descriptor = this._descriptors.get(id);
         if (!descriptor) {
             this._logService.warn(
@@ -55,12 +60,15 @@ let CustomViewService = class CustomViewService extends Disposable {
             StorageScope.WORKSPACE,
             StorageTarget.MACHINE
         );
-        this._activeCustomView.set(descriptor, undefined);
+        this._activeCustomViewOpen.set({
+            descriptor,
+            source: options?.source ?? "explicit"
+        }, undefined);
     }
-    hideCustomView() {
+    hideCustomView(tx) {
         this._desiredCustomViewId = undefined;
         this._storageService.remove(ACTIVE_CUSTOM_VIEW_STORAGE_KEY, StorageScope.WORKSPACE);
-        this._activeCustomView.set(undefined, undefined);
+        this._activeCustomViewOpen.set(undefined, tx);
     }
 };
 CustomViewService = ( __decorate([( __param(0, ILogService)), ( __param(1, IStorageService))], CustomViewService));

package/vscode/src/vs/sessions/services/sessions/browser/closedItemHistory.d.ts

@@ -5,6 +5,7 @@ import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/servic
 import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
 import { ISessionsPartService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service";
 import { VisibleSessions } from "./visibleSessions.js";
+import { Direction } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid";
 export declare enum ClosedItemKind {
     Chat = "chat",
     Session = "session"
@@ -22,6 +23,10 @@ export interface IClosedSessionItem {
     /** Grid index the slot occupied when the session left the grid. */
     readonly index: number;
     readonly sticky: boolean;
+    readonly placement?: {
+        readonly sessionId: string | undefined;
+        readonly direction: Direction;
+    };
     /**
      * Set when the session left the grid because a newly opened slot took its
      * place, holding the id of that slot (`undefined` for the empty

package/vscode/src/vs/sessions/services/sessions/browser/closedItemHistory.js

@@ -7,8 +7,10 @@ import { SessionsHasClosedItemContext } from '@codingame/monaco-vscode-api/vscod
 import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
 import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
 import { ISessionsPartService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service';
+import { Direction } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
 
 var ClosedItemKind;
 (function(ClosedItemKind) {
@@ -73,7 +75,7 @@ let ClosedItemHistory = class ClosedItemHistory extends Disposable {
             if (item.kind === ClosedItemKind.Chat) {
                 await this._openChat(session, item.chatResource);
             } else {
-                this._reopenSession(item, session);
+                transaction(() => this._reopenSession(item, session));
             }
         } finally {
             suspension.dispose();
@@ -87,7 +89,22 @@ let ClosedItemHistory = class ClosedItemHistory extends Disposable {
                 return;
             }
         }
+        if (!item.replacedBy && (!item.placement || !this._visibility.getSlot(item.placement.sessionId))) {
+            const active = this._visibility.setActive(session);
+            if (item.sticky && !active?.sticky.get()) {
+                this._visibility.toggleStickiness(session);
+            }
+            return;
+        }
         this._visibility.insertAtIndex(session, item.index, item.sticky);
+        if (item.placement && this._visibility.getSlot(item.placement.sessionId)) {
+            const direction = item.placement.direction;
+            this._visibility.insertAt(
+                session,
+                item.placement.sessionId,
+                direction === Direction.Left ? "left" : direction === Direction.Right ? "right" : direction === Direction.Up ? "up" : "down"
+            );
+        }
     }
     _recordSession(session, index, sticky, replacedBy) {
         if (session.status.get() !== SessionStatus.Untitled) {
@@ -96,7 +113,8 @@ let ClosedItemHistory = class ClosedItemHistory extends Disposable {
                 session,
                 index,
                 sticky,
-                replacedBy
+                replacedBy,
+                placement: this._sessionsPartService.getSessionPlacement(session.sessionId)
             });
         }
     }