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

package/vscode/src/vs/sessions/contrib/layout/browser/{singlePane/singlePaneExistingSessionStrategy.js → desktop/desktopExistingSessionStrategy.js}

@@ -16,21 +16,21 @@ import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/wor
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
 import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
-import { SinglePaneLayoutEnabledContext, HasDockedDetailsContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { DesktopLayoutContext, HasDockedDetailsContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
 import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
 import '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService';
 import { EmptyFileEditorInput } from '../../../editor/browser/emptyFileEditorInput.js';
-import { DetailPanelTarget } from './singlePaneDetailPanelCoordinator.js';
-import { isMainPartEmpty, isEditorWithoutDockedDetails, isChangesEditorInput, isFileEditorInput } from './singlePaneSharedHelpers.js';
-import { SinglePaneLayoutStrategy } from './singlePaneLayoutStrategy.js';
-import { SessionVisibilityProfile } from './singlePaneVisibilityProfileStore.js';
+import { DetailPanelTarget } from './desktopDetailPanelCoordinator.js';
+import { isMainPartEmpty, isEditorWithoutDockedDetails, isChangesEditorInput, getFilesDetailsState, FilesDetailsState } from './desktopSharedHelpers.js';
+import { DesktopLayoutStrategy } from './desktopLayoutStrategy.js';
+import { SessionVisibilityProfile } from './desktopVisibilityProfileStore.js';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
 import { ISessionChangesService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/sessionChangesService.service';
 
 const TOGGLE_DETAILS_COMMAND_ID = "workbench.action.agentSessions.toggleDetails";
-const singlePaneHeaderToggleDetailsOrder = 10;
-let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy extends SinglePaneLayoutStrategy {
+const desktopHeaderToggleDetailsOrder = 10;
+let DesktopExistingSessionStrategy = class DesktopExistingSessionStrategy extends DesktopLayoutStrategy {
     constructor(
         ctx,
         _visibilityStore,
@@ -81,7 +81,7 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
     get managedTabs() {
         if (!this._managedTabs) {
             throw ( new Error(
-                "SinglePaneExistingSessionStrategy: managed tabs accessed before registerManagedTabs()"
+                "DesktopExistingSessionStrategy: managed tabs accessed before registerManagedTabs()"
             ));
         }
         return this._managedTabs;
@@ -92,46 +92,58 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
         let previousQuickChatResource;
         let previousIsCreated;
         let previousSession;
+        let previousOwnerKey;
+        let wasSuspended = false;
         let togglingSidePane = false;
         this._register(autorun(reader => {
             const multipleSessionsVisible = this._ctx.multipleSessionsVisibleObs.read(reader);
             const activeSession = this._sessionsService.activeSession.read(reader);
+            activeSession?.activeChat.read(reader);
             const isQuickChat = activeSession?.isQuickChat?.read(reader) ?? false;
+            if (this._ctx.chatLayoutSuspended(reader)) {
+                wasSuspended = true;
+                return;
+            }
+            const resuming = wasSuspended;
+            wasSuspended = false;
             const wasQuickChatActive = previousQuickChatResource !== undefined;
             const isWorkspaceConversion = !isQuickChat && !!activeSession && isEqual(previousQuickChatResource, activeSession.resource);
             previousQuickChatResource = isQuickChat ? activeSession?.resource : undefined;
-            if (isWorkspaceConversion) {
+            if (isWorkspaceConversion && !this._ctx.sharedChatLayout) {
                 this._captureExistingProfile();
             }
+            const ownerKey = this._ctx.chatLayoutActive(reader) && activeSession ? this._ctx.ownerKeyFor(activeSession, reader) : undefined;
             if (multipleSessionsVisible) {
-                const workspace = activeSession?.workspace.read(reader);
+                const activeChat = activeSession?.activeChat.read(reader);
+                const workspace = activeChat?.workspace.read(reader);
                 const isCreated = activeSession?.isCreated.read(reader);
-                if (!isWorkspaceConversion && activeSession && !isQuickChat && workspace && isCreated === true) {
-                    this._ctx.withSessionLayoutRestore(
-                        () => this._reveal(this._visibilityStore.get(SessionVisibilityProfile.Existing))
-                    );
+                if ((!isWorkspaceConversion || this._ctx.sharedChatLayout) && activeSession && !isQuickChat && workspace && isCreated === true) {
+                    const resolved = this._resolveComposition(activeSession, ownerKey);
+                    this._ctx.withSessionLayoutRestore(() => this._apply(resolved, !ownerKey));
                 }
                 wasExistingActive = false;
+                previousOwnerKey = ownerKey;
                 return;
             }
             if (!activeSession) {
+                previousOwnerKey = ownerKey;
                 return;
             }
             if (isQuickChat) {
                 wasExistingActive = false;
+                previousOwnerKey = ownerKey;
                 return;
             }
             const isCreated = activeSession.isCreated.read(reader);
             const sessionChanged = previousSession !== undefined && !isEqual(previousSession.resource, activeSession.resource);
+            const ownerChanged = !sessionChanged && ownerKey !== undefined && (resuming || !isEqual(previousOwnerKey, ownerKey));
             const isSubmit = !wasQuickChatActive && previousIsCreated === false && isCreated && (previousSession === activeSession || previousSession?.isCreated.read(undefined) === true);
-            if (isSubmit) {
+            if (isSubmit && !this._ctx.sharedChatLayout) {
                 this._captureExistingProfile();
             }
             if (isCreated) {
-                if (!isSubmit && !isWorkspaceConversion && (!initialized || !wasExistingActive || wasQuickChatActive || sessionChanged)) {
-                    this._ctx.withSessionLayoutRestore(
-                        () => this._apply(this._visibilityStore.get(SessionVisibilityProfile.Existing))
-                    );
+                if ((this._ctx.sharedChatLayout && (isSubmit || isWorkspaceConversion)) || (!isSubmit && !isWorkspaceConversion && (!initialized || !wasExistingActive || wasQuickChatActive || sessionChanged || ownerChanged))) {
+                    this._ctx.withSessionLayoutRestore(() => this._apply(this._resolveComposition(activeSession, ownerKey)));
                 }
                 wasExistingActive = true;
             } else {
@@ -139,6 +151,7 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
             }
             previousIsCreated = isCreated;
             previousSession = activeSession;
+            previousOwnerKey = ownerKey;
             initialized = true;
         }));
         this._register(this._layoutService.onDidChangePartVisibility(e => {
@@ -152,39 +165,111 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
         }));
         this._register(this._layoutService.onWillToggleSidePane(() => {
             togglingSidePane = true;
+            this._capturePreHideComposition();
         }));
-        this._register(this._layoutService.onDidToggleSidePane(() => {
+        this._register(this._layoutService.onDidToggleSidePane(e => {
             try {
+                this._correctToggleReopen(e);
                 this._captureExistingProfileIfApplicable();
             } finally {
                 togglingSidePane = false;
             }
         }));
     }
+    _capturePreHideComposition() {
+        if (!this._ctx.chatLayoutActive() || this._ctx.chatLayoutSuspended() || !this._layoutService.isSidePaneVisible()) {
+            return;
+        }
+        const ownerKey = this._activeOwnerKey();
+        if (!ownerKey) {
+            return;
+        }
+        this._ctx.compositionStore.setPreHide(ownerKey, this._layoutService.captureSidePaneComposition());
+    }
+    _correctToggleReopen(e) {
+        const wasFullyHidden = !e.before.editor && !e.before.auxiliaryBar;
+        const nowVisible = e.after.editor || e.after.auxiliaryBar;
+        if (!wasFullyHidden || !nowVisible || !this._ctx.chatLayoutActive() || this._ctx.chatLayoutSuspended()) {
+            return;
+        }
+        const ownerKey = this._activeOwnerKey();
+        if (!ownerKey) {
+            return;
+        }
+        const preHide = this._ctx.compositionStore.getPreHide(ownerKey);
+        if (preHide && (preHide.editor !== e.after.editor || preHide.auxiliaryBar !== e.after.auxiliaryBar)) {
+            this._layoutService.restoreSidePaneComposition(preHide);
+        }
+    }
+    _activeOwnerKey() {
+        const activeSession = this._sessionsService.activeSession.get();
+        return activeSession && !activeSession.isQuickChat?.get() ? this._ctx.compositionKeyFor(activeSession) : undefined;
+    }
+    _resolveComposition(activeSession, ownerKey) {
+        if (!ownerKey) {
+            return this._visibilityStore.get(SessionVisibilityProfile.Existing);
+        }
+        const compositionKey = this._ctx.compositionKeyFor(activeSession);
+        const stored = compositionKey && this._ctx.compositionStore.get(compositionKey);
+        if (stored) {
+            return {
+                editorVisible: stored.editor,
+                auxiliaryBarVisible: stored.auxiliaryBar
+            };
+        }
+        const state = this._visibilityStore.get(SessionVisibilityProfile.Existing);
+        if (compositionKey) {
+            this._ctx.compositionStore.set(compositionKey, {
+                editor: state.editorVisible,
+                auxiliaryBar: state.auxiliaryBarVisible
+            });
+        }
+        return state;
+    }
     _captureExistingProfileIfApplicable() {
-        if (this._ctx.isRestoringSessionLayout || this._ctx.multipleSessionsVisibleObs.get()) {
+        if (this._ctx.isRestoringSessionLayout || this._ctx.chatLayoutSuspended()) {
             return;
         }
         const activeSession = this._sessionsService.activeSession.get();
-        if (!activeSession || activeSession.isQuickChat?.get() || !activeSession.isCreated.get() || this._layoutService.isEditorMaximized() || this._layoutService.isVisible(Parts.CUSTOM_VIEW_GRID_PART)) {
+        if (this._ctx.multipleSessionsVisibleObs.get()) {
+            const ownerKey = activeSession && this._ctx.chatLayoutActive() ? this._ctx.ownerKeyFor(activeSession) : undefined;
+            if (!ownerKey) {
+                return;
+            }
+        }
+        if (!activeSession || activeSession.isQuickChat?.get() || !activeSession.isCreated.get() || (this._ctx.sharedChatLayout && !activeSession.activeChat.get().workspace.get()) || this._layoutService.isEditorMaximized() || this._layoutService.isVisible(Parts.CUSTOM_VIEW_GRID_PART)) {
             return;
         }
         this._captureExistingProfile();
     }
     _captureExistingProfile() {
+        if (this._ctx.chatLayoutSuspended()) {
+            return;
+        }
         const state = {
             editorVisible: this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow),
             auxiliaryBarVisible: this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)
         };
+        if (this._ctx.chatLayoutActive()) {
+            const activeSession = this._sessionsService.activeSession.get();
+            const ownerKey = activeSession && this._ctx.compositionKeyFor(activeSession);
+            if (ownerKey) {
+                this._ctx.compositionStore.set(ownerKey, {
+                    editor: state.editorVisible,
+                    auxiliaryBar: state.auxiliaryBarVisible
+                });
+            }
+            return;
+        }
         this._visibilityStore.set(SessionVisibilityProfile.Existing, state);
     }
-    _apply(state) {
+    _apply(state, revealOnly = false) {
         const suppression = this._layoutService.suppressEditorPartAutoVisibility();
         try {
-            if (!state.editorVisible && this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+            if (!revealOnly && !state.editorVisible && this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
                 this._layoutService.setPartHidden(true, Parts.EDITOR_PART);
             }
-            if (!state.auxiliaryBarVisible && this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+            if (!revealOnly && !state.auxiliaryBarVisible && this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
                 this._layoutService.setPartHidden(true, Parts.AUXILIARYBAR_PART);
             }
             if (state.auxiliaryBarVisible && !this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
@@ -197,19 +282,6 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
             suppression.dispose();
         }
     }
-    _reveal(state) {
-        const suppression = this._layoutService.suppressEditorPartAutoVisibility();
-        try {
-            if (state.auxiliaryBarVisible && !this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
-                this._layoutService.setPartHidden(false, Parts.AUXILIARYBAR_PART);
-            }
-            if (state.editorVisible && !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
-                this._layoutService.setPartHidden(false, Parts.EDITOR_PART);
-            }
-        } finally {
-            suppression.dispose();
-        }
-    }
     _registerDetailPanel() {
         const activeEditorObs = observableFromEvent(
             this,
@@ -241,13 +313,17 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
         let previousEditorSessionKey;
         let previousQuickChatResource;
         const sync = reader => {
+            if (this._ctx.chatLayoutSuspended(reader)) {
+                return;
+            }
             const activeSession = this._sessionsService.activeSession.read(reader);
             const isQuickChat = activeSession?.isQuickChat?.read(reader) ?? false;
             const isWorkspaceConversion = !isQuickChat && !!activeSession && isEqual(previousQuickChatResource, activeSession.resource);
             if (!isWorkspaceConversion) {
                 previousQuickChatResource = isQuickChat ? activeSession?.resource : undefined;
             }
-            if (!activeSession || isQuickChat || !activeSession.workspace.read(reader) || !activeSession.isCreated.read(reader)) {
+            const workspace = activeSession?.activeChat.read(reader).workspace.read(reader);
+            if (!activeSession || isQuickChat || !workspace || !activeSession.isCreated.read(reader)) {
                 wasExistingActive = false;
                 previousActiveEditor = undefined;
                 previousEditorPartVisible = false;
@@ -255,7 +331,7 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
                 return;
             }
             previousQuickChatResource = undefined;
-            const sessionKey = ( activeSession.resource.toString());
+            const sessionKey = this._ctx.ownerKeyFor(activeSession, reader)?.toString();
             const sessionChanged = activeSessionKey !== undefined && activeSessionKey !== sessionKey;
             if (!wasExistingActive || sessionChanged) {
                 activeSessionKey = sessionKey;
@@ -287,7 +363,7 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
             previousActiveEditor = activeEditor;
             previousEditorPartVisible = editorPartVisible;
             previousEditorSessionKey = sessionKey;
-            const target = this._computeTarget(activeEditor, mainPartEmpty, editorMaximized, editorPartVisible);
+            const target = this._computeTarget(activeEditor, mainPartEmpty, editorMaximized, editorPartVisible, workspace);
             const revealOnly = this._ctx.multipleSessionsVisibleObs.read(reader);
             if (!isWorkspaceConversion) {
                 this._syncDetailVisibility(target, revealOnly, emptyFilesShown);
@@ -297,7 +373,7 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
         this._register(autorun(sync));
         this._register(this._ctx.onDidEndSessionLayoutRestore(() => {
             const activeSession = this._sessionsService.activeSession.get();
-            if (!activeSession || ( activeSession.resource.toString()) !== pendingSessionKey) {
+            if (pendingSessionKey && (!activeSession || this._ctx.ownerKeyFor(activeSession)?.toString() !== pendingSessionKey)) {
                 return;
             }
             pendingSessionKey = undefined;
@@ -322,10 +398,11 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
         if (this._ctx.isRestoringSessionLayout || target === DetailPanelTarget.Preserve) {
             return;
         }
-        if (target === DetailPanelTarget.Hidden || target === DetailPanelTarget.EditorHidden) {
-            if ((target === DetailPanelTarget.EditorHidden || !revealOnly) && detailVisible) {
+        if (target === DetailPanelTarget.Hidden || target === DetailPanelTarget.EditorHidden || target === DetailPanelTarget.FilesHidden) {
+            const hiddenByEditor = target === DetailPanelTarget.EditorHidden || target === DetailPanelTarget.FilesHidden;
+            if ((hiddenByEditor || !revealOnly) && detailVisible) {
                 this._detailHiddenTransiently = true;
-                this._detailHiddenByEditor = target === DetailPanelTarget.EditorHidden;
+                this._detailHiddenByEditor = hiddenByEditor;
                 this._setDetailHiddenTransiently(true);
             }
             return;
@@ -345,7 +422,7 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
             this._changingDetailTransiently = false;
         }
     }
-    _computeTarget(activeEditor, mainPartEmpty, editorMaximized, editorPartVisible) {
+    _computeTarget(activeEditor, mainPartEmpty, editorMaximized, editorPartVisible, workspace) {
         if (mainPartEmpty) {
             return this._ctx.isRestoringSessionLayout ? DetailPanelTarget.Preserve : DetailPanelTarget.Hidden;
         }
@@ -361,10 +438,13 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
         if (isChangesEditorInput(activeEditor, this._sessionChangesService)) {
             return DetailPanelTarget.ChangesForced;
         }
-        if (isFileEditorInput(activeEditor)) {
+        switch (getFilesDetailsState(activeEditor, workspace)) {
+        case FilesDetailsState.Active:
             return DetailPanelTarget.FilesForced;
+        case FilesDetailsState.Available:
+            return editorPartVisible ? DetailPanelTarget.FilesHidden : DetailPanelTarget.Changes;
         }
-        return DetailPanelTarget.Preserve;
+        return editorPartVisible ? DetailPanelTarget.EditorHidden : DetailPanelTarget.Changes;
     }
     _registerManagedTabsSupplement() {
         let previousSessionKey;
@@ -375,7 +455,7 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
             const session = this._sessionsService.activeSession.read(reader);
             const isQuickChat = session?.isQuickChat?.read(reader) ?? false;
             const isCreated = session && !isQuickChat ? session.isCreated.read(reader) : false;
-            const sessionKey = session?.resource.toString();
+            const sessionKey = session && this._ctx.ownerKeyFor(session, reader)?.toString();
             const isSubmit = !isQuickChat && previousIsCreated === false && isCreated && (previousSession === session || previousSession?.isCreated.read(undefined) === true);
             if (isSubmit) {
                 changesActivationPendingForSession = sessionKey;
@@ -384,14 +464,14 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
             }
             if (session && !isQuickChat && isCreated) {
                 const target = this.managedTabs.readTarget(reader);
-                const hasChanges = (session.changes.read(reader).length ?? 0) > 0;
+                const hasChanges = session.activeChat.read(reader).changes.read(reader).length > 0;
                 const ensureChangesActive = changesActivationPendingForSession === sessionKey && hasChanges;
                 if (ensureChangesActive) {
                     changesActivationPendingForSession = undefined;
                 }
                 if (isSubmit || ensureChangesActive) {
                     this.managedTabs.queueReconcile(target, {
-                        openDefaultsIfEmpty: isSubmit,
+                        openDefaultsIfEmpty: isSubmit && this._layoutService.isSidePaneVisible(),
                         ensureChangesActive
                     });
                 }
@@ -407,20 +487,20 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
             constructor() {
                 super({
                     id: TOGGLE_DETAILS_COMMAND_ID,
-                    title: ( localize2(4122, "Toggle Details")),
+                    title: ( localize2(4754, "Toggle Details")),
                     icon: Codicon.listSelection,
                     f1: false,
                     toggled: AuxiliaryBarVisibleContext,
                     keybinding: {
                         weight: KeybindingWeight.SessionsContrib,
                         primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyL,
-                        when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), SinglePaneLayoutEnabledContext))
+                        when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), DesktopLayoutContext))
                     },
                     menu: {
                         id: MenuId.EditorTitleLayout,
                         group: "navigation",
-                        order: singlePaneHeaderToggleDetailsOrder,
-                        when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), IsTopRightEditorGroupContext, SinglePaneLayoutEnabledContext, MainEditorAreaVisibleContext, HasDockedDetailsContext))
+                        order: desktopHeaderToggleDetailsOrder,
+                        when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), IsTopRightEditorGroupContext, DesktopLayoutContext, MainEditorAreaVisibleContext, HasDockedDetailsContext))
                     }
                 });
             }
@@ -430,6 +510,6 @@ let SinglePaneExistingSessionStrategy = class SinglePaneExistingSessionStrategy
         });
     }
 };
-SinglePaneExistingSessionStrategy = ( __decorate([( __param(3, IAgentWorkbenchLayoutService)), ( __param(4, ISessionsService)), ( __param(5, IEditorService)), ( __param(6, IEditorGroupsService)), ( __param(7, ISessionChangesService))], SinglePaneExistingSessionStrategy));
+DesktopExistingSessionStrategy = ( __decorate([( __param(3, IAgentWorkbenchLayoutService)), ( __param(4, ISessionsService)), ( __param(5, IEditorService)), ( __param(6, IEditorGroupsService)), ( __param(7, ISessionChangesService))], DesktopExistingSessionStrategy));
 
-export { SinglePaneExistingSessionStrategy, TOGGLE_DETAILS_COMMAND_ID };
+export { DesktopExistingSessionStrategy, TOGGLE_DETAILS_COMMAND_ID };

package/vscode/src/vs/sessions/contrib/layout/browser/{singlePane/singlePaneLayoutStrategy.d.ts → desktop/desktopLayoutStrategy.d.ts}

@@ -1,13 +1,15 @@
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IObservable, IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { DesktopOwnerCompositionStore } from "./desktopOwnerCompositionStore.js";
 /**
- * Shared controller state that single-pane layout strategies read/coordinate
- * through. Implemented by the single-pane layout controller; the concrete
+ * Shared controller state that desktop layout strategies read/coordinate
+ * through. Implemented by the desktop layout controller; the concrete
  * services each strategy needs are injected into the strategy directly via DI.
  */
-export interface ISinglePaneLayoutContext {
+export interface IDesktopLayoutContext {
     /** `> 0` while a session-switch layout restore is in progress. */
     readonly isRestoringSessionLayout: boolean;
     /** Runs `work` while a session-switch layout restore is held. */
@@ -19,28 +21,35 @@ export interface ISinglePaneLayoutContext {
     readonly multipleSessionsVisibleObs: IObservable<boolean>;
     readonly activeSessionResourceObs: IObservable<URI | undefined>;
     hasSavedWorkingSet(sessionResource: URI): boolean;
+    completeChangesEditorTransition(): void;
+    chatLayoutActive(reader?: IReader): boolean;
+    chatLayoutSuspended(reader?: IReader): boolean;
+    readonly sharedChatLayout: boolean;
+    ownerKeyFor(session: IActiveSession, reader?: IReader): URI | undefined;
+    compositionKeyFor(session: IActiveSession, reader?: IReader): URI | undefined;
+    readonly compositionStore: DesktopOwnerCompositionStore;
 }
 /**
- * Base class for a single-pane layout behaviour, owning its own disposables.
+ * Base class for a desktop layout behaviour, owning its own disposables.
  *
  * Exactly two concrete strategies extend this — one per session lifecycle stage:
- * {@link import('./singlePaneDraftSessionStrategy.js').SinglePaneDraftSessionStrategy} (workspace-backed
- * and workspace-less drafts) and {@link import('./singlePaneExistingSessionStrategy.js').SinglePaneExistingSessionStrategy}
+ * {@link import('./desktopDraftSessionStrategy.js').DesktopDraftSessionStrategy} (workspace-backed
+ * and workspace-less drafts) and {@link import('./desktopExistingSessionStrategy.js').DesktopExistingSessionStrategy}
  * (a created, workspace-backed session). Each owns the full vertical slice of behaviour for its stage:
  * side-pane visibility, the detail-panel (Changes/Files) mapping, and — for the two workspace
  * stages — the managed docked tabs and detail-only editor-area collapse.
  *
  * Shared mechanics (the managed-tabs reconcile pipeline + editor-area collapse and the Existing
  * Editor-visibility-profile storage) live in non-strategy coordinator classes in this
- * folder — see `singlePaneDockedTabsCoordinator.ts`, `singlePaneDetailPanelCoordinator.ts`, and
- * `singlePaneVisibilityProfileStore.ts`. The shared detail coordinator owns only content selection
+ * folder — see `desktopDockedTabsCoordinator.ts`, `desktopDetailPanelCoordinator.ts`, and
+ * `desktopVisibilityProfileStore.ts`. The shared detail coordinator owns only content selection
  * and context publication; each lifecycle strategy owns Auxiliary Bar visibility. The shared mechanics are owned by
- * {@link import('./singlePaneExistingSessionStrategy.js').SinglePaneExistingSessionStrategy}
+ * {@link import('./desktopExistingSessionStrategy.js').DesktopExistingSessionStrategy}
  * (the docked-tabs coordinator, since its reconcile pipeline is shared across the New→Existing
  * submit transition) or by the controller (the visibility-profile store, since it backs one
  * combined storage blob for both workspace stages).
  */
-export declare abstract class SinglePaneLayoutStrategy extends Disposable {
-    protected readonly _ctx: ISinglePaneLayoutContext;
-    constructor(_ctx: ISinglePaneLayoutContext);
+export declare abstract class DesktopLayoutStrategy extends Disposable {
+    protected readonly _ctx: IDesktopLayoutContext;
+    constructor(_ctx: IDesktopLayoutContext);
 }

package/vscode/src/vs/sessions/contrib/layout/browser/{singlePane/singlePaneLayoutStrategy.js → desktop/desktopLayoutStrategy.js}

@@ -1,11 +1,11 @@
 
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 
-class SinglePaneLayoutStrategy extends Disposable {
+class DesktopLayoutStrategy extends Disposable {
     constructor(_ctx) {
         super();
         this._ctx = _ctx;
     }
 }
 
-export { SinglePaneLayoutStrategy };
+export { DesktopLayoutStrategy };

package/vscode/src/vs/sessions/contrib/layout/browser/desktop/desktopOwnerCompositionStore.d.ts

@@ -0,0 +1,22 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+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 { ISidePaneState } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench";
+export declare class DesktopOwnerCompositionStore {
+    private readonly _storageService;
+    private readonly _logService;
+    private readonly _byOwner;
+    private readonly _preHideByOwner;
+    constructor(shared: boolean, _storageService: IStorageService, _logService: ILogService);
+    private readonly _compositionStorageKey;
+    private readonly _preHideStorageKey;
+    get ownerKeys(): Iterable<URI>;
+    get(ownerKey: URI): ISidePaneState | undefined;
+    set(ownerKey: URI, state: ISidePaneState): void;
+    getPreHide(ownerKey: URI): ISidePaneState | undefined;
+    setPreHide(ownerKey: URI, state: ISidePaneState): void;
+    forget(keys: readonly URI[]): void;
+    remap(oldKey: URI, newKey: URI): void;
+    private _load;
+    private _save;
+}

package/vscode/src/vs/sessions/contrib/layout/browser/desktop/desktopOwnerCompositionStore.js

@@ -0,0 +1,136 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+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';
+
+const DESKTOP_OWNER_COMPOSITION_STATE_KEY = "sessions.chatLayout.sidePaneComposition";
+const DESKTOP_OWNER_PRE_HIDE_COMPOSITION_STATE_KEY = "sessions.chatLayout.sidePanePreHideComposition";
+const DESKTOP_OWNER_COMPOSITION_SCHEMA_VERSION = 1;
+function isValidDesktopOwnerCompositionEntry(value) {
+    if (!Array.isArray(value) || value.length !== 2) {
+        return false;
+    }
+    const [ownerKeyRaw, state] = value;
+    if (typeof ownerKeyRaw !== "string") {
+        return false;
+    }
+    if (typeof state !== "object" || state === null) {
+        return false;
+    }
+    const sidePaneState = state;
+    return typeof sidePaneState.editor === "boolean" && typeof sidePaneState.auxiliaryBar === "boolean";
+}
+let DesktopOwnerCompositionStore = class DesktopOwnerCompositionStore {
+    constructor(shared, _storageService, _logService) {
+        this._storageService = _storageService;
+        this._logService = _logService;
+        this._byOwner = ( new ResourceMap());
+        this._preHideByOwner = ( new ResourceMap());
+        this._compositionStorageKey = shared ? "sessions.sharedChatLayout.sidePaneComposition" : DESKTOP_OWNER_COMPOSITION_STATE_KEY;
+        this._preHideStorageKey = shared ? "sessions.sharedChatLayout.sidePanePreHideComposition" : DESKTOP_OWNER_PRE_HIDE_COMPOSITION_STATE_KEY;
+        this._load(this._compositionStorageKey, this._byOwner);
+        this._load(this._preHideStorageKey, this._preHideByOwner);
+    }
+    get ownerKeys() {
+        return ( new ResourceSet([...( this._byOwner.keys()), ...( this._preHideByOwner.keys())]));
+    }
+    get(ownerKey) {
+        return this._byOwner.get(ownerKey);
+    }
+    set(ownerKey, state) {
+        this._byOwner.set(ownerKey, state);
+        this._save(this._compositionStorageKey, this._byOwner);
+    }
+    getPreHide(ownerKey) {
+        return this._preHideByOwner.get(ownerKey);
+    }
+    setPreHide(ownerKey, state) {
+        this._preHideByOwner.set(ownerKey, state);
+        this._save(this._preHideStorageKey, this._preHideByOwner);
+    }
+    forget(keys) {
+        let changed = false;
+        for (const key of keys) {
+            changed = this._byOwner.delete(key) || changed;
+        }
+        if (changed) {
+            this._save(this._compositionStorageKey, this._byOwner);
+        }
+        let preHideChanged = false;
+        for (const key of keys) {
+            preHideChanged = this._preHideByOwner.delete(key) || preHideChanged;
+        }
+        if (preHideChanged) {
+            this._save(this._preHideStorageKey, this._preHideByOwner);
+        }
+    }
+    remap(oldKey, newKey) {
+        if (isEqual(oldKey, newKey)) {
+            return;
+        }
+        const state = this._byOwner.get(oldKey);
+        if (state) {
+            this._byOwner.set(newKey, state);
+            this._byOwner.delete(oldKey);
+            this._save(this._compositionStorageKey, this._byOwner);
+        }
+        const preHideState = this._preHideByOwner.get(oldKey);
+        if (preHideState) {
+            this._preHideByOwner.set(newKey, preHideState);
+            this._preHideByOwner.delete(oldKey);
+            this._save(this._preHideStorageKey, this._preHideByOwner);
+        }
+    }
+    _load(storageKey, target) {
+        const raw = this._storageService.get(storageKey, StorageScope.WORKSPACE);
+        if (!raw) {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed.version !== DESKTOP_OWNER_COMPOSITION_SCHEMA_VERSION || !Array.isArray(parsed.entries)) {
+                throw ( new Error(
+                    `Unsupported ${storageKey} schema: expected version ${DESKTOP_OWNER_COMPOSITION_SCHEMA_VERSION}, got version ${String(parsed.version)}`
+                ));
+            }
+            const staged = ( new ResourceMap());
+            parsed.entries.forEach((entry, index) => {
+                if (!isValidDesktopOwnerCompositionEntry(entry)) {
+                    throw ( new Error(`Malformed ${storageKey} entry at index ${index}`));
+                }
+                const [ownerKeyRaw, state] = entry;
+                staged.set(( URI.parse(ownerKeyRaw)), {
+                    editor: state.editor,
+                    auxiliaryBar: state.auxiliaryBar
+                });
+            });
+            staged.forEach((state, ownerKey) => target.set(ownerKey, state));
+        } catch (error) {
+            this._logService.error(error);
+            this._storageService.remove(storageKey, StorageScope.WORKSPACE);
+        }
+    }
+    _save(storageKey, source) {
+        const entries = [];
+        for (const [ownerKey, state] of source) {
+            entries.push([( ownerKey.toString()), state]);
+        }
+        const schema = {
+            version: DESKTOP_OWNER_COMPOSITION_SCHEMA_VERSION,
+            entries
+        };
+        this._storageService.store(
+            storageKey,
+            JSON.stringify(schema),
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
+    }
+};
+DesktopOwnerCompositionStore = ( __decorate([( __param(1, IStorageService)), ( __param(2, ILogService))], DesktopOwnerCompositionStore));
+
+export { DesktopOwnerCompositionStore };