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

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

@@ -1,11 +1,18 @@
 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 { ISessionChangesService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesService";
+import { ISessionWorkspace } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
 /** Whether every group in the main editor part is empty (used by both the detail-panel and side-pane-visibility logic to detect an empty side pane). */
 export declare function isMainPartEmpty(editorGroupsService: IEditorGroupsService): boolean;
 /** Whether `editor` is (or shows) a managed Changes multi-diff for some session. Shared by the New/Existing detail-panel mapping. */
 export declare function isChangesEditorInput(editor: EditorInput, sessionChangesService: ISessionChangesService): boolean;
-/** Whether `editor` is a file-like editor (the empty Files placeholder, a real file, or a markdown preview). Shared by the New/Existing detail-panel mapping. */
-export declare function isFileEditorInput(editor: EditorInput): boolean;
+/** How Files details apply to an editor in the active session workspace. */
+export declare enum FilesDetailsState {
+    Unavailable = 0,
+    Available = 1,
+    Active = 2
+}
+/** Classifies whether Files details apply to `editor` for the active session workspace. */
+export declare function getFilesDetailsState(editor: EditorInput, workspace: ISessionWorkspace): FilesDetailsState;
 /** Whether `editor` owns its full presentation and must hide the docked Details panel. */
 export declare function isEditorWithoutDockedDetails(editor: EditorInput): boolean;

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

@@ -0,0 +1,56 @@
+
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { isEqualOrParent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { DiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/diffEditorInput';
+import { EditorResourceAccessor, SideBySideEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { BrowserEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserEditorInput';
+import { CustomEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
+import { MultiDiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+import { WebviewInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { CanvasInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/canvases/common/canvas';
+import { EmptyFileEditorInput } from '../../../editor/browser/emptyFileEditorInput.js';
+
+const PULL_REQUEST_OVERVIEW_VIEW_TYPE = "PullRequestOverview";
+const ISSUE_OVERVIEW_VIEW_TYPE = "IssueOverview";
+function isMainPartEmpty(editorGroupsService) {
+    for (const group of editorGroupsService.mainPart.groups) {
+        if (!group.isEmpty) {
+            return false;
+        }
+    }
+    return true;
+}
+function isChangesEditorInput(editor, sessionChangesService) {
+    if (editor instanceof DiffEditorInput || editor instanceof MultiDiffEditorInput) {
+        return true;
+    }
+    const resource = editor.resource;
+    return !!resource && sessionChangesService.getSessionResource(resource) !== undefined;
+}
+var FilesDetailsState;
+(function(FilesDetailsState) {
+    FilesDetailsState[FilesDetailsState["Unavailable"] = 0] = "Unavailable";
+    FilesDetailsState[FilesDetailsState["Available"] = 1] = "Available";
+    FilesDetailsState[FilesDetailsState["Active"] = 2] = "Active";
+})(FilesDetailsState || (FilesDetailsState = {}));
+function getFilesDetailsState(editor, workspace) {
+    if (editor instanceof EmptyFileEditorInput) {
+        return FilesDetailsState.Active;
+    }
+    const resource = EditorResourceAccessor.getCanonicalUri(editor, {
+        supportSideBySide: SideBySideEditor.PRIMARY
+    });
+    if (!resource) {
+        return FilesDetailsState.Unavailable;
+    }
+    const matchingSchemeFolders = workspace.folders.filter(folder => folder.workingDirectory.scheme === resource.scheme);
+    if (matchingSchemeFolders.length === 0) {
+        return FilesDetailsState.Unavailable;
+    }
+    return ( matchingSchemeFolders.some(folder => isEqualOrParent(resource, folder.workingDirectory))) ? FilesDetailsState.Active : FilesDetailsState.Available;
+}
+function isEditorWithoutDockedDetails(editor) {
+    return editor instanceof BrowserEditorInput || editor instanceof CanvasInput || (editor instanceof CustomEditorInput && editor.resource?.scheme !== Schemas.untitled) || (editor instanceof WebviewInput && (editor.viewType === PULL_REQUEST_OVERVIEW_VIEW_TYPE || editor.providerId === PULL_REQUEST_OVERVIEW_VIEW_TYPE || editor.viewType === ISSUE_OVERVIEW_VIEW_TYPE || editor.providerId === ISSUE_OVERVIEW_VIEW_TYPE));
+}
+
+export { FilesDetailsState, getFilesDetailsState, isChangesEditorInput, isEditorWithoutDockedDetails, isMainPartEmpty };

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

@@ -10,10 +10,11 @@ export declare enum SessionVisibilityProfile {
 /**
  * Persists the Existing Session Editor/Details visibility profile.
  */
-export declare class SinglePaneVisibilityProfileStore {
+export declare class DesktopVisibilityProfileStore {
     private readonly _storageService;
     private _profiles;
-    constructor(_storageService: IStorageService);
+    constructor(shared: boolean, _storageService: IStorageService);
+    private readonly _storageKey;
     get(profile: SessionVisibilityProfile): ISidePaneVisibilityState;
     set(profile: SessionVisibilityProfile, state: ISidePaneVisibilityState): void;
     private _load;

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

@@ -8,7 +8,7 @@ var SessionVisibilityProfile;
     SessionVisibilityProfile[SessionVisibilityProfile["New"] = 0] = "New";
     SessionVisibilityProfile[SessionVisibilityProfile["Existing"] = 1] = "Existing";
 })(SessionVisibilityProfile || (SessionVisibilityProfile = {}));
-const SINGLE_PANE_VISIBILITY_STATE_KEY = "sessions.singlePane.sidePaneVisibility";
+const DESKTOP_VISIBILITY_STATE_KEY = "sessions.singlePane.sidePaneVisibility";
 const DEFAULT_NEW_SESSION_VISIBILITY_STATE = {
     editorVisible: false,
     auxiliaryBarVisible: true
@@ -17,13 +17,14 @@ const DEFAULT_EXISTING_SESSION_VISIBILITY_STATE = {
     editorVisible: true,
     auxiliaryBarVisible: false
 };
-let SinglePaneVisibilityProfileStore = class SinglePaneVisibilityProfileStore {
-    constructor(_storageService) {
+let DesktopVisibilityProfileStore = class DesktopVisibilityProfileStore {
+    constructor(shared, _storageService) {
         this._storageService = _storageService;
         this._profiles = {
             newSession: DEFAULT_NEW_SESSION_VISIBILITY_STATE,
             existingSession: DEFAULT_EXISTING_SESSION_VISIBILITY_STATE
         };
+        this._storageKey = shared ? "sessions.sharedChatLayout.sidePaneVisibility" : DESKTOP_VISIBILITY_STATE_KEY;
         this._load();
     }
     get(profile) {
@@ -38,14 +39,14 @@ let SinglePaneVisibilityProfileStore = class SinglePaneVisibilityProfileStore {
             existingSession: state
         };
         this._storageService.store(
-            SINGLE_PANE_VISIBILITY_STATE_KEY,
+            this._storageKey,
             JSON.stringify(this._profiles),
             StorageScope.WORKSPACE,
             StorageTarget.MACHINE
         );
     }
     _load() {
-        const raw = this._storageService.get(SINGLE_PANE_VISIBILITY_STATE_KEY, StorageScope.WORKSPACE);
+        const raw = this._storageService.get(this._storageKey, StorageScope.WORKSPACE);
         if (!raw) {
             return;
         }
@@ -62,16 +63,16 @@ let SinglePaneVisibilityProfileStore = class SinglePaneVisibilityProfileStore {
                     existingSession: parsed
                 };
             } else {
-                this._storageService.remove(SINGLE_PANE_VISIBILITY_STATE_KEY, StorageScope.WORKSPACE);
+                this._storageService.remove(this._storageKey, StorageScope.WORKSPACE);
             }
         } catch {
-            this._storageService.remove(SINGLE_PANE_VISIBILITY_STATE_KEY, StorageScope.WORKSPACE);
+            this._storageService.remove(this._storageKey, StorageScope.WORKSPACE);
         }
     }
     _isVisibilityState(value) {
         return typeof value?.editorVisible === "boolean" && typeof value.auxiliaryBarVisible === "boolean";
     }
 };
-SinglePaneVisibilityProfileStore = ( __decorate([( __param(0, IStorageService))], SinglePaneVisibilityProfileStore));
+DesktopVisibilityProfileStore = ( __decorate([( __param(1, IStorageService))], DesktopVisibilityProfileStore));
 
-export { SessionVisibilityProfile, SinglePaneVisibilityProfileStore };
+export { DesktopVisibilityProfileStore, SessionVisibilityProfile };

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

@@ -0,0 +1,71 @@
+import { IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IEditorWorkingSet } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { ISidePaneState } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench";
+import { IActiveSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { BaseLayoutController } from "./baseSessionLayoutController.js";
+import { DesktopOwnerCompositionStore } from "./desktop/desktopOwnerCompositionStore.js";
+export { TOGGLE_DETAILS_COMMAND_ID } from "./desktop/desktopExistingSessionStrategy.js";
+/**
+ * Layout controller for the desktop detail-panel layout. It owns its behavior
+ * through exactly two composed lifecycle strategies:
+ *  - {@link DesktopDraftSessionStrategy} — workspace-backed and workspace-less drafts;
+ *  - {@link DesktopExistingSessionStrategy} — a created, workspace-backed session
+ *    (also owns the Toggle Details command and the shared managed-tabs coordinator);
+ *
+ * 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 — a supplementary
+ * nuance on the shared managed-docked-tabs reconcile pipeline (`DesktopDockedTabsCoordinator`,
+ * which also performs the detail-only editor-area collapse). That coordinator, the detail
+ * panel's sync mechanics (`DesktopDetailPanelCoordinator`), and the shared New/Existing
+ * Editor-visibility-profile storage (`DesktopVisibilityProfileStore`) are non-strategy coordinator
+ * objects — see `desktop/desktopLayoutStrategy.ts`'s doc comment for why.
+ *
+ * Strategies coordinate through this controller (the {@link IDesktopLayoutContext}):
+ * a session-switch restore is signalled by {@link _isRestoringSessionLayout}, so
+ * a restore-driven editor change is never mistaken for a user action.
+ */
+export declare class DesktopLayoutController extends BaseLayoutController {
+    private _context;
+    private _existingSession;
+    private _managedTabs;
+    protected _compositionStore: DesktopOwnerCompositionStore | undefined;
+    private _changesEditorTransitionPhase;
+    private _onDidChangeChangesEditorTransition;
+    private readonly _changesEditorTransitionContextKey;
+    protected get _layoutStateStorageKey(): string;
+    private get _sharedChatLayout();
+    private _compositionKeyFor;
+    protected _panelVisibilityKeyFor(session: IActiveSession, reader?: IReader): URI | undefined;
+    protected _defaultPanelVisibility(key: URI): boolean;
+    protected get _isLayoutStateVersioned(): boolean;
+    protected get _legacyWorkingSetsStorageKey(): string | undefined;
+    protected get _legacyLayoutStateStorageKey(): string | undefined;
+    private get _ctx();
+    protected _registerViewStateManagement(): void;
+    protected _registerAuxiliaryControllers(): void;
+    /** Toggle the detail panel and return whether it is now visible. */
+    toggleDetails(): boolean;
+    protected preHideComposition(ownerKey: URI): ISidePaneState | undefined;
+    /**
+     * A session-switch restore closes/opens the docked editors (empty working-set
+     * apply, managed-tab reconciliation), so suppress editor-part auto-visibility
+     * for the whole restore to avoid closing the side pane or mistaking a
+     * layout-driven close for a user dismissing a managed tab.
+     */
+    protected _suppressEditorVisibilityDuringRestore(): IDisposable | undefined;
+    protected get _isEditorPartVisibilityPerSession(): boolean;
+    protected get _isViewStatePerSession(): boolean;
+    protected get _isPanelVisibilityPerSession(): boolean;
+    protected get _isPanelVisibilityPersisted(): boolean;
+    protected get _isPanelViewPerSession(): boolean;
+    protected _shouldRevealEditorPartOnApply(_editorPartHidden: boolean, _isModal: boolean): boolean;
+    protected _shouldHideEditorPartOnApply(_editorPartHidden: boolean): boolean;
+    protected _onWillApplyWorkingSet(workingSet: IEditorWorkingSet | "empty"): void;
+    protected _onActiveSessionSwitched(_previousSession: IActiveSession, session: IActiveSession | undefined): void;
+    private _shouldPreserveChangesEditor;
+    private _setChangesEditorTransitionPhase;
+    protected _onOwnerKeyRemapped(oldKey: URI, newKey: URI): void;
+    protected _onOwnerKeysForgotten(keys: readonly URI[]): void;
+}

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

@@ -0,0 +1,201 @@
+
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { DesktopChangesEditorTransitionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { BaseLayoutController } from './baseSessionLayoutController.js';
+import { DesktopDetailPanelCoordinator } from './desktop/desktopDetailPanelCoordinator.js';
+import { DesktopDockedTabsCoordinator } from './desktop/desktopDockedTabsCoordinator.js';
+import { DesktopDraftSessionStrategy } from './desktop/desktopDraftSessionStrategy.js';
+import { DesktopExistingSessionStrategy } from './desktop/desktopExistingSessionStrategy.js';
+export { TOGGLE_DETAILS_COMMAND_ID } from './desktop/desktopExistingSessionStrategy.js';
+import { DesktopOwnerCompositionStore } from './desktop/desktopOwnerCompositionStore.js';
+import { DesktopVisibilityProfileStore } from './desktop/desktopVisibilityProfileStore.js';
+
+const DESKTOP_LAYOUT_STATE_KEY = "sessions.singlePane.layoutState";
+const DESKTOP_CHAT_LAYOUT_STATE_KEY = "sessions.singlePane.chatLayoutState";
+const DESKTOP_SHARED_CHAT_LAYOUT_STATE_KEY = "sessions.singlePane.sharedChatLayoutState";
+const SHARED_EXISTING_VISIBILITY_KEY = ( URI.from({
+    scheme: "vscode-chat-layout-visibility",
+    path: "/existing"
+}));
+class DesktopLayoutController extends BaseLayoutController {
+    constructor() {
+        super(...arguments);
+        this._changesEditorTransitionPhase = "idle";
+        this._changesEditorTransitionContextKey = DesktopChangesEditorTransitionContext.bindTo(this._contextKeyService);
+    }
+    get _layoutStateStorageKey() {
+        if (this._sharedChatLayout) {
+            return DESKTOP_SHARED_CHAT_LAYOUT_STATE_KEY;
+        }
+        return this._chatLayoutEnabled ? DESKTOP_CHAT_LAYOUT_STATE_KEY : DESKTOP_LAYOUT_STATE_KEY;
+    }
+    get _sharedChatLayout() {
+        return this._chatLayoutEnabled && this._layoutService.chatLayoutPresentation.configured === "chat-shared";
+    }
+    _compositionKeyFor(session, reader) {
+        const ownerKey = this._ownerKeyFor(session, reader);
+        return ownerKey && this._sharedChatLayout && session.isCreated.read(reader) && !session.isQuickChat?.read(reader) && session.activeChat.read(reader).workspace.read(reader) ? SHARED_EXISTING_VISIBILITY_KEY : ownerKey;
+    }
+    _panelVisibilityKeyFor(session, reader) {
+        return this._compositionKeyFor(session, reader);
+    }
+    _defaultPanelVisibility(key) {
+        const visible = this._layoutService.isVisible(Parts.PANEL_PART);
+        this._panelVisibilityBySession.set(key, visible);
+        return visible;
+    }
+    get _isLayoutStateVersioned() {
+        return this._chatLayoutEnabled;
+    }
+    get _legacyWorkingSetsStorageKey() {
+        return undefined;
+    }
+    get _legacyLayoutStateStorageKey() {
+        return this._chatLayoutEnabled ? DESKTOP_LAYOUT_STATE_KEY : undefined;
+    }
+    get _ctx() {
+        if (!this._context) {
+            const that = this;
+            this._context = {
+                get isRestoringSessionLayout() {
+                    return that._isRestoringSessionLayout;
+                },
+                withSessionLayoutRestore: work => that._withSessionLayoutRestore(work),
+                onDidEndSessionLayoutRestore: that.onDidEndSessionLayoutRestore,
+                get togglingSidePane() {
+                    return that._togglingSidePane;
+                },
+                get multipleSessionsVisibleObs() {
+                    return that.multipleSessionsVisibleObs;
+                },
+                get activeSessionResourceObs() {
+                    return that.activeSessionResourceObs;
+                },
+                hasSavedWorkingSet: sessionResource => ( that._workingSets.has(sessionResource)),
+                completeChangesEditorTransition: () => {
+                    if (that._changesEditorTransitionPhase === "reconciling") {
+                        const session = that._sessionsService.activeSession.get();
+                        if (session?.isCreated.get() && session.isQuickChat?.get() !== true && !session.workspace.get()) {
+                            return;
+                        }
+                        that._setChangesEditorTransitionPhase("idle");
+                    }
+                },
+                chatLayoutActive: reader => that._chatLayoutActive(reader),
+                chatLayoutSuspended: reader => that._chatLayoutSuspended(reader),
+                get sharedChatLayout() {
+                    return that._sharedChatLayout;
+                },
+                ownerKeyFor: (session, reader) => that._ownerKeyFor(session, reader),
+                compositionKeyFor: (session, reader) => that._compositionKeyFor(session, reader),
+                get compositionStore() {
+                    return that._compositionStore;
+                }
+            };
+        }
+        return this._context;
+    }
+    _registerViewStateManagement() {
+        this._register(toDisposable(() => this._changesEditorTransitionContextKey.reset()));
+        this._compositionStore = this._instantiationService.createInstance(DesktopOwnerCompositionStore, this._sharedChatLayout);
+        this._registerPersistedOwnerKeys(this._compositionStore.ownerKeys);
+        const visibilityStore = this._instantiationService.createInstance(DesktopVisibilityProfileStore, this._sharedChatLayout);
+        const detailPanel = this._register(this._instantiationService.createInstance(DesktopDetailPanelCoordinator));
+        this._existingSession = this._register(
+            this._instantiationService.createInstance(DesktopExistingSessionStrategy, this._ctx, visibilityStore, detailPanel)
+        );
+        this._register(
+            this._instantiationService.createInstance(DesktopDraftSessionStrategy, this._ctx, detailPanel, visibilityStore)
+        );
+    }
+    _registerAuxiliaryControllers() {
+        this._lifecycleService.when(LifecyclePhase.Restored).then(() => {
+            if (this._store.isDisposed) {
+                return;
+            }
+            const onDidChangeChangesEditorTransition = this._onDidChangeChangesEditorTransition = this._register(( new Emitter()));
+            this._register(this.onDidEndSessionLayoutRestore(() => {
+                if (this._changesEditorTransitionPhase === "restoringWorkingSet") {
+                    this._setChangesEditorTransitionPhase("reconciling");
+                }
+            }));
+            this._register(this._editorGroupsService.registerContextKeyProvider({
+                contextKey: DesktopChangesEditorTransitionContext,
+                getGroupContextKeyValue: group => this._changesEditorTransitionPhase !== "idle" && group.id === this._editorGroupsService.mainPart.activeGroup.id && (group.activeEditor === null || !!group.activeEditor.resource && this._sessionChangesService.getSessionResource(group.activeEditor.resource) !== undefined),
+                onDidChange: onDidChangeChangesEditorTransition.event
+            }));
+            this._register(
+                this._editorGroupsService.mainPart.onDidAddGroup(() => onDidChangeChangesEditorTransition.fire())
+            );
+            this._managedTabs = this._register(
+                this._instantiationService.createInstance(DesktopDockedTabsCoordinator, this._ctx)
+            );
+            this._existingSession?.registerManagedTabs(this._managedTabs);
+        });
+    }
+    toggleDetails() {
+        return this._existingSession?.toggleDetails() ?? false;
+    }
+    preHideComposition(ownerKey) {
+        return this._compositionStore?.getPreHide(ownerKey);
+    }
+    _suppressEditorVisibilityDuringRestore() {
+        return this._layoutService.suppressEditorPartAutoVisibility();
+    }
+    get _isEditorPartVisibilityPerSession() {
+        return false;
+    }
+    get _isViewStatePerSession() {
+        return false;
+    }
+    get _isPanelVisibilityPerSession() {
+        return this._chatLayoutEnabled;
+    }
+    get _isPanelVisibilityPersisted() {
+        return this._chatLayoutEnabled;
+    }
+    get _isPanelViewPerSession() {
+        return true;
+    }
+    _shouldRevealEditorPartOnApply(_editorPartHidden, _isModal) {
+        return false;
+    }
+    _shouldHideEditorPartOnApply(_editorPartHidden) {
+        return false;
+    }
+    _onWillApplyWorkingSet(workingSet) {
+        this._managedTabs?.prepareWorkingSetRestore(workingSet !== "empty");
+        if ((this._changesEditorTransitionPhase ?? "idle") !== "idle" || this._shouldPreserveChangesEditor(this._sessionsService.activeSession.get())) {
+            this._setChangesEditorTransitionPhase("restoringWorkingSet");
+        }
+    }
+    _onActiveSessionSwitched(_previousSession, session) {
+        this._setChangesEditorTransitionPhase(this._shouldPreserveChangesEditor(session) ? "awaitingWorkingSet" : "idle");
+    }
+    _shouldPreserveChangesEditor(session) {
+        const editorResource = this._editorGroupsService.mainPart.activeGroup.activeEditor?.resource;
+        return !!session && session.isQuickChat?.get() !== true && !!editorResource && !!this._sessionChangesService.getSessionResource(editorResource);
+    }
+    _setChangesEditorTransitionPhase(phase) {
+        const previousPhase = this._changesEditorTransitionPhase ?? "idle";
+        this._changesEditorTransitionPhase = phase;
+        this._changesEditorTransitionContextKey.set(phase !== "idle");
+        if ((previousPhase === "idle") !== (phase === "idle")) {
+            this._onDidChangeChangesEditorTransition?.fire();
+        }
+    }
+    _onOwnerKeyRemapped(oldKey, newKey) {
+        this._compositionStore?.remap(oldKey, newKey);
+        this._managedTabs?.remapOwnerKey(oldKey, newKey);
+    }
+    _onOwnerKeysForgotten(keys) {
+        this._compositionStore?.forget(keys);
+        this._managedTabs?.forgetOwnerKeys(keys);
+    }
+}
+
+export { DesktopLayoutController };

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

@@ -1 +1,8 @@
-export {};
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IAgentWorkbenchLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service";
+export declare class SessionsLayoutContribution extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "workbench.contrib.sessionsLayoutContribution";
+    constructor(instantiationService: IInstantiationService, layoutService: IAgentWorkbenchLayoutService);
+}

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

@@ -1,18 +1,19 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { isWeb, isMobile } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
-import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
-import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
 import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { LayoutController, RESPONSIVE_SIDEBAR_SETTING } from './desktopSessionLayoutController.js';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
 import { MobileLayoutController } from './mobileSessionLayoutController.js';
-import { DOCK_DETAIL_PANEL_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionConfig';
+import { AgentWorkbenchLayout } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench';
 import { IAgentWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench.service';
-import { SinglePaneLayoutController } from './singlePaneLayoutController.js';
+import { DesktopLayoutController } from './desktopLayoutController.js';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Extensions, ConfigurationScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { SESSIONS_LAYOUT_SCOPE_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/chatLayout';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 
 let SessionsLayoutContribution = class SessionsLayoutContribution extends Disposable {
     static {
@@ -20,15 +21,11 @@ let SessionsLayoutContribution = class SessionsLayoutContribution extends Dispos
     }
     constructor(instantiationService, layoutService) {
         super();
-        if (layoutService.isSinglePaneLayoutEnabled) {
-            this._register(instantiationService.createInstance(SinglePaneLayoutController));
+        if (layoutService.agentWorkbenchLayout === AgentWorkbenchLayout.Desktop) {
+            this._register(instantiationService.createInstance(DesktopLayoutController));
             return;
         }
-        if (isWeb && isMobile) {
-            this._register(instantiationService.createInstance(MobileLayoutController));
-            return;
-        }
-        this._register(instantiationService.createInstance(LayoutController));
+        this._register(instantiationService.createInstance(MobileLayoutController));
     }
 };
 SessionsLayoutContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IAgentWorkbenchLayoutService))], SessionsLayoutContribution));
@@ -39,30 +36,33 @@ registerWorkbenchContribution2(
 );
 ( Registry.as(Extensions.Configuration)).registerConfiguration({
     id: "sessions",
+    title: ( localize(4755, "Sessions")),
     properties: {
-        [RESPONSIVE_SIDEBAR_SETTING]: {
-            type: "boolean",
-            markdownDescription: ( localize(
-                4119,
-                "Controls whether the sessions sidebar is automatically collapsed in a narrow Agents window while both the editor and the side panel are open, and shown again once either of them closes."
-            )),
-            default: product.quality !== "stable",
-            tags: ["experimental"],
-            experiment: {
-                mode: "auto"
-            }
-        },
-        [DOCK_DETAIL_PANEL_SETTING]: {
-            type: "boolean",
-            markdownDescription: ( localize(
-                4120,
-                "Controls whether the Agents window docks the detail panel inside the editor so a single editor tab bar spans across the editor and the detail panel. Requires a window reload to take effect."
-            )),
-            default: true,
+        [SESSIONS_LAYOUT_SCOPE_SETTING]: {
+            type: "string",
+            enum: ["session-shared", "chat-shared", "chat"],
+            enumDescriptions: [( localize(
+                4756,
+                "Keep editors and selected panel views separate for each session, with shared Editor, Details, and bottom-panel visibility across existing workspace sessions."
+            )), ( localize(
+                4757,
+                "Keep editors and selected panel views separate for each chat, with shared Editor, Details, and bottom-panel visibility across existing workspace chats."
+            )), ( localize(
+                4758,
+                "Keep editors, Editor and Details composition, bottom-panel visibility, and selected panel views separate for each chat."
+            ))],
+            default: "session-shared",
+            scope: ConfigurationScope.WINDOW,
             tags: ["experimental"],
             experiment: {
                 mode: "startup"
-            }
+            },
+            description: ( localize(
+                4759,
+                "Choose whether layout state belongs to each session or each chat in non-phone Agents windows. Pane sizes remain shared. Terminal behavior is unchanged in all modes. Changes take effect after manually reloading the window."
+            ))
         }
     }
 });
+
+export { SessionsLayoutContribution };

package/vscode/src/vs/sessions/contrib/layout/common/sessionEditorWorkingSet.d.ts

@@ -0,0 +1,39 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { ISessionEditorWorkingSetService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/layout/common/sessionEditorWorkingSet.service";
+/**
+ * The layout owner of an editor working set: a whole session, or a single chat of
+ * it when the window scopes layout to chats.
+ */
+export interface ISessionEditorWorkingSetOwner {
+    readonly sessionResource: URI;
+    /** The owning chat, or `undefined` when the working set belongs to the whole session. */
+    readonly chatResource: URI | undefined;
+}
+/** Whether the given chat of a session belongs to `owner`'s editor working set. */
+export declare function editorWorkingSetOwnerIncludes(owner: ISessionEditorWorkingSetOwner, sessionResource: URI, chatResource: URI): boolean;
+export interface ISessionEditorWorkingSetRestoreState {
+    /** The owner whose working set was restored most recently, or `undefined` for an empty working set. */
+    readonly owner: ISessionEditorWorkingSetOwner | undefined;
+    /**
+     * Whether a restore is queued or running. A restore replaces every open editor, so owners of
+     * editors that a working set cannot serialize close them when it begins and reopen them once it settles.
+     */
+    readonly restoring: boolean;
+    /** Whether the queued restore is currently replacing the editor working set. */
+    readonly applying: boolean;
+}
+export declare class SessionEditorWorkingSetService implements ISessionEditorWorkingSetService {
+    readonly _serviceBrand: undefined;
+    private readonly _restoreState;
+    readonly restoreState: IObservable<ISessionEditorWorkingSetRestoreState>;
+    private _pendingRestores;
+    private readonly _editorsToRetain;
+    setCurrentOwner(owner: ISessionEditorWorkingSetOwner | undefined): void;
+    registerEditorToRetain(input: EditorInput): IDisposable;
+    shouldRetainEditor(input: EditorInput): boolean;
+    beginApply(owner: ISessionEditorWorkingSetOwner | undefined): boolean;
+    beginRestore(owner: ISessionEditorWorkingSetOwner | undefined): IDisposable;
+}