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

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

@@ -32,10 +32,18 @@ import { IsNewChatSessionContext } from '@codingame/monaco-vscode-api/vscode/vs/
 import { setActiveSessionContextKeys } from '../common/sessionContextKeys.js';
 import { ISessionChangesStatsCache } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionChangesStatsCache.service';
 import { ISessionOpenTelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionOpenTelemetryService.service';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { Direction } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/grid/grid';
+import { projectSessionGrid, isSessionGridState } from './sessionGridState.js';
 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';
 
 const ACTIVE_SESSION_STATES_KEY = "agentSessions.activeSessionStates";
+const SESSION_GRID_STATE_KEY = "agentSessions.gridState";
+function toSessionGridDirection(direction) {
+    return direction === Direction.Left ? "left" : direction === Direction.Right ? "right" : direction === Direction.Up ? "up" : "down";
+}
 const RESTORE_RESOLVE_BUDGET_MS = 10_000;
 const RESTORE_SESSION_WAIT_TIMEOUT = 30_000;
 const MAX_RECENTLY_OPENED_SESSIONS = 10;
@@ -71,6 +79,7 @@ let SessionsService = class SessionsService extends Disposable {
         this.sessionOpenTelemetryService = sessionOpenTelemetryService;
         this._onDidToggleSessionStickiness = this._register(( new Emitter()));
         this.onDidToggleSessionStickiness = this._onDidToggleSessionStickiness.event;
+        this._gridRequest = observableValue(this, undefined);
         this._initialRestoreComplete = observableValue(this, false);
         this.initialRestoreComplete = this._initialRestoreComplete;
         this._navigationRequest = observableValue(this, undefined);
@@ -78,6 +87,7 @@ let SessionsService = class SessionsService extends Disposable {
         this._openSessionCts = this._register(( new MutableDisposable()));
         this._restoreCts = this._register(( new MutableDisposable()));
         this._pendingRestoredChatResources = ( new ResourceMap());
+        this._pendingExplicitChatOpens = ( new ResourceMap());
         this._sendFollow = this._register(( new MutableDisposable()));
         this._sessionStates = this._loadSessionStates();
         this._visibility = this._register(this.instantiationService.createInstance(
@@ -97,20 +107,31 @@ let SessionsService = class SessionsService extends Disposable {
         this._isNewChatSessionContext = IsNewChatSessionContext.bindTo(this.contextKeyService);
         this._register(this.storageService.onWillSaveState(() => this._saveSessionStates()));
         this._recencyHistory = this._register(( new SessionsRecencyHistory(this.storageService, this.logService)));
-        this._navigation = this._register(( new SessionsNavigation(
-            this,
-            this.activeSession,
-            this.sessionsManagementService,
-            this._recencyHistory,
-            this.contextKeyService,
-            this.logService
-        )));
+        this._navigation = this._register(( new SessionsNavigation({
+            openSession: (resource, options) => this._openSession(resource, options, "history"),
+            openChat: (session, resource) => this._openChatSession(session, resource, {
+                source: "navigation"
+            }, "history"),
+            openNewSession: async () => {
+                await this._openNewSession({
+                    cancelRestore: true
+                }, CancellationToken.None, "history");
+            }
+        }, this.activeSession, this.customViewService, this.sessionsManagementService, this._recencyHistory, this.contextKeyService, this.logService)));
         this._register(
             this.sessionsManagementService.onDidChangeSessions(e => this._navigation.onDidRemoveSessions(e))
         );
         this._register(
-            this.sessionsManagementService.onDidDeleteSession(session => this._recencyHistory.remove(entry => ( entry.sessionResource.toString()) === ( session.resource.toString())))
+            this.sessionsManagementService.onDidDeleteSession(session => this._recencyHistory.remove(
+                entry => entry.kind === "session" && this.uriIdentityService.extUri.isEqual(entry.sessionResource, session.resource)
+            ))
         );
+        this._register(autorun(reader => {
+            if (this.customViewService.activeCustomViewOpen.read(reader)) {
+                this._openSessionCts.value?.cancel();
+                this._recordNavigation();
+            }
+        }));
         this._register(autorun(reader => {
             const activeSession = this.activeSession.read(reader);
             const newSession = this.sessionsManagementService.newSession.read(reader);
@@ -125,12 +146,6 @@ let SessionsService = class SessionsService extends Disposable {
                 reader.store.add(this._activeSessionViewListeners(activeSession));
             }
         }));
-        this._register(autorun(reader => {
-            const activeSession = this.activeSession.read(reader);
-            if (activeSession && !activeSession.isRead.read(reader)) {
-                this.sessionsManagementService.markRead(activeSession);
-            }
-        }));
         this._register(
             this.sessionsManagementService.onDidChangeSessions(e => this._onDidChangeSessions(e))
         );
@@ -156,10 +171,10 @@ let SessionsService = class SessionsService extends Disposable {
             const visible = this.visibleSessions.read(reader);
             const active = this._visibility.activeSession.read(reader);
             const preserveFocus = this._visibility.activePreserveFocus.read(reader);
-            this.sessionsPartService.updateVisibleSessions(visible, active);
-            const activeId = active?.sessionId;
-            if (activeId !== this._focusedActiveSessionId) {
-                this._focusedActiveSessionId = activeId;
+            const request = this._gridRequest.read(reader);
+            this.sessionsPartService.updateVisibleSessions(visible, active, this._visibility.getGridSlots(), request);
+            if (active !== this._focusedActiveSession) {
+                this._focusedActiveSession = active;
                 if (!preserveFocus) {
                     this.sessionsPartService.focusSession(active);
                 }
@@ -167,13 +182,19 @@ let SessionsService = class SessionsService extends Disposable {
         }));
         this._register(this.sessionsPartService.onDidFocusSession(sessionId => {
             const session = this.visibleSessions.get().find(s => s?.sessionId === sessionId);
-            if (session) {
+            if (sessionId === undefined || session) {
                 this.setActive(session);
             }
         }));
+        this._register(this.sessionsPartService.onDidInteractWithGrid(() => {
+            this._cancelRestore();
+            this._startOpenSession();
+        }));
     }
     _onDidReplaceSession(from, to) {
-        this._visibility.updateSession(from, to);
+        const sessionView = this.sessionsPartService.getSessionView(from.sessionId);
+        const preserveFocus = !sessionView || this.sessionsPartService.getFocusedSessionView() !== sessionView;
+        this._visibility.updateSession(from, to, preserveFocus);
     }
     _activeSessionViewListeners(activeSession) {
         const disposables = ( new DisposableStore());
@@ -260,6 +281,50 @@ let SessionsService = class SessionsService extends Disposable {
                 });
             }
         }));
+        let previousActiveChat;
+        let lastReadRequest;
+        disposables.add(autorun(reader => {
+            const chat = activeSession.activeChat.read(reader);
+            const mainChat = activeSession.mainChat.read(reader);
+            const activeChatChanged = !chat || !previousActiveChat || !this.uriIdentityService.extUri.isEqual(chat.resource, previousActiveChat);
+            previousActiveChat = chat?.resource;
+            if (activeChatChanged) {
+                lastReadRequest = undefined;
+            }
+            if (activeSession.loading.read(reader)) {
+                lastReadRequest = undefined;
+                return;
+            }
+            if (!chat || chat.isRead.read(reader)) {
+                return;
+            }
+            const pendingExplicitChat = this._pendingExplicitChatOpens.get(activeSession.resource)?.chatResource;
+            if (pendingExplicitChat && !this.uriIdentityService.extUri.isEqual(chat.resource, pendingExplicitChat)) {
+                return;
+            }
+            const version = (chat.lastTurnEnd?.read(reader) ?? chat.updatedAt.read(reader))?.getTime();
+            if (lastReadRequest && this.uriIdentityService.extUri.isEqual(lastReadRequest.chat, chat.resource) && lastReadRequest.version === version) {
+                return;
+            }
+            const readRequest = {
+                chat: chat.resource,
+                version
+            };
+            lastReadRequest = readRequest;
+            const accepted = this.uriIdentityService.extUri.isEqual(chat.resource, mainChat.resource) ? this.sessionsManagementService.markRead(activeSession, {
+                preserveExplicitUnread: !activeChatChanged
+            }) : this.sessionsManagementService.markChatRead(activeSession, chat);
+            accepted.then(result => {
+                if (result === false && lastReadRequest === readRequest) {
+                    lastReadRequest = undefined;
+                }
+            }, error => {
+                if (lastReadRequest === readRequest) {
+                    lastReadRequest = undefined;
+                }
+                onUnexpectedError(error);
+            });
+        }));
         return disposables;
     }
     _onDidChangeSessions(e) {
@@ -316,6 +381,9 @@ let SessionsService = class SessionsService extends Disposable {
             if (recent.length >= MAX_RECENTLY_OPENED_SESSIONS) {
                 break;
             }
+            if (entry.kind !== "session") {
+                continue;
+            }
             const key = ( entry.sessionResource.toString());
             if (( seen.has(key))) {
                 continue;
@@ -339,11 +407,10 @@ let SessionsService = class SessionsService extends Disposable {
         return cts.token;
     }
     _beginNavigation(intent, token = CancellationToken.None, preserveNavigation = false) {
-        if (intent === "explicit") {
+        if (intent !== "automatic") {
             if (!preserveNavigation) {
                 this._recordNavigation(token);
             }
-            this.customViewService.hideCustomView();
         }
     }
     _recordNavigation(token = CancellationToken.None) {
@@ -354,9 +421,17 @@ let SessionsService = class SessionsService extends Disposable {
     _cancelRestore() {
         this._restoreCts.value?.cancel();
         this._restoreCts.clear();
+        this._restoringGridState = undefined;
     }
-    _activate(session, preserveFocus) {
-        return this._visibility.setActive(session, preserveFocus);
+    _activate(session, preserveFocus, intent = "automatic") {
+        let active;
+        transaction(tx => {
+            if (intent !== "automatic") {
+                this.customViewService.hideCustomView(tx);
+            }
+            active = this._visibility.setActive(session, preserveFocus);
+        });
+        return active;
     }
     openChat(session, chatUri, options) {
         return this._openChatSession(session, chatUri, options, "explicit");
@@ -366,66 +441,99 @@ let SessionsService = class SessionsService extends Disposable {
         this._cancelRestore();
         this._beginNavigation(intent);
         const token = this._startOpenSession();
-        const resolved = await this._resolveSessionForOpen(session, chatUri);
-        if (token.isCancellationRequested) {
-            return;
-        }
-        session = resolved.session;
-        chatUri = resolved.chatUri ?? chatUri;
-        if (options?.source) {
-            await this.sessionOpenTelemetryService.withOpenRequest(
-                options.source,
-                token,
-                telemetryAttempt => this._openChat(session, chatUri, options.preserveFocus, token, t0, telemetryAttempt)
-            );
-            return;
+        const navigation = this._navigation.beginSessionOpen(intent, token);
+        try {
+            const resolved = await this._resolveSessionForOpen(session, chatUri);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            session = resolved.session;
+            chatUri = resolved.chatUri ?? chatUri;
+            if (options?.source) {
+                await this.sessionOpenTelemetryService.withOpenRequest(options.source, token, async telemetryAttempt => {
+                    this.sessionOpenTelemetryService.sessionResolved(
+                        telemetryAttempt,
+                        session.resource,
+                        session.providerId,
+                        this.activeSession.get()?.sessionId === session.sessionId,
+                        session.loading.get()
+                    );
+                    await this._openChat(
+                        session,
+                        chatUri,
+                        options.preserveFocus,
+                        token,
+                        t0,
+                        telemetryAttempt,
+                        intent
+                    );
+                });
+                return;
+            }
+            await this._openChat(session, chatUri, options?.preserveFocus, token, t0, undefined, intent);
+        } finally {
+            navigation.cancel();
         }
-        await this._openChat(session, chatUri, options?.preserveFocus, token, t0);
     }
-    async _openChat(session, chatUri, preserveFocus, token, startTime, telemetryAttempt) {
-        if (telemetryAttempt) {
-            this.sessionOpenTelemetryService.sessionResolved(
-                telemetryAttempt,
-                session.resource,
-                session.providerId,
-                this.activeSession.get()?.sessionId === session.sessionId,
-                session.loading.get()
-            );
-            this.sessionOpenTelemetryService.sessionActivated(telemetryAttempt, chatUri);
-        }
-        this.logService.trace(`[SessionsView] openChat start uri=${( chatUri.toString())} provider=${session.providerId}`);
-        this._activate(session, preserveFocus);
-        if (!(await this._waitForSessionToLoad(session, token))) {
-            this.logService.trace(
-                `[SessionsView] openChat cancelled while waiting for session to load uri=${( chatUri.toString())}`
-            );
-            return;
-        }
-        let chat;
-        const activeSession = this._visibility.activeSession.get();
-        if (activeSession) {
-            chat = activeSession.chats.get().find(c => this.uriIdentityService.extUri.isEqual(c.resource, chatUri));
-            if (chat) {
-                this._visibility.openChat(session, chat);
-                this._visibility.setActiveChat(session, chat);
-                this._setChatVisibilityState(session, chat, true);
+    async _openChat(
+        session,
+        chatUri,
+        preserveFocus,
+        token,
+        startTime,
+        telemetryAttempt,
+        intent = "explicit"
+    ) {
+        const pendingOpen = {
+            chatResource: chatUri,
+            token
+        };
+        this._pendingExplicitChatOpens.set(session.resource, pendingOpen);
+        const navigation = this._navigation.beginSessionOpen(intent, token);
+        try {
+            if (telemetryAttempt) {
+                this.sessionOpenTelemetryService.sessionActivated(telemetryAttempt, chatUri);
             }
-        }
-        if (telemetryAttempt) {
-            if (chat) {
-                this.sessionOpenTelemetryService.sessionActivated(telemetryAttempt, chat.resource);
+            this.logService.trace(`[SessionsView] openChat start uri=${( chatUri.toString())} provider=${session.providerId}`);
+            this._activate(session, preserveFocus, intent);
+            if (!(await this._waitForSessionToLoad(session, token))) {
+                this.logService.trace(
+                    `[SessionsView] openChat cancelled while waiting for session to load uri=${( chatUri.toString())}`
+                );
+                return;
+            }
+            let chat;
+            const activeSession = this._visibility.activeSession.get();
+            if (activeSession) {
+                chat = activeSession.chats.get().find(c => this.uriIdentityService.extUri.isEqual(c.resource, chatUri));
+                if (chat) {
+                    this._visibility.openChat(session, chat);
+                    this._visibility.setActiveChat(session, chat);
+                    this._setChatVisibilityState(session, chat, true);
+                }
+            }
+            navigation.complete();
+            if (telemetryAttempt) {
+                if (chat) {
+                    this.sessionOpenTelemetryService.sessionActivated(telemetryAttempt, chat.resource);
+                }
+                this.sessionOpenTelemetryService.sessionLoaded(telemetryAttempt);
+            }
+            if (chat && chat.status.get() === SessionStatus.Untitled) {
+                this.logService.trace(
+                    `[SessionsView] openChat done total=${Date.now() - startTime}ms uri=${( chatUri.toString())} path=untitled`
+                );
+                return;
             }
-            this.sessionOpenTelemetryService.sessionLoaded(telemetryAttempt);
-        }
-        if (chat && chat.status.get() === SessionStatus.Untitled) {
             this.logService.trace(
-                `[SessionsView] openChat done total=${Date.now() - startTime}ms uri=${( chatUri.toString())} path=untitled`
+                `[SessionsView] openChat done total=${Date.now() - startTime}ms uri=${( chatUri.toString())}`
             );
-            return;
+        } finally {
+            if (this._pendingExplicitChatOpens.get(session.resource) === pendingOpen) {
+                this._pendingExplicitChatOpens.delete(session.resource);
+            }
+            navigation.cancel();
         }
-        this.logService.trace(
-            `[SessionsView] openChat done total=${Date.now() - startTime}ms uri=${( chatUri.toString())}`
-        );
     }
     async closeChat(session, chat, options) {
         this._visibility.closeChat(session, chat);
@@ -435,6 +543,8 @@ let SessionsService = class SessionsService extends Disposable {
         }
     }
     reopenLastClosedItem() {
+        this._cancelRestore();
+        this._startOpenSession();
         return this._closedItems.reopenLast();
     }
     _setChatVisibilityState(session, chat, visible) {
@@ -462,12 +572,12 @@ let SessionsService = class SessionsService extends Disposable {
             openedChatResources: openedChatResources.size ? [...openedChatResources] : undefined
         });
     }
-    _applyActiveChatSelection(session, restoreOnlySideOrToolChat) {
-        if (!restoreOnlySideOrToolChat) {
+    _applyActiveChatSelection(session, options) {
+        if (!options?.forceMainChat && !options?.restoreOnlySideOrToolChat) {
             return;
         }
         const state = this._sessionStates.get(session.resource);
-        if (state?.activeChatOrigin === ChatOriginKind.SideChat || state?.activeChatOrigin === ChatOriginKind.Tool) {
+        if (!options.forceMainChat && (state?.activeChatOrigin === ChatOriginKind.SideChat || state?.activeChatOrigin === ChatOriginKind.Tool)) {
             return;
         }
         const mainChat = session.mainChat.get();
@@ -487,27 +597,35 @@ let SessionsService = class SessionsService extends Disposable {
         this._cancelRestore();
         this._beginNavigation(intent);
         const token = this._startOpenSession();
-        await this.sessionOpenTelemetryService.withOpenRequest(options?.source ?? "unknown", token, async telemetryAttempt => {
-            const resolved = await this.sessionsManagementService.resolveSessionResource(sessionResource, "open");
-            if (token.isCancellationRequested) {
-                return;
-            }
-            const sessionData = this._getSession(resolved);
-            await this.sessionsProvidersService.getProvider(sessionData.providerId)?.prepareSessionForOpen?.(sessionData, "open");
-            if (token.isCancellationRequested) {
-                return;
-            }
-            this._applyActiveChatSelection(sessionData, options?.restoreOnlySideOrToolChat);
-            this.sessionOpenTelemetryService.sessionResolved(
-                telemetryAttempt,
-                sessionData.resource,
-                sessionData.providerId,
-                this.activeSession.get()?.sessionId === sessionData.sessionId,
-                sessionData.loading.get()
-            );
-            this._showSession(sessionData, options);
-            await this._waitForOpenSessionToLoad(sessionData, token, telemetryAttempt);
-        });
+        const navigation = this._navigation.beginSessionOpen(intent, token);
+        try {
+            await this.sessionOpenTelemetryService.withOpenRequest(options?.source ?? "unknown", token, async telemetryAttempt => {
+                const resolved = await this.sessionsManagementService.resolveSessionResource(sessionResource, "open");
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                const sessionData = this._getSession(resolved);
+                this._applyActiveChatSelection(sessionData, options);
+                this.sessionOpenTelemetryService.sessionResolved(
+                    telemetryAttempt,
+                    sessionData.resource,
+                    sessionData.providerId,
+                    this.activeSession.get()?.sessionId === sessionData.sessionId,
+                    sessionData.loading.get()
+                );
+                this._showSession(sessionData, options, intent);
+                if (intent !== "history") {
+                    navigation.complete();
+                }
+                await this.sessionsProvidersService.getProvider(sessionData.providerId)?.prepareSessionForOpen?.(sessionData, "open");
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                await this._waitForOpenSessionToLoad(sessionData, token, telemetryAttempt);
+            });
+        } finally {
+            navigation.cancel();
+        }
     }
     showSession(sessionResource, options) {
         this._cancelRestore();
@@ -533,7 +651,7 @@ let SessionsService = class SessionsService extends Disposable {
             const trusted = await this.workspaceTrustRequestService.requestResourcesTrust({
                 uri: folder,
                 message: ( localize(
-                    5027,
+                    6342,
                     "An agent session will be able to read files, run commands, and make changes in this folder."
                 ))
             });
@@ -544,8 +662,11 @@ let SessionsService = class SessionsService extends Disposable {
         return true;
     }
     async openSessionToSide(session, options) {
+        const referenceWasVisible = options?.referenceSessionId !== undefined && !!this._visibility.getSlot(options.referenceSessionId);
+        this._cancelRestore();
         this._beginNavigation("explicit");
         const token = this._startOpenSession();
+        session = this.sessionsManagementService.getSession(session.resource) ?? session;
         const resolved = await this._resolveSessionForOpen(session, options?.chatResource);
         if (token.isCancellationRequested) {
             return;
@@ -557,33 +678,241 @@ let SessionsService = class SessionsService extends Disposable {
                 chatResource: resolved.chatUri
             };
         }
+        if (!this.areGridSessionsCurrent([session]) || !(await this.canOpenSession(session)) || token.isCancellationRequested || !this.areGridSessionsCurrent([session])) {
+            return;
+        }
+        await this.sessionsProvidersService.getProvider(session.providerId)?.prepareSessionForOpen?.(session, "open");
+        if (token.isCancellationRequested || !this.areGridSessionsCurrent([session])) {
+            return;
+        }
         const visible = this.visibleSessions.get();
-        const lastVisible = visible[visible.length - 1];
-        if (lastVisible && lastVisible.sessionId !== session.sessionId) {
-            this.insertAt(session, lastVisible.sessionId, "right");
-        }
-        if (options?.chatResource) {
-            await this.openChat(session, options.chatResource, {
-                preserveFocus: options.preserveFocus,
-                source: options.source
+        if (referenceWasVisible && !this._visibility.getSlot(options?.referenceSessionId)) {
+            return;
+        }
+        if (options?.forceMainChat && !options.chatResource && ( visible.some(candidate => candidate?.sessionId === session.sessionId))) {
+            await this.openChatToSide(session, session.mainChat.get().resource, {
+                preserveFocus: options.preserveFocus
             });
-        } else {
-            await this.openSession(session.resource, {
-                preserveFocus: options?.preserveFocus,
-                source: options?.source,
-                restoreOnlySideOrToolChat: options?.restoreOnlySideOrToolChat
+            return;
+        }
+        const reference = visible.find(candidate => candidate?.sessionId === options?.referenceSessionId) ?? visible[visible.length - 1];
+        const navigation = this._navigation.beginSessionOpen("explicit", token);
+        try {
+            await this.sessionOpenTelemetryService.withOpenRequest(options?.source ?? "unknown", token, async attempt => {
+                if (token.isCancellationRequested || !this.areGridSessionsCurrent([session])) {
+                    return;
+                }
+                this.sessionOpenTelemetryService.sessionResolved(
+                    attempt,
+                    session.resource,
+                    session.providerId,
+                    this.activeSession.get()?.sessionId === session.sessionId,
+                    session.loading.get()
+                );
+                transaction(() => {
+                    if (reference && reference.sessionId !== session.sessionId) {
+                        this._visibility.insertAt(session, reference.sessionId, "right", false);
+                    }
+                    this._applyActiveChatSelection(session, options);
+                    this._showSession(session, options);
+                });
+                if (options?.chatResource) {
+                    await this._openChat(
+                        session,
+                        options.chatResource,
+                        options.preserveFocus,
+                        token,
+                        Date.now(),
+                        attempt
+                    );
+                } else {
+                    navigation.complete();
+                    await this._waitForOpenSessionToLoad(session, token, attempt);
+                }
             });
+        } finally {
+            navigation.cancel();
         }
     }
-    async openChatToSide(session, chatResource, options) {
+    async prepareGridSessions(sessions, token) {
+        const result = [];
+        const ids = ( new Set());
+        const candidates = sessions.map(
+            candidate => this.sessionsManagementService.getSession(candidate.resource) ?? candidate
+        );
+        for (const candidate of candidates) {
+            const {
+                session
+            } = await this._resolveSessionForOpen(candidate, undefined);
+            if (token.isCancellationRequested || !this.areGridSessionsCurrent([session])) {
+                return undefined;
+            }
+            if (( ids.has(session.sessionId))) {
+                continue;
+            }
+            if (!this._visibility.getSlot(session.sessionId)) {
+                if (!(await this.canOpenSession(session)) || token.isCancellationRequested || !this.areGridSessionsCurrent([session])) {
+                    return undefined;
+                }
+                await this.sessionsProvidersService.getProvider(session.providerId)?.prepareSessionForOpen?.(session, "open");
+                if (token.isCancellationRequested) {
+                    return undefined;
+                }
+            }
+            ids.add(session.sessionId);
+            result.push(session);
+        }
+        return result;
+    }
+    areGridSessionsCurrent(sessions) {
+        if (( sessions.some(
+            session => this.sessionsManagementService.getSession(session.resource) !== session
+        ))) {
+            this.logService.trace(
+                "[SessionsView] Cancelled grid opening because a candidate was removed or replaced"
+            );
+            return false;
+        }
+        return true;
+    }
+    async openSessionsAt(sessions, referenceSessionId, direction, options) {
+        this._cancelRestore();
         this._beginNavigation("explicit");
         const token = this._startOpenSession();
-        const resolved = await this._resolveSessionForOpen(session, chatResource);
-        if (token.isCancellationRequested) {
+        const prepared = await this.prepareGridSessions(sessions, token);
+        if (!prepared || token.isCancellationRequested || !this._visibility.getSlot(referenceSessionId) || !this.areGridSessionsCurrent(prepared)) {
             return;
         }
-        session = resolved.session;
-        chatResource = resolved.chatUri ?? chatResource;
+        const primary = options?.activate === "last" ? prepared.at(-1) : prepared[0];
+        if (!primary) {
+            return;
+        }
+        const splitMainChat = options?.activate !== false && options?.forceMainChat && !!this._visibility.getSlot(primary.sessionId);
+        const entries = prepared.filter(
+            session => session.sessionId !== referenceSessionId && (!splitMainChat || session !== primary)
+        );
+        const open = async attempt => {
+            if (token.isCancellationRequested || !this.areGridSessionsCurrent(prepared)) {
+                return;
+            }
+            if (attempt) {
+                this.sessionOpenTelemetryService.sessionResolved(
+                    attempt,
+                    primary.resource,
+                    primary.providerId,
+                    this.activeSession.get()?.sessionId === primary.sessionId,
+                    primary.loading.get()
+                );
+            }
+            const navigation = splitMainChat ? this._navigation.beginSessionOpen("explicit", token) : undefined;
+            try {
+                transaction(tx => {
+                    this.customViewService.hideCustomView(tx);
+                    const ordered = direction === "right" || direction === "down" ? [...entries].reverse() : entries;
+                    for (const session of ordered) {
+                        this._visibility.insertAt(session, referenceSessionId, direction, false);
+                    }
+                    if (options?.activate !== false) {
+                        if (!splitMainChat) {
+                            this._applyActiveChatSelection(primary, options);
+                        }
+                        this._showSession(primary, options);
+                    }
+                });
+                if (splitMainChat) {
+                    await this._showChatToSide(primary, primary.mainChat.get().resource, options);
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                    navigation?.complete();
+                }
+                if (options?.activate !== false && !options?.preserveFocus) {
+                    this.sessionsPartService.focusSession(this.activeSession.get());
+                }
+                if (attempt) {
+                    await this._waitForOpenSessionToLoad(primary, token, attempt);
+                }
+            } finally {
+                navigation?.cancel();
+            }
+        };
+        if (options?.source && options.activate !== false) {
+            await this.sessionOpenTelemetryService.withOpenRequest(options.source, token, open);
+        } else {
+            await open();
+        }
+    }
+    async openSessionsInGrid(sessions) {
+        this._cancelRestore();
+        this._beginNavigation("explicit");
+        const token = this._startOpenSession();
+        const prepared = await this.prepareGridSessions(sessions, token);
+        if (!prepared || token.isCancellationRequested || !prepared.length || !this.areGridSessionsCurrent(prepared)) {
+            return;
+        }
+        const active = this.activeSession.get();
+        const slots = prepared.map(session => ({
+            session,
+            sticky: this._visibility.getSlot(session.sessionId)?.sticky ?? false
+        }));
+        transaction(tx => {
+            this.customViewService.hideCustomView(tx);
+            this._visibility.restoreGrid(
+                slots,
+                Math.max(0, prepared.findIndex(session => session.sessionId === active?.sessionId))
+            );
+            this._gridRequest.set({
+                type: "arrange"
+            }, tx);
+        });
+    }
+    arrangeSessions() {
+        this._cancelRestore();
+        this._startOpenSession();
+        this._gridRequest.set({
+            type: "arrange"
+        }, undefined);
+    }
+    focusSessionInDirection(session, direction) {
+        this._cancelRestore();
+        this._startOpenSession();
+        const neighbor = this.sessionsPartService.getNeighborSession(session?.sessionId, direction);
+        if (neighbor !== undefined) {
+            this.setActive(neighbor ?? undefined);
+            this.sessionsPartService.focusSession(neighbor ?? undefined);
+        }
+    }
+    moveSessionInDirection(session, direction) {
+        this._cancelRestore();
+        this._startOpenSession();
+        const neighbor = this.sessionsPartService.getNeighborSession(session?.sessionId, direction);
+        if (neighbor !== undefined) {
+            this.insertAt(session, neighbor?.sessionId, toSessionGridDirection(direction));
+        }
+    }
+    resizeSession(session, direction) {
+        this._cancelRestore();
+        this._startOpenSession();
+        this.sessionsPartService.resizeSession(session?.sessionId, direction, 40);
+    }
+    async openChatToSide(session, chatResource, options) {
+        this._beginNavigation("explicit");
+        const token = this._startOpenSession();
+        const navigation = this._navigation.beginSessionOpen("explicit", token);
+        try {
+            const resolved = await this._resolveSessionForOpen(session, chatResource);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            session = resolved.session;
+            chatResource = resolved.chatUri ?? chatResource;
+            await this._showChatToSide(session, chatResource, options);
+            navigation.complete();
+        } finally {
+            navigation.cancel();
+        }
+    }
+    async _showChatToSide(session, chatResource, options) {
         this._showSession(this._getSession(session.resource), options);
         const sessionView = this.sessionsPartService.getSessionView(session.sessionId);
         if (!sessionView) {
@@ -591,7 +920,7 @@ let SessionsService = class SessionsService extends Disposable {
                 `Unable to open chat to the side because session view '${session.sessionId}' is not mounted`
             ));
         }
-        await sessionView.openChatToSide(chatResource);
+        await sessionView.openChatToSide(chatResource, options?.referenceChatResource);
     }
     async _resolveSessionForOpen(session, chatUri) {
         const resolved = await this.sessionsManagementService.resolveSessionResource(session.resource, "open");
@@ -621,10 +950,10 @@ let SessionsService = class SessionsService extends Disposable {
         }
         return sessionData;
     }
-    _showSession(sessionData, options) {
+    _showSession(sessionData, options, intent = "explicit") {
         const t0 = Date.now();
         this.logService.trace(`[SessionsView] openSession start uri=${( sessionData.resource.toString())} provider=${sessionData.providerId}`);
-        this._activate(sessionData, options?.preserveFocus);
+        this._activate(sessionData, options?.preserveFocus, intent);
         this.logService.trace(
             `[SessionsView] showSession done total=${Date.now() - t0}ms uri=${( sessionData.resource.toString())}`
         );
@@ -665,7 +994,7 @@ let SessionsService = class SessionsService extends Disposable {
                 const trusted = await this.workspaceTrustRequestService.requestResourcesTrust({
                     uri: folderUri,
                     message: ( localize(
-                        5027,
+                        6342,
                         "An agent session will be able to read files, run commands, and make changes in this folder."
                     ))
                 });
@@ -692,7 +1021,29 @@ let SessionsService = class SessionsService extends Disposable {
             this._startOpenSession();
             try {
                 const session = this.sessionsManagementService.createNewSession(folderUri, options);
-                this._activateOrInsert(session, options?.toSide);
+                if (options?.requireDevContainer) {
+                    const provider = this.sessionsProvidersService.getProvider(session.providerId);
+                    if (!provider || !isAgentHostProvider(provider) || !provider.preferDevContainer) {
+                        this.sessionsManagementService.discardNewSession(session);
+                        throw ( new Error(
+                            `Session provider '${session.providerId}' does not support Dev Container drafts.`
+                        ));
+                    }
+                    try {
+                        provider.preferDevContainer(session.sessionId, {
+                            required: true
+                        });
+                    } catch (error) {
+                        this.sessionsManagementService.discardNewSession(session);
+                        throw error;
+                    }
+                }
+                this._activateOrInsert(session, options?.toSide, intent);
+                if (intent === "explicit" && !options?.preserveNavigation) {
+                    this._navigation.recordOpened({
+                        kind: "newSession"
+                    });
+                }
                 return {
                     session,
                     trustDeclined: false
@@ -707,6 +1058,17 @@ let SessionsService = class SessionsService extends Disposable {
             this._beginNavigation(intent, token, options?.preserveNavigation);
         }
         if (this._visibility.activeSession.get() === undefined && !options?.toSide) {
+            if (intent !== "automatic") {
+                if (!folderUri && !options?.preserveNavigation) {
+                    this._startOpenSession();
+                }
+                this.customViewService.hideCustomView();
+            }
+            if (intent === "explicit" && !options?.preserveNavigation) {
+                this._navigation.recordOpened({
+                    kind: "newSession"
+                });
+            }
             return {
                 session: undefined,
                 trustDeclined: false
@@ -718,34 +1080,44 @@ let SessionsService = class SessionsService extends Disposable {
         const newSession = this.sessionsManagementService.newSession.get();
         const activeSession = this._visibility.activeSession.get();
         const targetSession = options?.toSide && newSession?.sessionId === activeSession?.sessionId ? undefined : newSession;
-        this._activateOrInsert(targetSession, options?.toSide);
+        this._activateOrInsert(targetSession, options?.toSide, intent);
+        if (intent === "explicit" && !options?.preserveNavigation) {
+            this._navigation.recordOpened({
+                kind: "newSession"
+            });
+        }
         return {
             session: targetSession,
             trustDeclined: false
         };
     }
-    _activateOrInsert(session, toSide) {
+    _activateOrInsert(session, toSide, intent) {
         const activeSessionId = this._visibility.activeSession.get()?.sessionId;
         const sessionId = session?.sessionId;
         if (toSide && activeSessionId !== sessionId) {
             const visible = this.visibleSessions.get();
             const anchorId = activeSessionId ?? visible[visible.length - 1]?.sessionId;
             if (anchorId && anchorId !== sessionId) {
-                this.insertAt(session, anchorId, "right", true);
+                transaction(tx => {
+                    if (intent !== "automatic") {
+                        this.customViewService.hideCustomView(tx);
+                    }
+                    this.insertAt(session, anchorId, "right", true);
+                });
                 return;
             }
         }
-        this._activate(session);
+        this._activate(session, undefined, intent);
     }
-    openQuickChat(options) {
-        return this._openQuickChat(options, "explicit");
+    openQuickChat(options, preserveNavigation = false) {
+        return this._openQuickChat(options, preserveNavigation ? "automatic" : "explicit");
     }
     _openQuickChat(options, intent) {
         this._beginNavigation(intent);
         this._startOpenSession();
         try {
             const session = this.sessionsManagementService.createQuickChat(options);
-            return this._activate(session);
+            return this._activate(session, undefined, intent);
         } catch (e) {
             this.logService.trace(`[SessionsView] openQuickChat: createQuickChat failed: ${e}`);
             return undefined;
@@ -754,16 +1126,24 @@ let SessionsService = class SessionsService extends Disposable {
     async openNewChatInSession(session, options) {
         this._cancelRestore();
         this._beginNavigation("explicit");
-        this._startOpenSession();
+        const token = this._startOpenSession();
         const chat = await this.sessionsManagementService.createNewChatInSession(session, options);
-        if (!chat) {
+        if (!chat || token.isCancellationRequested) {
             return;
         }
-        this._activate(session);
-        this._visibility.setActiveChat(session, chat);
+        const navigation = this._navigation.beginSessionOpen("explicit", token);
+        try {
+            this._activate(session, undefined, "explicit");
+            this._visibility.setActiveChat(session, chat);
+            navigation.complete();
+        } finally {
+            navigation.cancel();
+        }
     }
     setActive(session) {
         if (session?.sessionId !== this.activeSession.get()?.sessionId) {
+            this._cancelRestore();
+            this._startOpenSession();
             this._recordNavigation();
         }
         this._activate(session);
@@ -783,6 +1163,8 @@ let SessionsService = class SessionsService extends Disposable {
         return this.sessionsPartService.getSessionView(activeSession?.sessionId)?.submitInput() ?? false;
     }
     toggleSessionStickiness(session) {
+        this._cancelRestore();
+        this._startOpenSession();
         const sticky = this._visibility.toggleStickiness(session);
         this._onDidToggleSessionStickiness.fire({
             session,
@@ -790,9 +1172,13 @@ let SessionsService = class SessionsService extends Disposable {
         });
     }
     insertAt(session, targetSessionId, side, activate = true) {
+        this._cancelRestore();
+        this._startOpenSession();
         this._visibility.insertAt(session, targetSessionId, side, activate);
     }
     closeSession(session) {
+        this._cancelRestore();
+        this._startOpenSession();
         const sessionId = session?.sessionId;
         const visible = this._visibility.visibleSessions.get();
         if (!( visible.some(s => s?.sessionId === sessionId))) {
@@ -814,6 +1200,8 @@ let SessionsService = class SessionsService extends Disposable {
         }
     }
     closeAllSessions() {
+        this._cancelRestore();
+        this._startOpenSession();
         const ids = this._visibility.visibleSessions.get().filter(s => !!s).map(s => s.sessionId);
         if (ids.length === 0) {
             return;
@@ -823,7 +1211,7 @@ let SessionsService = class SessionsService extends Disposable {
     }
     _restoreInitialChat(session) {
         const chats = session.chats.get();
-        let initialChat = chats[0];
+        let initialChat = chats[0] ?? session.mainChat.get();
         const sessionState = this._sessionStates.get(session.resource);
         if (sessionState?.activeChatResource) {
             try {
@@ -913,6 +1301,70 @@ let SessionsService = class SessionsService extends Disposable {
             StorageScope.WORKSPACE,
             StorageTarget.MACHINE
         );
+        if (this._restoringGridState) {
+            this.storageService.store(
+                SESSION_GRID_STATE_KEY,
+                JSON.stringify(this._restoringGridState),
+                StorageScope.WORKSPACE,
+                StorageTarget.MACHINE
+            );
+            return;
+        }
+        const grid = this.sessionsPartService.getGridLayout();
+        if (grid) {
+            const visible = this.visibleSessions.get();
+            const slots = this._visibility.getGridSlots();
+            const activeId = this.activeSession.get()?.sessionId;
+            const activeIndex = Math.max(0, visible.findIndex(session => session?.sessionId === activeId));
+            const composerIndex = !visible[activeIndex]?.isCreated.get() ? activeIndex : visible.findIndex(session => !session?.isCreated.get());
+            const bindings = [];
+            for (let index = 0; index < slots.length; index++) {
+                const session = visible[index];
+                const resource = session?.isCreated.get() ? ( session.resource.toString()) : undefined;
+                if (!resource && index !== composerIndex) {
+                    continue;
+                }
+                bindings.push({
+                    id: slots[index].id,
+                    resource,
+                    sticky: resource ? session.sticky.get() : false
+                });
+            }
+            const projected = projectSessionGrid(grid, id => ( bindings.some(binding => binding.id === id)) ? id : undefined);
+            const active = slots[activeIndex].id;
+            if (projected) {
+                const state = {
+                    version: 1,
+                    grid: projected,
+                    sessions: bindings,
+                    active: ( bindings.some(binding => binding.id === active)) ? active : bindings[0].id
+                };
+                this.storageService.store(
+                    SESSION_GRID_STATE_KEY,
+                    JSON.stringify(state),
+                    StorageScope.WORKSPACE,
+                    StorageTarget.MACHINE
+                );
+            }
+        }
+    }
+    loadGridState() {
+        const raw = this.storageService.get(SESSION_GRID_STATE_KEY, StorageScope.WORKSPACE);
+        if (!raw) {
+            return undefined;
+        }
+        try {
+            const value = JSON.parse(raw);
+            if (isSessionGridState(value)) {
+                return value;
+            }
+            this.logService.warn(
+                "[SessionsView] Invalid or unsupported session grid state; restoring session order instead"
+            );
+        } catch (error) {
+            this.logService.warn("[SessionsView] Failed to read session grid state", error);
+        }
+        return undefined;
     }
     _snapshotVisibleSessionStates() {
         const activeId = this._visibility.activeSession.get()?.sessionId;
@@ -987,29 +1439,55 @@ let SessionsService = class SessionsService extends Disposable {
         }));
     }
     async restoreVisibleSessions() {
+        this._cancelRestore();
+        const cts = ( new CancellationTokenSource());
+        this._restoreCts.value = cts;
         try {
-            await this._restoreVisibleSessions();
+            await this._restoreVisibleSessions(cts.token);
         } finally {
+            if (this._restoreCts.value === cts) {
+                this._restoringGridState = undefined;
+                this._restoreCts.clear();
+            }
             this._initialRestoreComplete.set(true, undefined);
         }
     }
-    async _restoreVisibleSessions() {
-        const cts = ( new CancellationTokenSource());
-        this._restoreCts.value = cts;
-        const token = cts.token;
+    async _restoreVisibleSessions(token) {
+        const gridState = this.loadGridState();
+        this._restoringGridState = gridState;
         const persisted = this._getVisibleSessionStates();
-        const unresolved = persisted.map(state => ({
+        const unresolved = gridState ? gridState.sessions.map((binding, index) => ({
+            resource: binding.resource ? ( URI.parse(binding.resource)) : undefined,
+            isSticky: binding.sticky,
+            isActive: binding.id === gridState.active,
+            order: index,
+            gridId: binding.id
+        })) : persisted.map(state => ({
             resource: ( URI.parse(state.sessionResource)),
             isSticky: !!state.isSticky,
             isActive: !!state.isActive,
             order: state.visibleOrder
         }));
-        const targets = (await raceTimeout(Promise.all(persisted.map(async (state, index) => ({
-            resource: await this.sessionsManagementService.resolveSessionResource(( URI.parse(state.sessionResource)), "restore"),
-            isSticky: unresolved[index].isSticky,
-            isActive: unresolved[index].isActive,
-            order: unresolved[index].order
+        const redirected = (await raceTimeout(Promise.all(unresolved.map(async target => ({
+            ...target,
+            resource: target.resource ? await this.sessionsManagementService.resolveSessionResource(target.resource, "restore") : undefined
         }))), RESTORE_RESOLVE_BUDGET_MS)) ?? unresolved;
+        const targets = [];
+        const redirects = ( new Map());
+        for (const target of redirected) {
+            const duplicate = targets.find(
+                existing => this.uriIdentityService.extUri.isEqual(existing.resource, target.resource)
+            );
+            if (duplicate) {
+                duplicate.isSticky ||= target.isSticky;
+                duplicate.isActive ||= target.isActive;
+                if (target.gridId && duplicate.gridId) {
+                    redirects.set(target.gridId, duplicate.gridId);
+                }
+            } else {
+                targets.push(target);
+            }
+        }
         if (token.isCancellationRequested) {
             return;
         }
@@ -1027,7 +1505,51 @@ let SessionsService = class SessionsService extends Disposable {
             activeIdx = 0;
         }
         const resolved = ( new Array(targets.length)).fill(undefined);
+        const restoreResolved = preserveActive => {
+            const slots = [];
+            let activeIndex = -1;
+            const activeId = this.activeSession.get()?.sessionId;
+            for (let index = 0; index < targets.length; index++) {
+                const session = resolved[index];
+                if (session === undefined) {
+                    continue;
+                }
+                if (preserveActive ? session?.sessionId === activeId : index === activeIdx) {
+                    activeIndex = slots.length;
+                }
+                slots.push({
+                    session: session ?? undefined,
+                    sticky: targets[index].isSticky,
+                    gridId: targets[index].gridId
+                });
+            }
+            transaction(tx => {
+                this._visibility.restoreGrid(slots, Math.max(0, activeIndex));
+                if (gridState) {
+                    const ids = ( new Set(slots.map(slot => slot.gridId)));
+                    const grid = projectSessionGrid(gridState.grid, id => {
+                        const mapped = redirects.get(id) ?? id;
+                        return ( ids.has(mapped)) ? mapped : undefined;
+                    });
+                    if (grid) {
+                        this._gridRequest.set({
+                            type: "restore",
+                            grid
+                        }, tx);
+                    }
+                } else if (( persisted.some(state => state.gridLayout === "grid"))) {
+                    this._gridRequest.set({
+                        type: "arrange"
+                    }, tx);
+                }
+            });
+        };
         const place = (idx, session) => {
+            if (gridState) {
+                resolved[idx] = session;
+                restoreResolved(true);
+                return;
+            }
             let anchor;
             for (let j = idx - 1; j >= 0 && !anchor; j--) {
                 const neighbour = resolved[j];
@@ -1070,8 +1592,6 @@ let SessionsService = class SessionsService extends Disposable {
                 error
             ));
         }
-        const slots = [];
-        let activeSlotIndex = -1;
         for (let idx = 0; idx < targets.length; idx++) {
             const target = targets[idx];
             let session;
@@ -1086,15 +1606,8 @@ let SessionsService = class SessionsService extends Disposable {
                 continue;
             }
             resolved[idx] = session;
-            if (idx === activeIdx) {
-                activeSlotIndex = slots.length;
-            }
-            slots.push({
-                session: session ?? undefined,
-                sticky: target.isSticky
-            });
         }
-        this._visibility.restoreGrid(slots, activeSlotIndex);
+        restoreResolved(false);
         if (token.isCancellationRequested) {
             return;
         }
@@ -1118,4 +1631,4 @@ let SessionsService = class SessionsService extends Disposable {
 };
 SessionsService = ( __decorate([( __param(0, IStorageService)), ( __param(1, ILogService)), ( __param(2, IUriIdentityService)), ( __param(3, IContextKeyService)), ( __param(4, ISessionsManagementService)), ( __param(5, ISessionsProvidersService)), ( __param(6, ISessionsPartService)), ( __param(7, ICustomViewService)), ( __param(8, IInstantiationService)), ( __param(9, IWorkspaceTrustRequestService)), ( __param(10, IWorkspaceTrustManagementService)), ( __param(11, ISessionChangesStatsCache)), ( __param(12, ISessionOpenTelemetryService))], SessionsService));
 
-export { SessionsService };
+export { SessionsService, toSessionGridDirection };