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

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

@@ -0,0 +1,18 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IChatLayoutOwner } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/chatLayout";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+export declare class ChatLayoutOwnerKeyRegistry {
+    private readonly _keysBySession;
+    resolveKey(owner: IChatLayoutOwner, mainChatResource: URI): URI;
+    registerPersistedKey(key: URI): void;
+    private _registerKey;
+    forgetChat(sessionResource: URI, chatResource: URI): URI | undefined;
+    forgetSession(sessionResource: URI): readonly URI[];
+    remapSession(replacement: {
+        readonly from: ISession;
+        readonly to: ISession;
+    }): readonly {
+        readonly oldKey: URI;
+        readonly newKey: URI;
+    }[];
+}

package/vscode/src/vs/sessions/contrib/layout/browser/chatLayoutOwnerKeys.js

@@ -0,0 +1,95 @@
+
+import { ResourceMap } 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 { getChatLayoutOwnerAfterReplacement } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/chatLayout';
+
+const CHAT_LAYOUT_OWNER_KEY_SCHEME = "vscode-chat-layout-owner";
+class ChatLayoutOwnerKeyRegistry {
+    constructor() {
+        this._keysBySession = ( new ResourceMap());
+    }
+    resolveKey(owner, mainChatResource) {
+        if (isEqual(owner.chatResource, mainChatResource)) {
+            return owner.sessionResource;
+        }
+        const bySession = this._keysBySession.get(owner.sessionResource);
+        const existing = bySession?.get(owner.chatResource);
+        if (existing) {
+            return existing;
+        }
+        const key = ( URI.from({
+            scheme: CHAT_LAYOUT_OWNER_KEY_SCHEME,
+            path: `/${encodeURIComponent(( owner.sessionResource.toString()))}/${encodeURIComponent(( owner.chatResource.toString()))}`
+        }));
+        this._registerKey(owner, key);
+        return key;
+    }
+    registerPersistedKey(key) {
+        if (key.scheme !== CHAT_LAYOUT_OWNER_KEY_SCHEME) {
+            return;
+        }
+        const segments = key.path.split("/");
+        if (segments.length !== 3 || !segments[1] || !segments[2]) {
+            throw ( new Error(`Malformed chat layout owner key: ${( key.toString())}`));
+        }
+        this._registerKey({
+            sessionResource: ( URI.parse(decodeURIComponent(segments[1]))),
+            chatResource: ( URI.parse(decodeURIComponent(segments[2])))
+        }, key);
+    }
+    _registerKey(owner, key) {
+        let bySession = this._keysBySession.get(owner.sessionResource);
+        if (!bySession) {
+            bySession = ( new ResourceMap());
+            this._keysBySession.set(owner.sessionResource, bySession);
+        }
+        bySession.set(owner.chatResource, key);
+    }
+    forgetChat(sessionResource, chatResource) {
+        const bySession = this._keysBySession.get(sessionResource);
+        const key = bySession?.get(chatResource);
+        if (!key) {
+            return undefined;
+        }
+        bySession.delete(chatResource);
+        if (bySession.size === 0) {
+            this._keysBySession.delete(sessionResource);
+        }
+        return key;
+    }
+    forgetSession(sessionResource) {
+        const bySession = this._keysBySession.get(sessionResource);
+        if (!bySession) {
+            return [];
+        }
+        const keys = [];
+        bySession.forEach(key => keys.push(key));
+        this._keysBySession.delete(sessionResource);
+        return keys;
+    }
+    remapSession(replacement) {
+        const bySession = this._keysBySession.get(replacement.from.resource);
+        if (!bySession) {
+            return [];
+        }
+        const entries = [];
+        bySession.forEach((key, chatResource) => entries.push([chatResource, key]));
+        this._keysBySession.delete(replacement.from.resource);
+        const result = [];
+        for (const [chatResource, oldKey] of entries) {
+            const newOwner = getChatLayoutOwnerAfterReplacement({
+                sessionResource: replacement.from.resource,
+                chatResource
+            }, replacement);
+            const newKey = this.resolveKey(newOwner, replacement.to.mainChat.get().resource);
+            result.push({
+                oldKey,
+                newKey
+            });
+        }
+        return result;
+    }
+}
+
+export { ChatLayoutOwnerKeyRegistry };

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

@@ -9,13 +9,14 @@ export declare enum DetailPanelTarget {
     Changes = 2,
     ChangesForced = 3,
     Files = 4,
-    FilesForced = 5,
-    Preserve = 6
+    FilesHidden = 5,
+    FilesForced = 6,
+    Preserve = 7
 }
 /**
- * Shared mechanics for selecting the single-pane detail content.
+ * Shared mechanics for selecting the desktop detail content.
  */
-export declare class SinglePaneDetailPanelCoordinator extends Disposable {
+export declare class DesktopDetailPanelCoordinator extends Disposable {
     private readonly _layoutService;
     private readonly _viewsService;
     private readonly _hasDockedDetailsContext;

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

@@ -21,10 +21,11 @@ var DetailPanelTarget;
     DetailPanelTarget[DetailPanelTarget["Changes"] = 2] = "Changes";
     DetailPanelTarget[DetailPanelTarget["ChangesForced"] = 3] = "ChangesForced";
     DetailPanelTarget[DetailPanelTarget["Files"] = 4] = "Files";
-    DetailPanelTarget[DetailPanelTarget["FilesForced"] = 5] = "FilesForced";
-    DetailPanelTarget[DetailPanelTarget["Preserve"] = 6] = "Preserve";
+    DetailPanelTarget[DetailPanelTarget["FilesHidden"] = 5] = "FilesHidden";
+    DetailPanelTarget[DetailPanelTarget["FilesForced"] = 6] = "FilesForced";
+    DetailPanelTarget[DetailPanelTarget["Preserve"] = 7] = "Preserve";
 })(DetailPanelTarget || (DetailPanelTarget = {}));
-let SinglePaneDetailPanelCoordinator = class SinglePaneDetailPanelCoordinator extends Disposable {
+let DesktopDetailPanelCoordinator = class DesktopDetailPanelCoordinator extends Disposable {
     constructor(_layoutService, _viewsService, sessionsService, contextKeyService) {
         super();
         this._layoutService = _layoutService;
@@ -40,7 +41,8 @@ let SinglePaneDetailPanelCoordinator = class SinglePaneDetailPanelCoordinator ex
         }));
         this._register(autorun(reader => {
             const activeSession = sessionsService.activeSession.read(reader);
-            if (!activeSession || (!(activeSession.isQuickChat?.read(reader) ?? false) && !activeSession.workspace.read(reader))) {
+            const activeChat = activeSession?.activeChat.read(reader);
+            if (!activeSession || (!(activeSession.isQuickChat?.read(reader) ?? false) && !activeChat?.workspace.read(reader))) {
                 this.sync(DetailPanelTarget.Preserve);
             }
         }));
@@ -48,7 +50,7 @@ let SinglePaneDetailPanelCoordinator = class SinglePaneDetailPanelCoordinator ex
     sync(target) {
         this._target = target;
         this._hasDockedDetailsContext.set(
-            target === DetailPanelTarget.Changes || target === DetailPanelTarget.ChangesForced || target === DetailPanelTarget.Files || target === DetailPanelTarget.FilesForced
+            target === DetailPanelTarget.Changes || target === DetailPanelTarget.ChangesForced || target === DetailPanelTarget.Files || target === DetailPanelTarget.FilesHidden || target === DetailPanelTarget.FilesForced
         );
         this._queueTarget(target);
     }
@@ -66,6 +68,7 @@ let SinglePaneDetailPanelCoordinator = class SinglePaneDetailPanelCoordinator ex
             await this._viewsService.openViewContainer(CHANGES_VIEW_CONTAINER_ID, false);
             return;
         case DetailPanelTarget.Files:
+        case DetailPanelTarget.FilesHidden:
         case DetailPanelTarget.FilesForced:
             await this._viewsService.openViewContainer(SESSIONS_FILES_CONTAINER_ID, false);
             return;
@@ -76,6 +79,6 @@ let SinglePaneDetailPanelCoordinator = class SinglePaneDetailPanelCoordinator ex
         }
     }
 };
-SinglePaneDetailPanelCoordinator = ( __decorate([( __param(0, IAgentWorkbenchLayoutService)), ( __param(1, IViewsService)), ( __param(2, ISessionsService)), ( __param(3, IContextKeyService))], SinglePaneDetailPanelCoordinator));
+DesktopDetailPanelCoordinator = ( __decorate([( __param(0, IAgentWorkbenchLayoutService)), ( __param(1, IViewsService)), ( __param(2, ISessionsService)), ( __param(3, IContextKeyService))], DesktopDetailPanelCoordinator));
 
-export { DetailPanelTarget, SinglePaneDetailPanelCoordinator };
+export { DesktopDetailPanelCoordinator, DetailPanelTarget };

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

@@ -3,6 +3,7 @@ import { IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/obse
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ISessionEditorWorkingSetService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/layout/common/sessionEditorWorkingSet.service";
 import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
 import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
@@ -11,7 +12,7 @@ import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/session
 import { ISessionChangesService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService";
 import { IChangesViewService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changesViewService.service";
 import { ISessionWorkspace } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
-import { ISinglePaneLayoutContext } from "./singlePaneLayoutStrategy.js";
+import { IDesktopLayoutContext } from "./desktopLayoutStrategy.js";
 /**
  * What the active session wants from its managed docked tabs.
  *  - `changesSessionResource`: set for any workspace session (the Changes multi-diff tab). `undefined` otherwise.
@@ -32,9 +33,7 @@ export interface IManagedTabsTarget {
 export interface IReconcileTrigger {
     /** Open the default docked tabs *if the group is empty* — a session switch, a side-pane reveal, or a settled layout restore. */
     readonly openDefaultsIfEmpty?: boolean;
-    /** Ensure the Changes tab, inactive, when a new-session view becomes eligible or finishes restoring. */
-    readonly ensureChanges?: boolean;
-    /** Ensure the Changes tab, opened **active**, even in a non-empty group — new-session submit (so the detail panel maps to Changes rather than the still-present Files placeholder). */
+    /** Activate an existing Changes tab after new-session submit so the detail panel maps to Changes rather than Files. */
     readonly ensureChangesActive?: boolean;
     /** A saved working set finished restoring for the active session. */
     readonly workingSetRestored?: boolean;
@@ -43,15 +42,15 @@ export interface IReconcileTrigger {
  * Owns the two managed docked tabs (the pinned Changes multi-diff tab and the empty Files
  * placeholder tab for workspace sessions) and the detail-only editor-area collapse. Shared
  * (not a strategy) because both belong to one reconcile pipeline that must stay single-instance
- * across the New→Existing submit transition — see `SinglePaneLayoutStrategy`'s doc comment.
- * Owned and disposed by {@link import('./singlePaneExistingSessionStrategy.js').SinglePaneExistingSessionStrategy}.
- * `SinglePaneDraftSessionStrategy` supplies workspace-draft supplementary reconcile intents via
+ * across the New→Existing submit transition — see `DesktopLayoutStrategy`'s doc comment.
+ * Owned and disposed by {@link import('./desktopExistingSessionStrategy.js').DesktopExistingSessionStrategy}.
+ * `DesktopDraftSessionStrategy` supplies workspace-draft supplementary reconcile intents via
  * {@link queueReconcile}; workspace-less drafts never want managed tabs, so the ambient
  * session-change trigger below reconciles them away on its own.
  *
- * See `SINGLE_PANE_SCENARIOS.md` for the full reconcile rules.
+ * See `DESKTOP.md` for the full reconcile rules.
  */
-export declare class SinglePaneDockedTabsCoordinator extends Disposable {
+export declare class DesktopDockedTabsCoordinator extends Disposable {
     private readonly _ctx;
     private readonly _layoutService;
     private readonly _sessionsService;
@@ -60,8 +59,9 @@ export declare class SinglePaneDockedTabsCoordinator extends Disposable {
     private readonly _sessionChangesService;
     private readonly _changesViewService;
     private readonly _instantiationService;
+    private readonly _editorWorkingSetService;
     /** Non-docked editors closed (as reopenable inputs + tab index) while the editor area is hidden. */
-    private _collapsedEditors;
+    private readonly _collapsedEditorsByOwner;
     private readonly _sequencer;
     private _generation;
     private _lastSyncedSessionKey;
@@ -75,9 +75,10 @@ export declare class SinglePaneDockedTabsCoordinator extends Disposable {
     private readonly _filesTabAvailableContext;
     /** Last observed editor-area visibility, to act only on transitions. */
     private _editorAreaVisible;
-    constructor(_ctx: ISinglePaneLayoutContext, _layoutService: IAgentWorkbenchLayoutService, _sessionsService: ISessionsService, _editorService: IEditorService, _editorGroupsService: IEditorGroupsService, _sessionChangesService: ISessionChangesService, _changesViewService: IChangesViewService, contextKeyService: IContextKeyService, _instantiationService: IInstantiationService);
+    constructor(_ctx: IDesktopLayoutContext, _layoutService: IAgentWorkbenchLayoutService, _sessionsService: ISessionsService, _editorService: IEditorService, _editorGroupsService: IEditorGroupsService, _sessionChangesService: ISessionChangesService, _changesViewService: IChangesViewService, contextKeyService: IContextKeyService, _instantiationService: IInstantiationService, _editorWorkingSetService: ISessionEditorWorkingSetService);
     /** The resource this managed Changes editor input shows, if it is one. */
     getChangesEditorResource(editor: EditorInput): URI | undefined;
+    private _ownerKeyString;
     prepareWorkingSetRestore(hasSavedWorkingSet: boolean): void;
     /** Reads the current managed-tabs target for the active session (or for `reader`'s transaction, if given). */
     readTarget(reader: IReader | undefined): IManagedTabsTarget;
@@ -85,11 +86,13 @@ export declare class SinglePaneDockedTabsCoordinator extends Disposable {
     queueReconcile(target: IManagedTabsTarget, trigger: IReconcileTrigger): void;
     private _readTarget;
     dispose(): void;
+    remapOwnerKey(oldKey: URI, newKey: URI): void;
+    forgetOwnerKeys(keys: readonly URI[]): void;
     /** Queues coordinator-owned work, dropping tasks and failures that outlive disposal. */
     private _queue;
     private _reconcile;
     private _reconcileCore;
-    /** On a session change, drop editors captured while the previous session's editor area was hidden so they are not reopened here. */
+    /** Legacy session switches discard collapsed inputs; chat-owned inputs survive until their owner is removed. */
     private _resetCollapsedEditorsOnSessionChange;
     /** Opens the Changes editor pinned first (active on submit). Returns `false` if the reconcile is cancelled mid-open. */
     private _openChangesTab;

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

@@ -11,12 +11,13 @@ import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/reso
 import { EditorActivation } from '@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor';
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ISessionEditorWorkingSetService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/layout/common/sessionEditorWorkingSet.service';
 import { EditorResourceAccessor, SideBySideEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
 import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 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 { SinglePaneChangesTabMissingContext, SinglePaneFilesTabMissingContext, SinglePaneChangesTabAvailableContext, SinglePaneFilesTabAvailableContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { DesktopChangesTabMissingContext, DesktopFilesTabMissingContext, DesktopChangesTabAvailableContext, DesktopFilesTabAvailableContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
 import { DockedEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/dockedEditorInput';
 import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
 import { SessionChangesEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesEditorInput';
@@ -25,6 +26,7 @@ import { IChangesViewService } from '@codingame/monaco-vscode-api/vscode/vs/sess
 import { EmptyFileEditorInput } from '../../../editor/browser/emptyFileEditorInput.js';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+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 CHANGES_TAB_OPTIONS = {
@@ -51,12 +53,11 @@ const FILES_TAB_OPTIONS = {
 function mergeTriggers(a, b) {
     return {
         openDefaultsIfEmpty: a.openDefaultsIfEmpty || b.openDefaultsIfEmpty,
-        ensureChanges: a.ensureChanges || b.ensureChanges,
         ensureChangesActive: a.ensureChangesActive || b.ensureChangesActive,
         workingSetRestored: a.workingSetRestored || b.workingSetRestored
     };
 }
-let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator extends Disposable {
+let DesktopDockedTabsCoordinator = class DesktopDockedTabsCoordinator extends Disposable {
     constructor(
         _ctx,
         _layoutService,
@@ -66,7 +67,8 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
         _sessionChangesService,
         _changesViewService,
         contextKeyService,
-        _instantiationService
+        _instantiationService,
+        _editorWorkingSetService
     ) {
         super();
         this._ctx = _ctx;
@@ -77,25 +79,23 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
         this._sessionChangesService = _sessionChangesService;
         this._changesViewService = _changesViewService;
         this._instantiationService = _instantiationService;
+        this._editorWorkingSetService = _editorWorkingSetService;
+        this._collapsedEditorsByOwner = ( new Map());
         this._sequencer = ( new Sequencer());
         this._generation = 0;
         this._filesTabDismissed = false;
         this._changingFilesInternally = false;
-        this._changesTabMissingContext = SinglePaneChangesTabMissingContext.bindTo(contextKeyService);
-        this._filesTabMissingContext = SinglePaneFilesTabMissingContext.bindTo(contextKeyService);
-        this._changesTabAvailableContext = SinglePaneChangesTabAvailableContext.bindTo(contextKeyService);
-        this._filesTabAvailableContext = SinglePaneFilesTabAvailableContext.bindTo(contextKeyService);
-        let previousChangesSessionResource;
+        this._changesTabMissingContext = DesktopChangesTabMissingContext.bindTo(contextKeyService);
+        this._filesTabMissingContext = DesktopFilesTabMissingContext.bindTo(contextKeyService);
+        this._changesTabAvailableContext = DesktopChangesTabAvailableContext.bindTo(contextKeyService);
+        this._filesTabAvailableContext = DesktopFilesTabAvailableContext.bindTo(contextKeyService);
         this._register(autorun(reader => {
             const target = this._readTarget(reader);
-            const ensureChanges = !!target.changesSessionResource && (!previousChangesSessionResource || !isEqual(previousChangesSessionResource, target.changesSessionResource));
-            previousChangesSessionResource = target.changesSessionResource;
             if (!target.wantsChangesTab) {
                 this._filesTabDismissed = false;
             }
             this.queueReconcile(target, {
-                openDefaultsIfEmpty: true,
-                ensureChanges
+                openDefaultsIfEmpty: this._layoutService.isSidePaneVisible()
             });
         }));
         this._register(this._layoutService.onDidRevealSidePane(() => {
@@ -104,22 +104,26 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
             });
         }));
         const partVisibilityChangedSignal = observableSignalFromEvent(this, this._layoutService.onDidChangePartVisibility);
-        const editorsChangedSignal = observableSignalFromEvent(this, Event.any(
+        const mainEditorsChanged = Event.filter(
+            this._editorService.onDidEditorsChange,
+            e => !!this._editorGroupsService.mainPart.getGroup(e.groupId)
+        );
+        const editorsChangedSignal = observableSignalFromEvent(this, mainEditorsChanged);
+        const activeMainGroup = observableFromEvent(
+            this,
             this._editorService.onDidActiveEditorChange,
-            this._editorService.onDidEditorsChange
-        ));
+            () => this._editorGroupsService.mainPart.activeGroup
+        );
         this._register(autorun(reader => {
             partVisibilityChangedSignal.read(reader);
             editorsChangedSignal.read(reader);
+            activeMainGroup.read(reader);
             this.queueReconcile(this._readTarget(undefined), {});
         }));
         this._register(this._ctx.onDidEndSessionLayoutRestore(() => {
-            const session = this._sessionsService.activeSession.get();
             const target = this._readTarget(undefined);
-            const ensureChanges = target.wantsChangesTab && session?.isCreated.get() === false;
             this.queueReconcile(target, {
-                openDefaultsIfEmpty: true,
-                ensureChanges,
+                openDefaultsIfEmpty: this._layoutService.isSidePaneVisible(),
                 workingSetRestored: true
             });
         }));
@@ -157,20 +161,24 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
                 return;
             }
             if (visible) {
-                this._queue(() => this._restoreCollapsedTabs());
+                const ownerKey = this._ownerKeyString();
+                this._queue(() => this._restoreCollapsedTabs(ownerKey));
                 return;
             }
             if (this._ctx.togglingSidePane) {
                 return;
             }
-            if (this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
-                this._queue(() => this._collapseNonManagedTabs());
+            this._queueCollapseIfDetailsOnly();
+        }));
+        this._register(this._ctx.onDidEndSessionLayoutRestore(() => {
+            if (this._ctx.chatLayoutActive() && this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+                const ownerKey = this._ownerKeyString();
+                this._queue(() => this._restoreCollapsedTabs(ownerKey));
+            } else {
+                this._queueCollapseIfDetailsOnly();
             }
         }));
-        this._register(
-            this._ctx.onDidEndSessionLayoutRestore(() => this._queueCollapseIfDetailsOnly())
-        );
-        this._register(this._editorService.onDidEditorsChange(() => {
+        this._register(mainEditorsChanged(() => {
             if (!this._ctx.isRestoringSessionLayout) {
                 this._queueCollapseIfDetailsOnly();
             }
@@ -180,15 +188,23 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
         const resource = editor.resource;
         return resource && this._sessionChangesService.getSessionResource(resource) ? resource : undefined;
     }
+    _ownerKeyString() {
+        const session = this._sessionsService.activeSession.get();
+        if (!session) {
+            return undefined;
+        }
+        const ownerKey = this._ctx.chatLayoutActive() ? this._ctx.ownerKeyFor(session) : undefined;
+        return ( (ownerKey ?? session.resource).toString());
+    }
     prepareWorkingSetRestore(hasSavedWorkingSet) {
-        const sessionKey = this._sessionsService.activeSession.get()?.resource.toString();
+        const sessionKey = this._ownerKeyString();
         this._preserveMissingFilesForSessionKey = hasSavedWorkingSet && this._filesTabDismissed ? sessionKey : undefined;
     }
     readTarget(reader) {
         return this._readTarget(reader);
     }
     queueReconcile(target, trigger) {
-        const sessionKey = this._sessionsService.activeSession.get()?.resource.toString();
+        const sessionKey = this._ownerKeyString();
         const mergedTrigger = this._pending && this._pending.sessionKey === sessionKey ? mergeTriggers(this._pending.trigger, trigger) : trigger;
         this._pending = {
             sessionKey,
@@ -221,8 +237,24 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
     dispose() {
         this._generation++;
         this._pending = undefined;
+        this._collapsedEditorsByOwner.clear();
         super.dispose();
     }
+    remapOwnerKey(oldKey, newKey) {
+        if (isEqual(oldKey, newKey)) {
+            return;
+        }
+        const captured = this._collapsedEditorsByOwner.get(( oldKey.toString()));
+        if (captured) {
+            this._collapsedEditorsByOwner.set(( newKey.toString()), captured);
+            this._collapsedEditorsByOwner.delete(( oldKey.toString()));
+        }
+    }
+    forgetOwnerKeys(keys) {
+        for (const key of keys) {
+            this._collapsedEditorsByOwner.delete(( key.toString()));
+        }
+    }
     _queue(task) {
         void this._sequencer.queue(() => this._store.isDisposed ? Promise.resolve() : task()).catch(error => {
             if (!this._store.isDisposed) {
@@ -246,6 +278,9 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
                     trigger: mergeTriggers(successor.trigger, pending.trigger)
                 };
             }
+            if (generation === this._generation && !this._ctx.isRestoringSessionLayout) {
+                this._ctx.completeChangesEditorTransition();
+            }
         }
     }
     async _reconcileCore(target, trigger, generation) {
@@ -262,7 +297,7 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
                 return;
             }
             this._updateFilesEditors(group, target.workspace);
-            const sessionKey = this._sessionsService.activeSession.get()?.resource.toString();
+            const sessionKey = this._ownerKeyString();
             const preserveMissingFiles = !!trigger.workingSetRestored && this._preserveMissingFilesForSessionKey === sessionKey;
             if (preserveMissingFiles) {
                 await this._removeFilesTab(group);
@@ -270,13 +305,13 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
                     return;
                 }
             }
-            const openIntoEmpty = !!trigger.openDefaultsIfEmpty && group.editors.length === 0;
+            const openIntoEmpty = !!trigger.openDefaultsIfEmpty && this._layoutService.isSidePaneVisible() && group.editors.length === 0;
             const changesPresent = !!changesResource && !!this._findChangesEditor(group, changesResource);
             const filesPresent = ( group.editors.some(editor => editor instanceof EmptyFileEditorInput));
             const activeChangesResource = this._editorService.activeEditor && this.getChangesEditorResource(this._editorService.activeEditor);
-            const activateChanges = !!trigger.ensureChangesActive && !!changesResource && (!activeChangesResource || !isEqual(activeChangesResource, changesResource));
+            const activateChanges = !!trigger.ensureChangesActive && changesPresent && !!changesResource && (!activeChangesResource || !isEqual(activeChangesResource, changesResource));
             const ensureAllInputs = this._layoutService.isVisible(Parts.AUXILIARYBAR_PART) && !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow);
-            const openChanges = target.wantsChangesTab && !!changesResource && (activateChanges || (!changesPresent && (openIntoEmpty || ensureAllInputs || trigger.ensureChanges)));
+            const openChanges = target.wantsChangesTab && !!changesResource && (activateChanges || (!changesPresent && (openIntoEmpty || ensureAllInputs)));
             const openFiles = target.wantsFilesTab && !filesPresent && !preserveMissingFiles && (openIntoEmpty || ensureAllInputs);
             const isCreated = this._sessionsService.activeSession.get()?.isCreated.get() ?? false;
             const openFilesFirst = openChanges && openFiles && !isCreated && group.editors.length === 0;
@@ -319,9 +354,11 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
         }
     }
     _resetCollapsedEditorsOnSessionChange() {
-        const sessionKey = this._sessionsService.activeSession.get()?.resource.toString();
+        const sessionKey = this._ownerKeyString();
         if (sessionKey !== this._lastSyncedSessionKey) {
-            this._collapsedEditors = undefined;
+            if (!this._ctx.chatLayoutActive() && !this._ctx.chatLayoutSuspended()) {
+                this._collapsedEditorsByOwner.clear();
+            }
             this._lastSyncedSessionKey = sessionKey;
         }
     }
@@ -443,17 +480,24 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
     }
     _queueCollapseIfDetailsOnly() {
         if (!this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow) && this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
-            this._queue(() => this._collapseNonManagedTabs());
+            const ownerKey = this._ownerKeyString();
+            this._queue(() => this._collapseNonManagedTabs(ownerKey));
         }
     }
-    async _collapseNonManagedTabs() {
+    async _collapseNonManagedTabs(ownerKey) {
+        if (this._ctx.isRestoringSessionLayout || this._ctx.chatLayoutSuspended() || this._ctx.togglingSidePane || ownerKey !== this._ownerKeyString() || this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow) || !this._layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
+            return;
+        }
         const group = this._editorGroupsService.mainPart.activeGroup;
-        const captured = [...(this._collapsedEditors ?? [])];
+        const captured = [...(this._collapsedEditorsByOwner.get(ownerKey) ?? [])];
         const toClose = [];
         group.editors.forEach((editor, index) => {
             if (editor instanceof DockedEditorInput || this.getChangesEditorResource(editor)) {
                 return;
             }
+            if (this._editorWorkingSetService.shouldRetainEditor(editor)) {
+                return;
+            }
             const untyped = editor.toUntyped();
             if (untyped) {
                 captured.push({
@@ -466,7 +510,7 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
         if (toClose.length === 0) {
             return;
         }
-        this._collapsedEditors = captured;
+        this._collapsedEditorsByOwner.set(ownerKey, captured);
         const suppressEditorPartAutoVisibility = this._layoutService.suppressEditorPartAutoVisibility();
         try {
             await this._editorService.closeEditors(toClose.map(editor => ({
@@ -479,9 +523,12 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
             suppressEditorPartAutoVisibility.dispose();
         }
     }
-    async _restoreCollapsedTabs() {
-        const captured = this._collapsedEditors;
-        this._collapsedEditors = undefined;
+    async _restoreCollapsedTabs(ownerKey) {
+        if (this._ctx.isRestoringSessionLayout || this._ctx.chatLayoutSuspended() || ownerKey !== this._ownerKeyString() || !this._layoutService.isVisible(Parts.EDITOR_PART, mainWindow)) {
+            return;
+        }
+        const captured = this._collapsedEditorsByOwner.get(ownerKey);
+        this._collapsedEditorsByOwner.delete(ownerKey);
         if (!captured || captured.length === 0) {
             return;
         }
@@ -508,6 +555,6 @@ let SinglePaneDockedTabsCoordinator = class SinglePaneDockedTabsCoordinator exte
         }
     }
 };
-SinglePaneDockedTabsCoordinator = ( __decorate([( __param(1, IAgentWorkbenchLayoutService)), ( __param(2, ISessionsService)), ( __param(3, IEditorService)), ( __param(4, IEditorGroupsService)), ( __param(5, ISessionChangesService)), ( __param(6, IChangesViewService)), ( __param(7, IContextKeyService)), ( __param(8, IInstantiationService))], SinglePaneDockedTabsCoordinator));
+DesktopDockedTabsCoordinator = ( __decorate([( __param(1, IAgentWorkbenchLayoutService)), ( __param(2, ISessionsService)), ( __param(3, IEditorService)), ( __param(4, IEditorGroupsService)), ( __param(5, ISessionChangesService)), ( __param(6, IChangesViewService)), ( __param(7, IContextKeyService)), ( __param(8, IInstantiationService)), ( __param(9, ISessionEditorWorkingSetService))], DesktopDockedTabsCoordinator));
 
-export { SinglePaneDockedTabsCoordinator };
+export { DesktopDockedTabsCoordinator };

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

@@ -4,13 +4,13 @@ import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench
 import { IAgentWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service";
 import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
 import { ISessionChangesService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService";
-import { SinglePaneDetailPanelCoordinator } from "./singlePaneDetailPanelCoordinator.js";
-import { ISinglePaneLayoutContext, SinglePaneLayoutStrategy } from "./singlePaneLayoutStrategy.js";
-import { SinglePaneVisibilityProfileStore } from "./singlePaneVisibilityProfileStore.js";
+import { DesktopDetailPanelCoordinator } from "./desktopDetailPanelCoordinator.js";
+import { IDesktopLayoutContext, DesktopLayoutStrategy } from "./desktopLayoutStrategy.js";
+import { DesktopVisibilityProfileStore } from "./desktopVisibilityProfileStore.js";
 /**
  * Owns workspace-backed and workspace-less draft layout behavior.
  */
-export declare class SinglePaneDraftSessionStrategy extends SinglePaneLayoutStrategy {
+export declare class DesktopDraftSessionStrategy extends DesktopLayoutStrategy {
     private readonly _detailPanel;
     private readonly _visibilityStore;
     private readonly _layoutService;
@@ -27,7 +27,12 @@ export declare class SinglePaneDraftSessionStrategy extends SinglePaneLayoutStra
     private _activeQuickChatKey;
     private _pendingEditorRestoreKey;
     private _changingVisibility;
-    constructor(ctx: ISinglePaneLayoutContext, _detailPanel: SinglePaneDetailPanelCoordinator, _visibilityStore: SinglePaneVisibilityProfileStore, _layoutService: IAgentWorkbenchLayoutService, _sessionsService: ISessionsService, _editorService: IEditorService, _editorGroupsService: IEditorGroupsService, _sessionChangesService: ISessionChangesService, _logService: ILogService);
+    constructor(ctx: IDesktopLayoutContext, _detailPanel: DesktopDetailPanelCoordinator, _visibilityStore: DesktopVisibilityProfileStore, _layoutService: IAgentWorkbenchLayoutService, _sessionsService: ISessionsService, _editorService: IEditorService, _editorGroupsService: IEditorGroupsService, _sessionChangesService: ISessionChangesService, _logService: ILogService);
+    private _activeOwnerKey;
+    private _readOwnerComposition;
+    private _applyOwnerComposition;
+    private _captureOwnerCompositionIfApplicable;
+    private _registerOwnerComposition;
     private _registerEntryEditorHide;
     private _registerQuickChatVisibility;
     private _captureQuickChatSharedVisibility;