@codingame/monaco-vscode-api 37.1.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/chat/browser/sessionWorkspacePicker.js

@@ -0,0 +1,1926 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, $, DisposableResizeObserver, getWindow, EventType, addDisposableListener, EventHelper, clearNode } from '../../../../base/browser/dom.js';
+import { Gesture, EventType as EventType$1 } from '../../../../base/browser/touch.js';
+import { status } from '../../../../base/browser/ui/aria/aria.js';
+import { CountBadge } from '../../../../base/browser/ui/countBadge/countBadge.js';
+import { toAction, SubmenuAction } from '../../../../base/common/actions.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { Limiter, RunOnceScheduler, disposableTimeout } from '../../../../base/common/async.js';
+import { Disposable, MutableDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { URI } from '../../../../base/common/uri.js';
+import '../../../../base/common/observableInternal/index.js';
+import { localize } from '../../../../nls.js';
+import { IActionWidgetService } from '../../../../platform/actionWidget/browser/actionWidget.service.js';
+import { ActionListItemKind } from '../../../../platform/actionWidget/browser/actionList.js';
+import { TabbedActionListWidget } from '../../../../platform/actionWidget/browser/tabbedActionListWidget.js';
+import { MenuItemAction } from '../../../../platform/actions/common/actions.js';
+import { IMenuService } from '../../../../platform/actions/common/actions.service.js';
+import { RemoteAgentHostsEnabledSettingId, RemoteAgentHostConnectionStatus } from '../../../../platform/agentHost/common/remoteAgentHostService.js';
+import { IRemoteAgentHostService } from '../../../../platform/agentHost/common/remoteAgentHostService.service.js';
+import { TUNNEL_ADDRESS_PREFIX } from '../../../../platform/agentHost/common/tunnelAgentHost.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IFileDialogService, IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.service.js';
+import '../../../../platform/notification/common/notification.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { renderIcon } from '../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { isActiveSessionStatus, SESSION_WORKSPACE_GROUP_LOCAL, SESSION_WORKSPACE_GROUP_GITHUB, SESSION_WORKSPACE_GROUP_REMOTE } from '../../../services/sessions/common/session.js';
+import { ISessionsProvidersService } from '../../../services/sessions/browser/sessionsProvidersService.service.js';
+import { isWorktreeWorkspaceUri } from '../../../services/sessions/browser/sessionsRecentWorkspacesService.js';
+import { ISessionsRecentWorkspacesService } from '../../../services/sessions/browser/sessionsRecentWorkspacesService.service.js';
+import { isAgentHostProvider } from '../../../common/agentHostSessionsProvider.js';
+import { SessionWorkspacePickerGroupContext } from '../../../common/contextkeys.js';
+import { getStatusLabel, getStatusHover, removeRemoteHost, showRemoteHostOptions } from '../../providers/remoteAgentHost/browser/remoteHostOptions.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
+import { defaultCountBadgeStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { DevContainerAgentHostEnabledSettingId } from '../../../common/devContainerAgentHostService.js';
+import { reportNewChatPickerClosed } from './newChatPickerTelemetry.js';
+import { Menus } from '../../../browser/menus.js';
+import { markOnboardingTarget } from '../../../../workbench/contrib/onboarding/browser/spotlight/onboardingTarget.js';
+import { NewSessionWorkspacePreselectionSource } from './newSessionComposerService.js';
+import { WorkspaceSelectionOrigin } from '../../../common/workspaceSelection.js';
+import { SessionWorkspaceFallback } from './sessionWorkspaceFallback.js';
+import { getAdditionalFolderContextId, ADDITIONAL_FOLDER_CONTEXT_ID_PREFIX, ADDITIONAL_REPOSITORY_CONTEXT_ID_PREFIX, getAdditionalRepositoryContextId } from '../common/newChatContextIds.js';
+import { UNIFIED_WORKSPACE_PICKER_SETTING } from '../common/constants.js';
+import { autorun } from '../../../../base/common/observableInternal/reactions/autorun.js';
+import Severity$1 from '../../../../base/common/severity.js';
+
+const FILTER_THRESHOLD = 10;
+const TABBED_PICKER_WIDTH = 360;
+const RESTORE_CONNECT_GRACE_MS = 5000;
+function getWorkspacePickerItemAriaLabel(item) {
+    return item.item?.ariaLabel ?? item.label ?? "";
+}
+function getRemoteHostStatusDescription(provider, status) {
+    const statusLabel = getStatusLabel(status);
+    const activeSessionCount = provider.getSessions().filter(
+        session => !session.isArchived.get() && isActiveSessionStatus(session.status.get())
+    ).length;
+    if (activeSessionCount === 0) {
+        return statusLabel;
+    }
+    return activeSessionCount === 1 ? ( localize(3905, "{0} · {1} active session", statusLabel, activeSessionCount)) : ( localize(3906, "{0} · {1} active sessions", statusLabel, activeSessionCount));
+}
+let WorkspacePicker = class WorkspacePicker extends Disposable {
+    get selectedFolderUri() {
+        return this._selectedFolderUri;
+    }
+    get selectedResolved() {
+        return this._selectedResolved;
+    }
+    get additionalFolderUris() {
+        return Array.from(( this._additionalFolderSelections.values()), selection => selection.workspace.folders[0].root);
+    }
+    get attachedContextWorkspaces() {
+        return Array.from(( this._additionalRepositorySelections.values()), selection => selection.workspace);
+    }
+    clearAttachedContext() {
+        if (this._additionalFolderSelections.size === 0 && this._additionalRepositorySelections.size === 0) {
+            return;
+        }
+        this._additionalFolderSelections.clear();
+        this._additionalRepositorySelections.clear();
+        this._updateTriggerLabel();
+        this._onDidChangeSelection.fire();
+    }
+    syncAttachedContext(attachments) {
+        this._attachedContext = attachments;
+        if (!this._syncAttachedContext()) {
+            this._updateTriggerLabel();
+        }
+    }
+    _syncAttachedContext() {
+        const attachmentIds = ( new Set(this._attachedContext.map(attachment => attachment.id)));
+        let changed = false;
+        for (const [key, contexts] of this._contextSelections) {
+            const retained = contexts.filter(context => ( attachmentIds.has(`github-context:${( context.uri.toString())}`)));
+            if (retained.length === contexts.length) {
+                continue;
+            }
+            changed = true;
+            if (retained.length > 0) {
+                this._contextSelections.set(key, retained);
+            } else {
+                this._contextSelections.delete(key);
+            }
+        }
+        for (const [key, selection] of this._additionalFolderSelections) {
+            if (!( attachmentIds.has(getAdditionalFolderContextId(selection.workspace.folders[0].root)))) {
+                this._additionalFolderSelections.delete(key);
+                changed = true;
+            }
+        }
+        for (const [key, selection] of this._additionalRepositorySelections) {
+            if (!( attachmentIds.has(selection.attachmentId))) {
+                this._additionalRepositorySelections.delete(key);
+                changed = true;
+            }
+        }
+        for (const attachment of this._attachedContext) {
+            if (attachment.id.startsWith(ADDITIONAL_FOLDER_CONTEXT_ID_PREFIX) && URI.isUri(attachment.value)) {
+                const resolved = this._resolveFolder(attachment.value);
+                if (resolved?.workspace.group === SESSION_WORKSPACE_GROUP_LOCAL) {
+                    const key = this.uriIdentityService.extUri.getComparisonKey(attachment.value);
+                    if (!( this._additionalFolderSelections.has(key))) {
+                        this._additionalFolderSelections.set(key, resolved);
+                        changed = true;
+                    }
+                }
+            } else if (attachment.id.startsWith(ADDITIONAL_REPOSITORY_CONTEXT_ID_PREFIX) && URI.isUri(attachment.value)) {
+                const resolved = this._resolveFolder(attachment.value);
+                const repositoryId = resolved && this._getRepositoryIdForResolvedWorkspace(resolved);
+                if (resolved?.workspace.group === SESSION_WORKSPACE_GROUP_GITHUB && repositoryId && !( this._additionalRepositorySelections.has(repositoryId))) {
+                    this._additionalRepositorySelections.set(repositoryId, {
+                        ...resolved,
+                        attachmentId: attachment.id
+                    });
+                    changed = true;
+                }
+            }
+        }
+        if (changed) {
+            this._updateTriggerLabel();
+            this._onDidChangeSelection.fire();
+        }
+        return changed;
+    }
+    get preselectionSource() {
+        return this._preselectionSource;
+    }
+    get selectionSnapshot() {
+        const restoreState = this._sessionRestoreState;
+        return {
+            folderUri: this._selectedFolderUri,
+            origin: this._selectionOrigin,
+            state: this.isNoWorkspaceSelected() ? "noWorkspace" : !this._selectedFolderUri ? "none" : this._selectedResolved ? "selected" : "unresolved",
+            historyState: this.recentWorkspacesService.historyLoadState.get(),
+            sessionFallbackState: !this._sessionWorkspaceFallback ? "disabled" : restoreState?.generation === this._sessionRestoreGeneration && restoreState.selectionGeneration === this._selectionGeneration && !this._userHasPicked && this._canRestoreWorkspace() ? restoreState.state : "idle",
+            registeredProviderCount: this.sessionsProvidersService.getProviders().length
+        };
+    }
+    matchesSelectedWorkspace(workspace) {
+        const folderUri = workspace.folders[0]?.root;
+        if (folderUri && this._selectedFolderUri && this.uriIdentityService.extUri.isEqual(folderUri, this._selectedFolderUri)) {
+            return true;
+        }
+        const selectedRepositoryId = this._getCurrentRepositoryId();
+        return selectedRepositoryId !== undefined && selectedRepositoryId === this._getRepositoryId(workspace);
+    }
+    constructor(
+        options,
+        actionWidgetService,
+        uriIdentityService,
+        sessionsProvidersService,
+        recentWorkspacesService,
+        remoteAgentHostService,
+        configurationService,
+        commandService,
+        menuService,
+        contextKeyService,
+        instantiationService,
+        fileDialogService,
+        telemetryService,
+        notificationService,
+        hoverService,
+        fileService,
+        dialogService
+    ) {
+        super();
+        this.options = options;
+        this.actionWidgetService = actionWidgetService;
+        this.uriIdentityService = uriIdentityService;
+        this.sessionsProvidersService = sessionsProvidersService;
+        this.recentWorkspacesService = recentWorkspacesService;
+        this.remoteAgentHostService = remoteAgentHostService;
+        this.configurationService = configurationService;
+        this.commandService = commandService;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this.instantiationService = instantiationService;
+        this.fileDialogService = fileDialogService;
+        this.telemetryService = telemetryService;
+        this.notificationService = notificationService;
+        this.hoverService = hoverService;
+        this.fileService = fileService;
+        this.dialogService = dialogService;
+        this._onDidSelectWorkspace = this._register(( new Emitter()));
+        this.onDidSelectWorkspace = this._onDidSelectWorkspace.event;
+        this._onDidSelectWorkspaceMode = this._register(( new Emitter()));
+        this.onDidSelectWorkspaceMode = this._onDidSelectWorkspaceMode.event;
+        this._onDidChangeSelection = this._register(( new Emitter()));
+        this.onDidChangeSelection = this._onDidChangeSelection.event;
+        this._onDidChangeChatPetPlatform = this._register(( new Emitter()));
+        this.onDidChangeChatPetPlatform = Event.any(this.onDidChangeSelection, this._onDidChangeChatPetPlatform.event);
+        this._onDidSelectContext = this._register(( new Emitter()));
+        this.onDidSelectContext = this._onDidSelectContext.event;
+        this._onDidSelectFolderContext = this._register(( new Emitter()));
+        this.onDidSelectFolderContext = this._onDidSelectFolderContext.event;
+        this._onDidSelectRepositoryContext = this._register(( new Emitter()));
+        this.onDidSelectRepositoryContext = this._onDidSelectRepositoryContext.event;
+        this._onDidRemoveAttachedContext = this._register(( new Emitter()));
+        this.onDidRemoveAttachedContext = this._onDidRemoveAttachedContext.event;
+        this._preselectionSource = NewSessionWorkspacePreselectionSource.None;
+        this._selectionOrigin = WorkspaceSelectionOrigin.None;
+        this._selectionGeneration = 0;
+        this._sessionRestoreGeneration = 0;
+        this._userHasPicked = false;
+        this._connectionStatusWatch = this._register(( new MutableDisposable()));
+        this._gitHubInfoWatch = this._register(( new MutableDisposable()));
+        this._providerSessionTypesWatch = this._register(( new MutableDisposable()));
+        this._localBrowseAction = {
+            label: ( localize(3907, "Select...")),
+            group: SESSION_WORKSPACE_GROUP_LOCAL,
+            icon: Codicon.folderOpened,
+            providerId: "",
+            run: async () => (await this._browseForLocalFolder())?.workspace
+        };
+        this._triggerElements = ( new Set());
+        this._triggerOptions = ( new Map());
+        this._triggerContents = ( new Map());
+        this._contextSelections = ( new Map());
+        this._renderDisposables = this._register(( new DisposableStore()));
+        this._additionalRepositorySelections = ( new Map());
+        this._additionalFolderSelections = ( new Map());
+        this._devContainerAvailability = ( new Map());
+        this._devContainerAvailabilityLimiter = this._register(( new Limiter(4)));
+        this._devContainerAvailabilityRefresh = this._register(( new RunOnceScheduler(() => {
+            const activeTrigger = this._activeTriggerElement;
+            if (!activeTrigger || (!this.actionWidgetService.isVisible && !this._tabbedWidget.isVisible)) {
+                return;
+            }
+            if (this._tabbedWidget.isVisible) {
+                this._tabbedWidget.refreshActiveList();
+            } else {
+                this.showPicker(
+                    true,
+                    activeTrigger,
+                    this._directPickerGroup,
+                    this._directPickerAttachesContext
+                );
+            }
+        }, 50)));
+        this._attachedContext = [];
+        this._userPickedTab = false;
+        this._tabbedWidget = this._register(this.instantiationService.createInstance(TabbedActionListWidget));
+        this._pickerGroupContext = SessionWorkspacePickerGroupContext.bindTo(this.contextKeyService);
+        this._register(
+            this._devContainerAvailabilityLimiter.onDrained(() => this._devContainerAvailabilityRefresh.schedule())
+        );
+        this._register(this._tabbedWidget.onDidChangeTab(tab => this._selectWorkspaceGroup(tab)));
+        this._register(this._tabbedWidget.onDidHide(() => {
+            this._pickerGroupContext.reset();
+        }));
+        this._sessionWorkspaceFallback = this.options.restoreFromSessions === false ? undefined : this._register(this.instantiationService.createInstance(SessionWorkspaceFallback, {
+            canUseProvider: providerId => this._canRestoreProviderWorkspace(providerId),
+            isProviderUnavailable: providerId => this._isProviderUnavailable(providerId),
+            resolveWorkspace: (folderUri, preferredProviderId) => this._resolveFolder(folderUri, preferredProviderId)
+        }));
+        this._watchProviderSessionTypes();
+        if (this._sessionWorkspaceFallback) {
+            this._register(
+                this._sessionWorkspaceFallback.onDidChange(() => this._restoreAutomaticSelection())
+            );
+        }
+        const restored = this._restoreSelectedWorkspace();
+        this._applySelection(restored?.resolved, restored?.source, restored?.origin);
+        if (this._selectedResolved) {
+            this._watchForConnectionFailure(this._selectedResolved);
+        } else {
+            this._scheduleSessionWorkspaceRestore();
+        }
+        this._register(this.sessionsProvidersService.onDidChangeProviders(() => {
+            this._watchProviderSessionTypes();
+            this._clearDevContainerAvailability();
+            this._sessionWorkspaceFallback?.refreshProviders();
+            if (this._selectedFolderUri) {
+                const reresolved = this._resolveFolder(this._selectedFolderUri);
+                if (!reresolved) {
+                    this._selectedFolderUri = undefined;
+                    this._selectedResolved = undefined;
+                    this._selectedDevContainerFolderUri = undefined;
+                    this._preselectionSource = NewSessionWorkspacePreselectionSource.None;
+                    this._selectionOrigin = WorkspaceSelectionOrigin.None;
+                    this._connectionStatusWatch.clear();
+                    this._gitHubInfoWatch.clear();
+                    this._updateTriggerLabel();
+                    this._onDidChangeSelection.fire();
+                    this._onDidSelectWorkspace.fire(undefined);
+                } else {
+                    this._selectedResolved = reresolved;
+                    this._watchSelectedGitHubInfo();
+                }
+            }
+            this._restoreAutomaticSelection();
+            this._syncAttachedContext();
+            const activeTrigger = this._activeTriggerElement;
+            if (activeTrigger && (this.actionWidgetService.isVisible || this._tabbedWidget.isVisible)) {
+                this.showPicker(
+                    true,
+                    activeTrigger,
+                    this._directPickerGroup,
+                    this._directPickerAttachesContext
+                );
+            }
+        }));
+        this._register(this.recentWorkspacesService.onDidChangeRecentWorkspaces(() => {
+            this._restoreAutomaticSelection();
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(DevContainerAgentHostEnabledSettingId) || e.affectsConfiguration(RemoteAgentHostsEnabledSettingId)) {
+                this._clearDevContainerAvailability(true);
+            }
+        }));
+        this._register(this.fileService.onDidFilesChange(e => {
+            const changedResources = [...e.rawAdded, ...e.rawUpdated, ...e.rawDeleted];
+            if (( changedResources.some(
+                resource => resource.path.endsWith("/.devcontainer") || resource.path.endsWith("/.devcontainer.json") || resource.path.endsWith("/.devcontainer/devcontainer.json")
+            ))) {
+                this._clearDevContainerAvailability(true);
+            }
+        }));
+        this._register(this.onDidSelectWorkspace(selection => {
+            if (selection && !this.actionWidgetService.isVisible && !this._tabbedWidget.isVisible) {
+                this._userPickedTab = false;
+            }
+        }));
+    }
+    _selectWorkspaceGroup(group) {
+        this._activeTab = group;
+        this._userPickedTab = true;
+        this._pickerGroupContext.set(group);
+    }
+    render(container) {
+        this._renderDisposables.clear();
+        const slot = append(
+            container,
+            $(".sessions-chat-picker-slot.sessions-chat-workspace-picker")
+        );
+        this._renderDisposables.add({
+            dispose: () => slot.remove()
+        });
+        this._renderDisposables.add(this._addTrigger(slot));
+        return slot;
+    }
+    renderCategoryTriggers(container, triggers, label) {
+        this._renderDisposables.clear();
+        const row = append(container, $(".sessions-workspace-category-picker"));
+        this._renderDisposables.add({
+            dispose: () => row.remove()
+        });
+        if (label) {
+            const rowLabel = append(row, $("span.sessions-workspace-category-picker-label"));
+            rowLabel.textContent = label;
+        }
+        for (const options of triggers) {
+            const slot = append(
+                row,
+                $(".sessions-chat-picker-slot.sessions-workspace-category-picker-slot")
+            );
+            slot.classList.toggle("sessions-workspace-picker-trigger", options.reflectsWorkspace === true);
+            this._renderDisposables.add(this._addTrigger(slot, options));
+        }
+        const platformObserver = this._renderDisposables.add(new DisposableResizeObserver(
+            "WorkspacePicker.chatPetPlatforms",
+            () => this._onDidChangeChatPetPlatform.fire(),
+            getWindow(row)
+        ));
+        for (const trigger of this._triggerElements) {
+            this._renderDisposables.add(platformObserver.observe(trigger));
+        }
+        return row;
+    }
+    getChatPetPlatformElements() {
+        return Array.from(this._triggerElements);
+    }
+    getContextPickerActions() {
+        return this.sessionsProvidersService.getProviders().flatMap(provider => provider.browseActions).filter(action => action.attachesContext === true).map(action => ({
+            label: action.label,
+            description: action.description,
+            icon: action.icon,
+            run: async () => {
+                await this._dispatchPickerItem({
+                    browseAction: action
+                });
+            }
+        }));
+    }
+    _addTrigger(slot, options) {
+        const triggerDisposables = ( new DisposableStore());
+        const trigger = append(slot, $("a.action-label"));
+        trigger.tabIndex = 0;
+        trigger.role = "button";
+        trigger.setAttribute("aria-haspopup", "listbox");
+        trigger.setAttribute("aria-expanded", "false");
+        this._triggerElements.add(trigger);
+        this._triggerContents.set(trigger, {});
+        if (options) {
+            this._triggerOptions.set(trigger, options);
+        }
+        this._triggerElement = trigger;
+        this._renderTriggerLabel(trigger);
+        if (options?.tooltip) {
+            triggerDisposables.add(this.hoverService.setupDelayedHover(trigger, {
+                content: options.tooltip
+            }));
+        }
+        triggerDisposables.add(markOnboardingTarget(trigger, "sessions.newSession.workspacePicker", {
+            open: () => this.showPicker(false, trigger, options?.group, options?.attachesContext)
+        }));
+        triggerDisposables.add(Gesture.addTarget(trigger));
+        [EventType.CLICK, EventType$1.Tap].forEach(eventType => {
+            triggerDisposables.add(addDisposableListener(trigger, eventType, e => {
+                EventHelper.stop(e, true);
+                this.showPicker(false, trigger, options?.group, options?.attachesContext);
+            }));
+        });
+        triggerDisposables.add(addDisposableListener(trigger, EventType.KEY_DOWN, e => {
+            if (e.key === "Enter" || e.key === " ") {
+                EventHelper.stop(e, true);
+                this.showPicker(false, trigger, options?.group, options?.attachesContext);
+            }
+        }));
+        triggerDisposables.add({
+            dispose: () => {
+                this._triggerContents.get(trigger)?.badge?.dispose();
+                this._triggerElements.delete(trigger);
+                this._triggerOptions.delete(trigger);
+                this._triggerContents.delete(trigger);
+                if (this._triggerElement === trigger) {
+                    this._triggerElement = ( this._triggerElements.values()).next().value;
+                }
+            }
+        });
+        return triggerDisposables;
+    }
+    showPicker(force = false, anchor, preferredGroup, attachesContext) {
+        const triggerElement = anchor ?? this._triggerElement;
+        if (!triggerElement) {
+            return;
+        }
+        const alreadyVisible = this.actionWidgetService.isVisible || this._tabbedWidget.isVisible;
+        if (alreadyVisible) {
+            if (this._activeTriggerElement === triggerElement) {
+                if (!force) {
+                    this._hidePicker();
+                    return;
+                }
+            }
+            this._hidePicker();
+        }
+        this._activeTriggerElement = triggerElement;
+        this._setDirectPickerFilter(preferredGroup, attachesContext);
+        if (preferredGroup === SESSION_WORKSPACE_GROUP_GITHUB && attachesContext === false && !this._getCurrentRepositoryId()) {
+            const items = this._buildItems();
+            const directBrowseItem = items.length === 1 && items[0].kind === ActionListItemKind.Action ? items[0].item : undefined;
+            if (directBrowseItem?.browseActionIndex !== undefined && !items[0].disabled) {
+                this._activeTriggerElement = undefined;
+                triggerElement.setAttribute("aria-expanded", "false");
+                void this._dispatchPickerItem(directBrowseItem).finally(() => {
+                    this._directPickerGroup = undefined;
+                    this._directPickerAttachesContext = undefined;
+                    triggerElement.focus();
+                });
+                return;
+            }
+        }
+        const tabs = this._showTabs() ? this._getAvailableTabs() : [];
+        if (preferredGroup === undefined && tabs.length > 0) {
+            const selectedGroup = this._getTabGroup(this._selectedResolved?.workspace.group);
+            if (!this._userPickedTab && selectedGroup && ( tabs.some(t => t.id === selectedGroup))) {
+                this._activeTab = selectedGroup;
+            }
+            if (!this._activeTab || !( tabs.some(t => t.id === this._activeTab))) {
+                this._activeTab = tabs[0].id;
+            }
+        }
+        if (preferredGroup !== undefined) {
+            this._showFlatPicker(triggerElement);
+        } else if (tabs.length > 1) {
+            this._showTabbedPicker(tabs, triggerElement);
+        } else {
+            this._activeTab = undefined;
+            this._showFlatPicker(triggerElement);
+        }
+    }
+    _setDirectPickerFilter(group, attachesContext) {
+        this._directPickerGroup = group;
+        this._directPickerAttachesContext = attachesContext;
+        if (group !== undefined) {
+            this._selectWorkspaceGroup(group);
+        }
+    }
+    refreshPresentation() {
+        this._updateTriggerLabel();
+    }
+    _showTabs() {
+        return !this._useConsolidatedRemoteWorkspaces();
+    }
+    _getAvailableTabs() {
+        const byLabel = ( new Map());
+        const remoteAgentHostsEnabled = this.configurationService.getValue(RemoteAgentHostsEnabledSettingId);
+        if (remoteAgentHostsEnabled) {
+            byLabel.set(SESSION_WORKSPACE_GROUP_REMOTE, {
+                id: SESSION_WORKSPACE_GROUP_REMOTE,
+                icon: Codicon.beaker,
+                tooltip: `${SESSION_WORKSPACE_GROUP_REMOTE} (${( localize(3908, "Experimental"))})`
+            });
+        }
+        for (const provider of this.sessionsProvidersService.getProviders()) {
+            if (provider.supportsLocalWorkspaces && !( byLabel.has(SESSION_WORKSPACE_GROUP_LOCAL))) {
+                byLabel.set(SESSION_WORKSPACE_GROUP_LOCAL, {
+                    id: SESSION_WORKSPACE_GROUP_LOCAL
+                });
+            }
+            for (const action of provider.browseActions) {
+                if (action.group === SESSION_WORKSPACE_GROUP_REMOTE && !remoteAgentHostsEnabled) {
+                    continue;
+                }
+                const group = this._getTabGroup(action.group);
+                if (group && !( byLabel.has(group))) {
+                    byLabel.set(group, {
+                        id: group
+                    });
+                }
+            }
+        }
+        return Array.from(( byLabel.values())).sort(
+            (a, b) => a.id === SESSION_WORKSPACE_GROUP_LOCAL ? -1 : b.id === SESSION_WORKSPACE_GROUP_LOCAL ? 1 : a.id.localeCompare(b.id)
+        );
+    }
+    _buildDelegate(triggerElement, hide) {
+        return {
+            onSelect: item => {
+                void this._dispatchPickerItem(item);
+                hide();
+            },
+            onHide: () => {
+                triggerElement.setAttribute("aria-expanded", "false");
+                if (this._activeTriggerElement === triggerElement) {
+                    this._activeTriggerElement = undefined;
+                    this._directPickerGroup = undefined;
+                    this._directPickerAttachesContext = undefined;
+                }
+                triggerElement.focus();
+            }
+        };
+    }
+    _buildListOptions(items, pickerWidth) {
+        const isConsolidatedWorkspacePicker = this._useConsolidatedRemoteWorkspaces() && this._directPickerAttachesContext !== true;
+        const showFilter = isConsolidatedWorkspacePicker || items.filter(i => i.kind === ActionListItemKind.Action).length > FILTER_THRESHOLD;
+        return showFilter ? {
+            className: "sessions-new-chat-picker-list",
+            showFilter: true,
+            focusFilterOnOpen: isConsolidatedWorkspacePicker,
+            filterPlaceholder: isConsolidatedWorkspacePicker ? ( localize(3909, "Search")) : undefined,
+            reserveSubmenuSpace: false,
+            inlineDescription: true,
+            showGroupTitleOnFirstItem: true,
+            minWidth: pickerWidth,
+            maxWidth: pickerWidth,
+            hideDefaultKeybindingTooltip: true
+        } : {
+            className: "sessions-new-chat-picker-list",
+            reserveSubmenuSpace: false,
+            inlineDescription: true,
+            showGroupTitleOnFirstItem: true,
+            minWidth: pickerWidth,
+            maxWidth: pickerWidth,
+            hideDefaultKeybindingTooltip: true
+        };
+    }
+    _showFlatPicker(triggerElement) {
+        this._tabbedWidget.hide();
+        const items = this._buildItems();
+        const delegate = this._buildDelegate(triggerElement, () => this._hidePicker());
+        triggerElement.setAttribute("aria-expanded", "true");
+        this.actionWidgetService.show(
+            "workspacePicker",
+            false,
+            items,
+            delegate,
+            triggerElement,
+            undefined,
+            [],
+            {
+                getAriaLabel: getWorkspacePickerItemAriaLabel,
+                getWidgetAriaLabel: () => ( localize(3910, "Workspace Picker"))
+            },
+            this._buildListOptions(items, undefined)
+        );
+    }
+    _showTabbedPicker(tabs, triggerElement) {
+        if (this.actionWidgetService.isVisible) {
+            this.actionWidgetService.hide();
+        }
+        const delegate = this._buildDelegate(triggerElement, () => this._hidePicker());
+        const accessibilityProvider = {
+            getAriaLabel: getWorkspacePickerItemAriaLabel,
+            getWidgetAriaLabel: () => ( localize(3910, "Workspace Picker"))
+        };
+        triggerElement.setAttribute("aria-expanded", "true");
+        this._pickerGroupContext.set(this._activeTab ?? tabs[0].id);
+        this._tabbedWidget.show({
+            user: "workspacePicker",
+            anchor: triggerElement,
+            tabs,
+            initialTab: this._activeTab ?? tabs[0].id,
+            createActionList: tab => {
+                this._activeTab = tab;
+                const items = this._buildItems();
+                const listOptions = this._useConsolidatedRemoteWorkspaces() ? this._buildListOptions(items, undefined) : {
+                    className: "sessions-new-chat-picker-list",
+                    inlineDescription: true,
+                    showGroupTitleOnFirstItem: true,
+                    hideDefaultKeybindingTooltip: true
+                };
+                return {
+                    items,
+                    listOptions
+                };
+            },
+            delegate,
+            accessibilityProvider,
+            width: TABBED_PICKER_WIDTH,
+            tabBarClassName: "sessions-workspace-picker-tabbar"
+        });
+    }
+    async _dispatchPickerItem(item) {
+        const generation = ++this._selectionGeneration;
+        this._reportPickerClosed(item);
+        if (item.run) {
+            item.run();
+            return true;
+        } else if (item.commandId) {
+            void this.commandService.executeCommand(item.commandId);
+            return true;
+        } else if (item.folderUri && item.providerId && this._isProviderUnavailable(item.providerId)) {
+            return false;
+        }
+        if (item.browseActionIndex !== undefined || item.browseAction) {
+            const selection = await this._executeBrowseAction(item.browseActionIndex, item.browseAction);
+            const folderUri = selection?.workspace.folders[0]?.root;
+            if (!folderUri || generation !== this._selectionGeneration) {
+                return false;
+            }
+            if (!(await this._canSelectWorkspace(folderUri, selection.providerId))) {
+                return false;
+            }
+            if (generation !== this._selectionGeneration) {
+                return false;
+            }
+            const action = selection.action;
+            if (action?.attachesContext) {
+                if (action.group) {
+                    const key = `${action.group}:context`;
+                    const contexts = this._contextSelections.get(key) ?? [];
+                    if (!( contexts.some(context => ( context.uri.toString()) === ( selection.workspace.uri.toString())))) {
+                        this._contextSelections.set(key, [...contexts, selection.workspace]);
+                    }
+                    this._updateTriggerLabel();
+                }
+                this._onDidSelectContext.fire(selection.workspace);
+                if (this._selectedFolderUri) {
+                    return true;
+                }
+            }
+            if (item.attachAsContext) {
+                if (action?.group === SESSION_WORKSPACE_GROUP_GITHUB && action.attachesContext !== true && action.supportsContextAttachment === true) {
+                    return this._attachAdditionalRepository(selection.workspace, selection.providerId);
+                }
+                if (action === this._localBrowseAction) {
+                    return this._attachAdditionalFolder(folderUri, selection.providerId);
+                }
+                return false;
+            }
+            this._selectedDevContainerFolderUri = undefined;
+            this._onDidSelectWorkspaceMode.fire({
+                folderUri,
+                preferDevContainer: false
+            });
+            const relatedWorkspace = this._findRelatedLocalWorkspace(selection.workspace);
+            this._selectFolder(
+                relatedWorkspace?.workspace.folders[0]?.root ?? folderUri,
+                true,
+                relatedWorkspace?.providerId ?? selection.providerId
+            );
+            return true;
+        } else if (item.folderUri) {
+            if (item.providerId && !(await this._connectProviderOnDemand(item.providerId))) {
+                return false;
+            }
+            if (generation !== this._selectionGeneration) {
+                return false;
+            }
+            if (!(await this._canSelectWorkspace(item.folderUri, item.providerId))) {
+                return false;
+            }
+            if (generation !== this._selectionGeneration) {
+                return false;
+            }
+            this._selectedDevContainerFolderUri = item.preferDevContainer ? item.folderUri : undefined;
+            this._onDidSelectWorkspaceMode.fire({
+                folderUri: item.folderUri,
+                preferDevContainer: item.preferDevContainer === true
+            });
+            this._selectFolder(item.folderUri, true, item.providerId);
+            return true;
+        }
+        return false;
+    }
+    _attachAdditionalFolder(folderUri, providerId) {
+        if (!this._selectedFolderUri || this.uriIdentityService.extUri.isEqual(this._selectedFolderUri, folderUri)) {
+            return false;
+        }
+        const resolved = this._resolveFolder(folderUri, providerId);
+        if (resolved?.workspace.group !== SESSION_WORKSPACE_GROUP_LOCAL) {
+            return false;
+        }
+        const key = this.uriIdentityService.extUri.getComparisonKey(folderUri);
+        if (!( this._additionalFolderSelections.has(key))) {
+            this._additionalFolderSelections.set(key, resolved);
+            this.recentWorkspacesService.addRecentWorkspace(folderUri, providerId, false);
+            this._updateTriggerLabel();
+            this._onDidSelectFolderContext.fire(folderUri);
+        }
+        return true;
+    }
+    _attachAdditionalRepository(workspace, providerId) {
+        if (!this._selectedFolderUri || workspace.group !== SESSION_WORKSPACE_GROUP_GITHUB) {
+            return false;
+        }
+        const repositoryId = this._getRepositoryId(workspace);
+        if (!repositoryId) {
+            return false;
+        }
+        if (!( this._additionalRepositorySelections.has(repositoryId))) {
+            const selection = {
+                workspace,
+                providerId
+            };
+            this._additionalRepositorySelections.set(repositoryId, {
+                ...selection,
+                attachmentId: getAdditionalRepositoryContextId(workspace.uri)
+            });
+            this.recentWorkspacesService.addRecentWorkspace(workspace.folders[0].root, providerId, false);
+            this._updateTriggerLabel();
+            this._onDidSelectRepositoryContext.fire(selection);
+            this._onDidChangeSelection.fire();
+        }
+        return true;
+    }
+    _findRelatedLocalWorkspace(workspace) {
+        const repositoryId = this._getRepositoryId(workspace);
+        if (!repositoryId) {
+            return undefined;
+        }
+        const matchesRepository = candidate => candidate.workspace.group === SESSION_WORKSPACE_GROUP_LOCAL && this._getRepositoryIdForResolvedWorkspace(candidate) === repositoryId;
+        if (this._selectedResolved && matchesRepository(this._selectedResolved)) {
+            return this._selectedResolved;
+        }
+        return this._getRecentWorkspaces().find(matchesRepository);
+    }
+    _getRepositoryId(workspace) {
+        for (const folder of workspace.folders) {
+            folder.gitRepository?.resolveGitHubInfo?.();
+        }
+        const info = workspace.folders.map(folder => folder.gitRepository?.gitHubInfo.get()).find(candidate => candidate !== undefined);
+        if (info) {
+            return `${info.owner}/${info.repo}`.toLowerCase();
+        }
+        if (workspace.group !== SESSION_WORKSPACE_GROUP_GITHUB) {
+            return undefined;
+        }
+        const pathSegments = workspace.folders[0]?.root.path.split("/").filter(Boolean);
+        return pathSegments?.[0] && pathSegments[1] ? `${pathSegments[0]}/${pathSegments[1]}`.toLowerCase() : undefined;
+    }
+    _watchProviderSessionTypes() {
+        const store = ( new DisposableStore());
+        this._providerSessionTypesWatch.value = store;
+        for (const provider of this.sessionsProvidersService.getProviders()) {
+            store.add(provider.onDidChangeSessionTypes(() => {
+                const activeTrigger = this._activeTriggerElement;
+                if (activeTrigger && (this.actionWidgetService.isVisible || this._tabbedWidget.isVisible)) {
+                    this.showPicker(
+                        true,
+                        activeTrigger,
+                        this._directPickerGroup,
+                        this._directPickerAttachesContext
+                    );
+                }
+            }));
+            if (isAgentHostProvider(provider) && provider.onDidChangeDevContainerAvailability) {
+                store.add(
+                    provider.onDidChangeDevContainerAvailability(() => this._clearDevContainerAvailability(true))
+                );
+            }
+        }
+    }
+    _getCurrentRepositoryId() {
+        const workspace = this._getSelectedRepositoryWorkspace();
+        return workspace && this._getRepositoryId(workspace);
+    }
+    _reportPickerClosed(item) {
+        const beforeFromStorage = this._restoreCheckedWorkspace();
+        const before = beforeFromStorage ?? this._selectedResolved;
+        const afterUri = item.folderUri;
+        const afterResolved = afterUri ? this._resolveFolder(afterUri) : undefined;
+        reportNewChatPickerClosed(this.telemetryService, {
+            id: "NewChatWorkspacePicker",
+            name: "NewChatWorkspacePicker",
+            optionIdBefore: before?.workspace?.uri.toString(),
+            optionIdAfter: afterResolved?.workspace?.uri.toString(),
+            optionLabelBefore: before?.workspace?.label,
+            optionLabelAfter: afterResolved?.workspace?.label,
+            isPII: true
+        });
+    }
+    setSelectedWorkspace(folderUri, options) {
+        this._selectedDevContainerFolderUri = options?.preferDevContainer ? folderUri : undefined;
+        const origin = options?.origin ?? WorkspaceSelectionOrigin.Programmatic;
+        const preserveOrigin = (origin === WorkspaceSelectionOrigin.RestoredDraft || origin === WorkspaceSelectionOrigin.SessionSync) && this._isSelectedFolder(folderUri);
+        this._selectFolder(
+            folderUri,
+            options?.fireEvent ?? true,
+            options?.providerId,
+            options?.persist ?? true,
+            NewSessionWorkspacePreselectionSource.ProvidedWorkspace,
+            preserveOrigin ? this._selectionOrigin : origin
+        );
+    }
+    _hidePicker() {
+        this._tabbedWidget.hide();
+        if (this.actionWidgetService.isVisible) {
+            this.actionWidgetService.hide();
+        }
+        this._activeTriggerElement?.setAttribute("aria-expanded", "false");
+        this._activeTriggerElement = undefined;
+        this._directPickerGroup = undefined;
+        this._directPickerAttachesContext = undefined;
+    }
+    clearSelection() {
+        this.options.onUserSelection?.();
+        this._selectionGeneration++;
+        this._hidePicker();
+        this._userHasPicked = true;
+        this._connectionStatusWatch.clear();
+        this._selectedFolderUri = undefined;
+        this._selectedResolved = undefined;
+        this._preselectionSource = NewSessionWorkspacePreselectionSource.None;
+        this._selectionOrigin = WorkspaceSelectionOrigin.None;
+        if (this._shouldPersistSelection()) {
+            this.recentWorkspacesService.clearCheckedWorkspace();
+        }
+        this._updateTriggerLabel();
+        this._onDidChangeSelection.fire();
+        this._onDidSelectWorkspace.fire(undefined);
+    }
+    isNoWorkspaceSelected() {
+        return !!this.options.getNoWorkspaceOption && this.recentWorkspacesService.isNoWorkspaceChecked();
+    }
+    selectNoWorkspace() {
+        this.options.onUserSelection?.();
+        this._selectionGeneration++;
+        this._sessionRestoreGeneration++;
+        this._hidePicker();
+        this._userHasPicked = true;
+        this._connectionStatusWatch.clear();
+        this._applySelection(undefined);
+        this.recentWorkspacesService.checkNoWorkspace();
+        this._updateTriggerLabel();
+        this._onDidChangeSelection.fire();
+    }
+    removeFromRecents(uri) {
+        if (this._selectedFolderUri && this.uriIdentityService.extUri.isEqual(this._selectedFolderUri, uri)) {
+            this.clearSelection();
+        }
+    }
+    _selectFolder(
+        folderUri,
+        fireEvent = true,
+        providerIdHint,
+        persist = true,
+        source = NewSessionWorkspacePreselectionSource.User,
+        origin = WorkspaceSelectionOrigin.User
+    ) {
+        if (source === NewSessionWorkspacePreselectionSource.User) {
+            this.options.onUserSelection?.();
+        }
+        this._selectionGeneration++;
+        this._userHasPicked = true;
+        this._connectionStatusWatch.clear();
+        const storedProviderId = this.recentWorkspacesService.getRecentWorkspaces().find(
+            r => this.uriIdentityService.extUri.isEqual(r.workspace.folders[0]?.root, folderUri)
+        )?.providerId;
+        const resolved = this._resolveFolder(folderUri, providerIdHint ?? storedProviderId);
+        const additionalFolderKey = this.uriIdentityService.extUri.getComparisonKey(folderUri);
+        const additionalFolder = this._additionalFolderSelections.get(additionalFolderKey);
+        const removedAdditionalFolder = this._additionalFolderSelections.delete(additionalFolderKey);
+        const repositoryId = resolved && this._getRepositoryIdForResolvedWorkspace(resolved);
+        const additionalRepository = repositoryId ? this._additionalRepositorySelections.get(repositoryId) : undefined;
+        const removedAdditionalRepository = repositoryId ? this._additionalRepositorySelections.delete(repositoryId) : false;
+        if (removedAdditionalFolder && additionalFolder) {
+            this._onDidRemoveAttachedContext.fire(getAdditionalFolderContextId(additionalFolder.workspace.folders[0].root));
+        }
+        if (removedAdditionalRepository && additionalRepository) {
+            this._onDidRemoveAttachedContext.fire(additionalRepository.attachmentId);
+        }
+        this._selectedFolderUri = folderUri;
+        this._selectedResolved = resolved;
+        this._watchSelectedGitHubInfo();
+        this._preselectionSource = source;
+        this._selectionOrigin = origin;
+        if (persist && this._shouldPersistSelection()) {
+            this.recentWorkspacesService.addRecentWorkspace(folderUri, resolved?.providerId, true);
+        }
+        this._updateTriggerLabel();
+        this._onDidChangeSelection.fire();
+        if (fireEvent) {
+            this._onDidSelectWorkspace.fire(folderUri);
+        }
+    }
+    _shouldPersistSelection() {
+        return true;
+    }
+    _applySelection(
+        resolved,
+        source = NewSessionWorkspacePreselectionSource.None,
+        origin = WorkspaceSelectionOrigin.None
+    ) {
+        this._selectedResolved = resolved;
+        this._selectedFolderUri = resolved?.workspace.folders[0]?.root;
+        this._watchSelectedGitHubInfo();
+        this._preselectionSource = resolved ? source : NewSessionWorkspacePreselectionSource.None;
+        this._selectionOrigin = resolved ? origin : WorkspaceSelectionOrigin.None;
+    }
+    _watchSelectedGitHubInfo() {
+        const store = ( new DisposableStore());
+        this._gitHubInfoWatch.value = store;
+        const observed = ( new Set());
+        for (const workspace of this._getSelectedRepositoryWorkspaceCandidates()) {
+            for (const folder of workspace.folders) {
+                folder.gitRepository?.resolveGitHubInfo?.();
+                const gitHubInfo = folder.gitRepository?.gitHubInfo;
+                if (gitHubInfo && !( observed.has(gitHubInfo))) {
+                    observed.add(gitHubInfo);
+                    store.add(autorun(reader => {
+                        gitHubInfo.read(reader);
+                        this._updateTriggerLabel();
+                    }));
+                }
+            }
+        }
+    }
+    _getSelectedRepositoryWorkspace() {
+        return this._getSelectedRepositoryWorkspaceCandidates().find(workspace => this._getRepositoryId(workspace) !== undefined);
+    }
+    _getSelectedRepositoryWorkspaceCandidates() {
+        if (!this._selectedResolved || !this._selectedFolderUri) {
+            return [];
+        }
+        return this._getRepositoryWorkspaceCandidates(this._selectedResolved);
+    }
+    _getRepositoryIdForResolvedWorkspace(selection) {
+        for (const workspace of this._getRepositoryWorkspaceCandidates(selection)) {
+            const repositoryId = this._getRepositoryId(workspace);
+            if (repositoryId) {
+                return repositoryId;
+            }
+        }
+        return undefined;
+    }
+    _getRepositoryWorkspaceCandidates(selection) {
+        const folderUri = selection.workspace.folders[0]?.root;
+        if (!folderUri) {
+            return [selection.workspace];
+        }
+        const candidates = [selection.workspace];
+        for (const provider of this.sessionsProvidersService.getProviders()) {
+            if (provider.id === selection.providerId) {
+                continue;
+            }
+            const workspace = provider.resolveWorkspace(folderUri);
+            if (workspace?.group === SESSION_WORKSPACE_GROUP_LOCAL) {
+                candidates.push(workspace);
+            }
+        }
+        return candidates;
+    }
+    _resolveFolder(folderUri, preferredProviderId) {
+        if (preferredProviderId) {
+            const preferred = this.sessionsProvidersService.getProvider(preferredProviderId);
+            const workspace = preferred?.resolveWorkspace(folderUri);
+            if (workspace) {
+                return {
+                    providerId: preferredProviderId,
+                    workspace
+                };
+            }
+        }
+        for (const provider of this.sessionsProvidersService.getProviders()) {
+            const workspace = provider.resolveWorkspace(folderUri);
+            if (workspace) {
+                return {
+                    providerId: provider.id,
+                    workspace
+                };
+            }
+        }
+        return undefined;
+    }
+    async _executeBrowseAction(actionIndex, browseAction) {
+        const action = browseAction ?? (actionIndex !== undefined ? this._getAllBrowseActions()[actionIndex] : undefined);
+        if (!action) {
+            return undefined;
+        }
+        await Promise.resolve();
+        try {
+            if (action === this._localBrowseAction) {
+                const selection = await this._browseForLocalFolder();
+                return selection ? {
+                    ...selection,
+                    action
+                } : undefined;
+            }
+            const actionProvider = this.sessionsProvidersService.getProvider(action.providerId);
+            const currentWorkspace = action.attachesContext && this._selectedFolderUri ? (actionProvider?.resolveWorkspace(this._selectedFolderUri) ?? this._selectedResolved?.workspace) : (this._getSelectedRepositoryWorkspace() ?? this._selectedResolved?.workspace);
+            const workspace = await action.run(currentWorkspace);
+            return workspace ? {
+                workspace,
+                providerId: action.providerId,
+                action
+            } : undefined;
+        } catch {}
+        return undefined;
+    }
+    async _canSelectWorkspace(folderUri, providerId) {
+        if (folderUri.scheme === Schemas.file && this.fileService.hasProvider(folderUri)) {
+            const generation = this._selectionGeneration;
+            const exists = await this.fileService.exists(folderUri);
+            if (generation !== this._selectionGeneration) {
+                return false;
+            }
+            if (!exists) {
+                this._removeRecentWorkspace(folderUri);
+                await this.dialogService.info(( localize(3911, "Path does not exist")), ( localize(3912, "The path '{0}' does not exist on this computer.", folderUri.fsPath)));
+                return false;
+            }
+        }
+        return !this.options.canSelectWorkspace || (await this.options.canSelectWorkspace(folderUri, providerId));
+    }
+    _getAllBrowseActions() {
+        const all = this.sessionsProvidersService.getProviders().flatMap(p => p.browseActions);
+        const hasLocalSupport = ( this.sessionsProvidersService.getProviders().some(p => p.supportsLocalWorkspaces));
+        if (hasLocalSupport) {
+            all.unshift(this._localBrowseAction);
+        }
+        return all.filter(
+            a => (!this._isTabFiltered() || this._isGroupInActiveTab(a.group)) && (this._directPickerAttachesContext === undefined || Boolean(a.attachesContext) === this._directPickerAttachesContext)
+        );
+    }
+    _useConsolidatedRemoteWorkspaces() {
+        return this.configurationService.getValue(UNIFIED_WORKSPACE_PICKER_SETTING);
+    }
+    _getWorkspaceIcon(workspace) {
+        if (this._useConsolidatedRemoteWorkspaces()) {
+            if (workspace.group === SESSION_WORKSPACE_GROUP_LOCAL) {
+                return Codicon.folder;
+            }
+            if (workspace.group === SESSION_WORKSPACE_GROUP_GITHUB) {
+                return Codicon.repo;
+            }
+        }
+        return workspace.icon;
+    }
+    _getTabGroup(group) {
+        return this._useConsolidatedRemoteWorkspaces() && group === SESSION_WORKSPACE_GROUP_GITHUB ? SESSION_WORKSPACE_GROUP_REMOTE : group;
+    }
+    _isGroupInActiveTab(group) {
+        if (this._directPickerGroup !== undefined) {
+            return group === this._directPickerGroup;
+        }
+        const availableTabs = this._getAvailableTabs();
+        const activeTab = this._activeTab ?? (availableTabs.length === 1 ? availableTabs[0].id : undefined);
+        return this._getTabGroup(group) === activeTab;
+    }
+    async _browseForLocalFolder() {
+        const localProviders = this.sessionsProvidersService.getProviders().filter(p => p.supportsLocalWorkspaces);
+        if (localProviders.length === 0) {
+            return undefined;
+        }
+        const result = await this.fileDialogService.showOpenDialog({
+            canSelectFolders: true,
+            canSelectFiles: false,
+            canSelectMany: false
+        });
+        if (!result?.length) {
+            return undefined;
+        }
+        for (const provider of localProviders) {
+            const workspace = provider.resolveWorkspace(result[0]);
+            if (workspace) {
+                return {
+                    workspace,
+                    providerId: provider.id
+                };
+            }
+        }
+        return undefined;
+    }
+    _isTabFiltered() {
+        return this._directPickerGroup !== undefined || (this._showTabs() && !!this._activeTab && this._getAvailableTabs().length > 1);
+    }
+    _getActivePickerGroup() {
+        return this._directPickerGroup ?? (this._directPickerAttachesContext !== undefined ? this._activeTab : undefined);
+    }
+    _buildItems() {
+        const items = [];
+        const allProviders = this.sessionsProvidersService.getProviders();
+        const providerIds = ( new Set(allProviders.map(p => p.id)));
+        const availableTabs = this._getAvailableTabs();
+        const activeGroup = this._activeTab ?? (availableTabs.length === 1 ? availableTabs[0].id : undefined);
+        let workspaceGroupAction = this.options.getWorkspaceGroupAction?.(activeGroup);
+        let workspaceGroupActionGroup = activeGroup;
+        if (!workspaceGroupAction && activeGroup === undefined) {
+            workspaceGroupAction = this.options.getWorkspaceGroupAction?.(SESSION_WORKSPACE_GROUP_GITHUB);
+            workspaceGroupActionGroup = workspaceGroupAction ? SESSION_WORKSPACE_GROUP_GITHUB : undefined;
+        }
+        if (!workspaceGroupAction && activeGroup === SESSION_WORKSPACE_GROUP_REMOTE && this._useConsolidatedRemoteWorkspaces()) {
+            const gitHubGroupAction = this.options.getWorkspaceGroupAction?.(SESSION_WORKSPACE_GROUP_GITHUB);
+            workspaceGroupAction = gitHubGroupAction ? {
+                ...gitHubGroupAction,
+                hideWorkspaceItems: false
+            } : undefined;
+            workspaceGroupActionGroup = workspaceGroupAction ? SESSION_WORKSPACE_GROUP_GITHUB : undefined;
+        }
+        const tabFilter = this._isTabFiltered() ? w => this._isGroupInActiveTab(w.workspace.group) : undefined;
+        const useRemoteSubmenu = this._useConsolidatedRemoteWorkspaces() && this._directPickerGroup === undefined;
+        const remotePickerItem = {};
+        const remoteSubmenuActions = [];
+        let devContainerActionIndex = 0;
+        const setRemotePickerItem = item => {
+            remotePickerItem.folderUri = item.folderUri;
+            remotePickerItem.providerId = item.providerId;
+            remotePickerItem.browseAction = item.browseAction;
+            remotePickerItem.run = item.run;
+        };
+        const recentWorkspaces = this._directPickerAttachesContext === true ? [] : this._getRecentWorkspaces().filter(w => ( providerIds.has(w.providerId))).filter(w => !tabFilter || tabFilter(w)).filter(
+            w => !workspaceGroupAction?.hideWorkspaceItems || w.workspace.group !== workspaceGroupActionGroup
+        );
+        const localRepositoryIds = this._useConsolidatedRemoteWorkspaces() ? ( new Set(recentWorkspaces.filter((
+            {
+                workspace
+            }
+        ) => workspace.group === SESSION_WORKSPACE_GROUP_LOCAL).map(workspace => this._getRepositoryIdForResolvedWorkspace(workspace)).filter(repositoryId => repositoryId !== undefined))) : undefined;
+        const recentWorkspaceEntries = recentWorkspaces.map(resolved => ({
+            ...resolved,
+            repositoryId: this._getRepositoryIdForResolvedWorkspace(resolved)
+        })).filter((
+            {
+                workspace,
+                repositoryId
+            }
+        ) => workspace.group !== SESSION_WORKSPACE_GROUP_GITHUB || !repositoryId || !localRepositoryIds?.has(repositoryId));
+        const orderedRecentWorkspaceEntries = this._useConsolidatedRemoteWorkspaces() ? [...recentWorkspaceEntries.filter((
+            {
+                workspace
+            }
+        ) => !ThemeIcon.isEqual(this._getWorkspaceIcon(workspace), Codicon.repo)), ...recentWorkspaceEntries.filter((
+            {
+                workspace
+            }
+        ) => ThemeIcon.isEqual(this._getWorkspaceIcon(workspace), Codicon.repo))] : recentWorkspaceEntries;
+        let previousRecentWorkspaceIsRepository;
+        for (const {
+            workspace,
+            providerId,
+            repositoryId
+        } of orderedRecentWorkspaceEntries) {
+            const folderUri = workspace.folders[0]?.root;
+            if (!folderUri) {
+                continue;
+            }
+            const icon = this._getWorkspaceIcon(workspace);
+            const selected = this._isSelectedFolder(folderUri) || (repositoryId !== undefined && repositoryId === this._getCurrentRepositoryId());
+            const attached = ( this._additionalFolderSelections.has(this.uriIdentityService.extUri.getComparisonKey(folderUri))) || (repositoryId !== undefined && ( this._additionalRepositorySelections.has(repositoryId)));
+            if (useRemoteSubmenu && workspace.group === SESSION_WORKSPACE_GROUP_REMOTE) {
+                const unavailable = this._isProviderUnavailable(providerId);
+                const submenuAction = toAction({
+                    id: `workspacePicker.remote.workspace.${providerId}.${remoteSubmenuActions.length}`,
+                    label: workspace.label,
+                    tooltip: typeof workspace.description === "string" ? workspace.description : undefined,
+                    enabled: !unavailable,
+                    run: () => setRemotePickerItem({
+                        folderUri,
+                        providerId
+                    })
+                });
+                Object.assign(submenuAction, {
+                    icon,
+                    onRemove: () => this._removeRecentWorkspace(folderUri)
+                });
+                remoteSubmenuActions.push(submenuAction);
+                continue;
+            }
+            const recentWorkspaceIsRepository = ThemeIcon.isEqual(icon, Codicon.repo);
+            if (previousRecentWorkspaceIsRepository !== undefined && previousRecentWorkspaceIsRepository !== recentWorkspaceIsRepository) {
+                items.push({
+                    kind: ActionListItemKind.Separator,
+                    label: ""
+                });
+            }
+            previousRecentWorkspaceIsRepository = recentWorkspaceIsRepository;
+            const item = {
+                folderUri,
+                providerId,
+                checked: selected || attached || undefined
+            };
+            const usingDevContainer = !!this._selectedDevContainerFolderUri && this.uriIdentityService.extUri.isEqual(this._selectedDevContainerFolderUri, folderUri);
+            const submenuActions = workspace.group === SESSION_WORKSPACE_GROUP_LOCAL && this._isDevContainerWorkspaceAvailable(folderUri, providerId) ? [( new SubmenuAction(
+                `workspacePicker.devContainer.${providerId}.${devContainerActionIndex}`,
+                "",
+                [toAction({
+                    id: `workspacePicker.devContainer.local.${providerId}.${devContainerActionIndex}`,
+                    label: ( localize(3913, "Use Local")),
+                    tooltip: "",
+                    checked: !usingDevContainer,
+                    run: () => item.preferDevContainer = false
+                }), toAction({
+                    id: `workspacePicker.devContainer.use.${providerId}.${devContainerActionIndex++}`,
+                    label: ( localize(3914, "Use Dev Container")),
+                    tooltip: "",
+                    checked: usingDevContainer,
+                    run: () => item.preferDevContainer = true
+                })]
+            ))] : undefined;
+            items.push({
+                kind: ActionListItemKind.Action,
+                label: workspace.label,
+                description: workspace.description,
+                group: {
+                    title: "",
+                    icon
+                },
+                disabled: this._isProviderUnavailable(providerId),
+                item,
+                submenuActions,
+                onRemove: () => this._removeRecentWorkspace(folderUri)
+            });
+        }
+        const remoteAgentHostsEnabled = this.configurationService.getValue(RemoteAgentHostsEnabledSettingId);
+        const allBrowseActions = this._getAllBrowseActions().map((action, index) => ({
+            action,
+            index
+        })).filter((
+            {
+                action
+            }
+        ) => remoteAgentHostsEnabled || action.group !== SESSION_WORKSPACE_GROUP_REMOTE).filter((
+            {
+                action
+            }
+        ) => !workspaceGroupAction?.hideWorkspaceItems || action.group !== workspaceGroupActionGroup);
+        const remoteProviders = allProviders.filter(isAgentHostProvider).filter(p => p.connectionStatus !== undefined);
+        const includeRemoteProviders = remoteAgentHostsEnabled && (activeGroup === undefined || activeGroup === SESSION_WORKSPACE_GROUP_REMOTE);
+        if (items.length > 0 && (workspaceGroupAction || allBrowseActions.length > 0)) {
+            items.push({
+                kind: ActionListItemKind.Separator,
+                label: ""
+            });
+        }
+        if (workspaceGroupAction) {
+            items.push({
+                kind: ActionListItemKind.Action,
+                label: workspaceGroupAction.label,
+                description: workspaceGroupAction.description,
+                group: {
+                    title: "",
+                    icon: workspaceGroupAction.icon
+                },
+                item: {
+                    commandId: workspaceGroupAction.commandId
+                }
+            });
+        }
+        let hasRepositoryAttachmentAction = false;
+        allBrowseActions.forEach((
+            {
+                action,
+                index
+            }
+        ) => {
+            const actionIcon = action === this._localBrowseAction && this._useConsolidatedRemoteWorkspaces() ? Codicon.folder : action.icon;
+            const actionLabel = action === this._localBrowseAction && this._useConsolidatedRemoteWorkspaces() && this._directPickerAttachesContext !== true ? ( localize(3915, "Choose Folder")) : this._useConsolidatedRemoteWorkspaces() ? action.label.replace(/(?:\.\.\.|…)$/, "") : action.label;
+            const isUnavailable = this._isProviderUnavailable(action.providerId);
+            if (useRemoteSubmenu && action.group === SESSION_WORKSPACE_GROUP_REMOTE) {
+                const submenuAction = toAction({
+                    id: `workspacePicker.remote.browse.${action.providerId}.${index}`,
+                    label: actionLabel,
+                    tooltip: action.description,
+                    enabled: !isUnavailable,
+                    run: () => setRemotePickerItem({
+                        browseAction: action
+                    })
+                });
+                Object.assign(submenuAction, {
+                    icon: actionIcon
+                });
+                remoteSubmenuActions.push(submenuAction);
+                return;
+            }
+            const isRepositoryAction = action.group === SESSION_WORKSPACE_GROUP_GITHUB && action.attachesContext !== true;
+            items.push({
+                kind: ActionListItemKind.Action,
+                label: actionLabel,
+                description: action.description,
+                group: {
+                    title: "",
+                    icon: actionIcon
+                },
+                disabled: isUnavailable,
+                item: {
+                    browseActionIndex: index
+                }
+            });
+            const canAttachFolder = action === this._localBrowseAction && !!this._selectedFolderUri && this._getActivePickerGroup() === SESSION_WORKSPACE_GROUP_LOCAL && (!this._useConsolidatedRemoteWorkspaces() || this._directPickerAttachesContext === true);
+            const canAttachRepository = isRepositoryAction && action.supportsContextAttachment === true && !!this._selectedFolderUri && this._isGroupInActiveTab(SESSION_WORKSPACE_GROUP_GITHUB) && !hasRepositoryAttachmentAction;
+            if (canAttachFolder || canAttachRepository) {
+                hasRepositoryAttachmentAction ||= canAttachRepository;
+                items.push({
+                    kind: ActionListItemKind.Action,
+                    label: canAttachFolder ? this._useConsolidatedRemoteWorkspaces() ? ( localize(3916, "Attach Folder")) : ( localize(3917, "Attach Folder...")) : this._useConsolidatedRemoteWorkspaces() ? ( localize(3918, "Attach Repository")) : ( localize(3919, "Attach Repository...")),
+                    description: action.description,
+                    group: {
+                        title: "",
+                        icon: actionIcon
+                    },
+                    disabled: isUnavailable,
+                    item: {
+                        browseActionIndex: index,
+                        attachAsContext: true
+                    }
+                });
+            }
+        });
+        const manageActions = [];
+        if (includeRemoteProviders) {
+            for (const provider of remoteProviders) {
+                const status = provider.connectionStatus.get();
+                const isTunnel = provider.remoteAddress?.startsWith(TUNNEL_ADDRESS_PREFIX) === true;
+                const statusDescription = getRemoteHostStatusDescription(provider, status);
+                const action = toAction({
+                    id: `workspacePicker.remote.${provider.id}`,
+                    label: provider.label,
+                    tooltip: statusDescription,
+                    enabled: true,
+                    run: () => {
+                        this._hidePicker();
+                        this._showRemoteHostOptionsDelayed(provider);
+                    }
+                });
+                const extended = action;
+                extended.ariaLabel = ( localize(3920, "{0}, {1}", provider.label, statusDescription));
+                extended.icon = RemoteAgentHostConnectionStatus.isIncompatible(status) ? Codicon.warning : (isTunnel ? Codicon.cloud : Codicon.remote);
+                extended.hoverContent = getStatusHover(status, provider.remoteAddress);
+                if (provider.remoteAddress) {
+                    extended.onRemove = async () => {
+                        await removeRemoteHost(provider, this.remoteAgentHostService, this.configurationService);
+                    };
+                }
+                if (useRemoteSubmenu) {
+                    const submenuAction = toAction({
+                        id: action.id,
+                        label: action.label,
+                        tooltip: action.tooltip,
+                        enabled: action.enabled,
+                        run: () => setRemotePickerItem({
+                            run: () => action.run()
+                        })
+                    });
+                    Object.assign(submenuAction, {
+                        icon: extended.icon,
+                        hoverContent: extended.hoverContent,
+                        onRemove: extended.onRemove
+                    });
+                    remoteSubmenuActions.push(submenuAction);
+                } else {
+                    manageActions.push(action);
+                }
+            }
+        }
+        const menuContextKeyService = useRemoteSubmenu ? this.contextKeyService.createOverlay([[SessionWorkspacePickerGroupContext.key, SESSION_WORKSPACE_GROUP_REMOTE]]) : this.contextKeyService;
+        const menuActions = this.menuService.getMenuActions(Menus.SessionWorkspaceManage, menuContextKeyService, {
+            renderShortTitle: true
+        });
+        for (const [, actions] of menuActions) {
+            for (const menuAction of actions) {
+                if (menuAction instanceof MenuItemAction) {
+                    const icon = ThemeIcon.isThemeIcon(menuAction.item.icon) ? menuAction.item.icon : undefined;
+                    if (useRemoteSubmenu) {
+                        const submenuAction = toAction({
+                            id: menuAction.id,
+                            label: menuAction.label,
+                            tooltip: menuAction.tooltip,
+                            enabled: menuAction.enabled,
+                            run: () => setRemotePickerItem({
+                                run: () => menuAction.run()
+                            })
+                        });
+                        Object.assign(submenuAction, {
+                            icon
+                        });
+                        remoteSubmenuActions.push(submenuAction);
+                    } else {
+                        manageActions.push(Object.assign(menuAction, {
+                            icon
+                        }));
+                    }
+                }
+            }
+        }
+        if (remoteSubmenuActions.length > 0) {
+            if (items.length > 0 && items[items.length - 1].kind !== ActionListItemKind.Separator) {
+                items.push({
+                    kind: ActionListItemKind.Separator,
+                    label: ""
+                });
+            }
+            items.push({
+                kind: ActionListItemKind.Action,
+                label: ( localize(3921, "Remote")),
+                group: {
+                    title: "",
+                    icon: Codicon.remote
+                },
+                item: remotePickerItem,
+                submenuActions: [( new SubmenuAction("workspacePicker.remote.options", "", remoteSubmenuActions))]
+            });
+        }
+        if (manageActions.length > 0) {
+            if (items.length > 0 && items[items.length - 1].kind !== ActionListItemKind.Separator) {
+                items.push({
+                    kind: ActionListItemKind.Separator,
+                    label: ""
+                });
+            }
+            for (const action of manageActions) {
+                const extended = action;
+                items.push({
+                    kind: ActionListItemKind.Action,
+                    label: action.label,
+                    description: extended.onRemove ? action.tooltip || undefined : undefined,
+                    group: {
+                        title: "",
+                        icon: extended.icon ?? Codicon.settingsGear
+                    },
+                    item: {
+                        run: () => action.run(),
+                        commandId: action.id,
+                        ariaLabel: extended.ariaLabel
+                    },
+                    onRemove: extended.onRemove
+                });
+            }
+        }
+        if (items.length === 0 && this._getActivePickerGroup() === SESSION_WORKSPACE_GROUP_GITHUB) {
+            items.push({
+                kind: ActionListItemKind.Action,
+                label: ( localize(3922, "GitHub repositories are still loading")),
+                group: {
+                    title: "",
+                    icon: Codicon.loading
+                },
+                disabled: true,
+                item: {}
+            });
+        }
+        const noWorkspaceOption = this._getNoWorkspaceOption();
+        if (!noWorkspaceOption || this._directPickerAttachesContext === true) {
+            return items;
+        }
+        const noWorkspace = {
+            kind: ActionListItemKind.Action,
+            label: this._getNoWorkspaceLabel(),
+            description: this._useConsolidatedRemoteWorkspaces() ? undefined : noWorkspaceOption.description,
+            group: {
+                title: "",
+                icon: this._useConsolidatedRemoteWorkspaces() ? Codicon.comment : Codicon.commentDiscussion
+            },
+            item: {
+                checked: noWorkspaceOption.isSelected || undefined,
+                run: () => {
+                    noWorkspaceOption.select();
+                    this._updateTriggerLabel();
+                    this._onDidChangeSelection.fire();
+                }
+            }
+        };
+        return items.length > 0 ? [noWorkspace, {
+            kind: ActionListItemKind.Separator,
+            label: ""
+        }, ...items] : [noWorkspace];
+    }
+    _getNoWorkspaceOption() {
+        return this.options.getNoWorkspaceOption?.();
+    }
+    _getNoWorkspaceLabel() {
+        return this._useConsolidatedRemoteWorkspaces() ? ( localize(3923, "Start from Scratch")) : ( localize(3924, "No workspace"));
+    }
+    _showRemoteHostOptionsDelayed(provider) {
+        const timeout = setTimeout(() => {
+            this.instantiationService.invokeFunction(accessor => showRemoteHostOptions(accessor, provider));
+        }, 1);
+        this._renderDisposables.add({
+            dispose: () => clearTimeout(timeout)
+        });
+    }
+    _updateTriggerLabel() {
+        for (const trigger of this._triggerElements) {
+            this._renderTriggerLabel(trigger);
+        }
+    }
+    _renderTriggerLabel(trigger) {
+        const options = this._triggerOptions.get(trigger);
+        const contents = this._triggerContents.get(trigger);
+        if (!contents) {
+            return;
+        }
+        if (options) {
+            const reflectsWorkspace = options.reflectsWorkspace === true;
+            const noWorkspaceSelected = reflectsWorkspace && this._getNoWorkspaceOption()?.isSelected === true;
+            const workspace = noWorkspaceSelected ? undefined : this._selectedResolved?.workspace;
+            const isSelectedCategory = options.attachesContext !== true && options.group !== undefined && options.group === workspace?.group;
+            const contextCount = options.group && options.attachesContext ? Math.max(
+                this._contextSelections.get(`${options.group}:context`)?.length ?? 0,
+                options.group === SESSION_WORKSPACE_GROUP_GITHUB ? this._attachedContext.filter(attachment => attachment.id.startsWith("github-context:")).length : 0
+            ) : 0;
+            const additionalWorkspaceCount = options.attachesContext !== true && (reflectsWorkspace || isSelectedCategory) ? this._additionalFolderSelections.size + this._additionalRepositorySelections.size : 0;
+            const badgeCount = Math.max(contextCount, additionalWorkspaceCount);
+            const repositoryWorkspace = this._getSelectedRepositoryWorkspace();
+            const relatedGitHubInfo = options.group === SESSION_WORKSPACE_GROUP_GITHUB && options.attachesContext === false ? repositoryWorkspace?.folders.map(folder => folder.gitRepository?.gitHubInfo.get()).find(info => info !== undefined) : undefined;
+            const hideForSelectedWorkspace = workspace !== undefined && options.hideWhenWorkspaceSelected === true && options.group !== workspace.group;
+            const hideForMissingWorkspace = workspace === undefined && options.hideWhenNoWorkspaceSelected === true;
+            const hideForMissingGitHubRepository = options.hideWhenNoGitHubRepository === true && this._getCurrentRepositoryId() === undefined;
+            trigger.parentElement?.toggleAttribute(
+                "hidden",
+                hideForSelectedWorkspace || hideForMissingWorkspace || hideForMissingGitHubRepository
+            );
+            trigger.classList.toggle(
+                "selected",
+                noWorkspaceSelected || (reflectsWorkspace && workspace !== undefined) || isSelectedCategory || badgeCount > 0 || relatedGitHubInfo !== undefined
+            );
+            const workspaceIcon = workspace ? this._getWorkspaceIcon(workspace) : undefined;
+            const icon = noWorkspaceSelected ? this._useConsolidatedRemoteWorkspaces() ? Codicon.comment : Codicon.commentDiscussion : (reflectsWorkspace ? workspaceIcon : undefined) ?? (relatedGitHubInfo ? Codicon.repo : (isSelectedCategory && workspace ? workspaceIcon : options.icon));
+            if (!icon || (options.hideIconWhenAttached === true && badgeCount > 0)) {
+                contents.icon?.remove();
+                contents.icon = undefined;
+            } else {
+                if (!contents.icon) {
+                    contents.icon = renderIcon(icon);
+                    trigger.prepend(contents.icon);
+                }
+                contents.icon.className = ThemeIcon.asClassName(icon);
+            }
+            const label = noWorkspaceSelected ? this._getNoWorkspaceLabel() : (reflectsWorkspace && workspace ? this._getWorkspaceLabel(workspace) : undefined) ?? (relatedGitHubInfo ? `${relatedGitHubInfo.owner}/${relatedGitHubInfo.repo}` : (isSelectedCategory && workspace ? workspace.label : options.label));
+            trigger.setAttribute("aria-label", badgeCount > 0 ? ( localize(3925, "{0}, {1} attached", options.ariaLabel, badgeCount)) : label && label !== options.label ? ( localize(3926, "{0}: {1}", options.label ?? options.ariaLabel, label)) : options.ariaLabel);
+            if (label) {
+                contents.label ??= append(trigger, $("span.sessions-chat-dropdown-label"));
+                contents.label.textContent = label;
+            } else {
+                contents.label?.remove();
+                contents.label = undefined;
+            }
+            if (badgeCount > 0) {
+                contents.badge ??= ( new CountBadge(trigger, {
+                    count: badgeCount
+                }, defaultCountBadgeStyles));
+                contents.badge.setCount(badgeCount);
+            } else {
+                contents.badge?.dispose();
+                contents.badge = undefined;
+            }
+            if (!contents.chevron) {
+                contents.chevron = renderIcon(Codicon.chevronDownCompact);
+                contents.chevron.classList.add("sessions-chat-dropdown-chevron");
+                contents.chevron.setAttribute("aria-hidden", "true");
+            }
+            trigger.append(contents.chevron);
+            return;
+        }
+        clearNode(trigger);
+        const noWorkspaceSelected = this._getNoWorkspaceOption()?.isSelected === true;
+        const workspace = noWorkspaceSelected ? undefined : this._selectedResolved?.workspace;
+        const label = noWorkspaceSelected ? ( localize(3924, "No workspace")) : workspace ? this._getWorkspaceLabel(workspace) : ( localize(3927, "workspace"));
+        const icon = noWorkspaceSelected ? Codicon.commentDiscussion : workspace?.icon ?? Codicon.project;
+        trigger.setAttribute("aria-label", noWorkspaceSelected ? ( localize(3928, "New session with no workspace")) : workspace ? ( localize(3929, "New session in {0}", label)) : ( localize(3930, "Start by picking a workspace")));
+        contents.icon = append(trigger, renderIcon(icon));
+        contents.label = append(trigger, $("span.sessions-chat-dropdown-label"));
+        contents.label.textContent = label;
+        append(trigger, renderIcon(Codicon.chevronDownCompact)).classList.add("sessions-chat-dropdown-chevron");
+    }
+    _getWorkspaceLabel(workspace) {
+        return this._selectedDevContainerFolderUri && this.uriIdentityService.extUri.isEqual(this._selectedDevContainerFolderUri, workspace.folders[0]?.root) ? ( localize(3931, "{0} - Dev Container", workspace.label)) : workspace.label;
+    }
+    _isDevContainerWorkspaceAvailable(folderUri, providerId) {
+        let provider = this.sessionsProvidersService.getProvider(providerId);
+        if (!provider || !isAgentHostProvider(provider) || !provider.isDevContainerWorkspaceAvailable) {
+            provider = this.sessionsProvidersService.getProviders().find(
+                candidate => isAgentHostProvider(candidate) && !!candidate.isDevContainerWorkspaceAvailable && candidate.resolveWorkspace(folderUri)?.group === SESSION_WORKSPACE_GROUP_LOCAL
+            );
+        }
+        if (!provider || !isAgentHostProvider(provider) || !provider.isDevContainerWorkspaceAvailable) {
+            return false;
+        }
+        const key = `${provider.id}:${this.uriIdentityService.extUri.getComparisonKey(folderUri)}`;
+        const cached = this._devContainerAvailability.get(key);
+        if (typeof cached === "boolean") {
+            return cached;
+        }
+        if (cached) {
+            return false;
+        }
+        const availability = this._devContainerAvailabilityLimiter.queue(() => provider.isDevContainerWorkspaceAvailable(folderUri)).catch(error => {
+            onUnexpectedError(error);
+            return false;
+        });
+        this._devContainerAvailability.set(key, availability);
+        void availability.then(available => {
+            if (this._devContainerAvailability.get(key) !== availability) {
+                return;
+            }
+            this._devContainerAvailability.set(key, available);
+        });
+        return false;
+    }
+    _clearDevContainerAvailability(refreshVisiblePicker = false) {
+        this._devContainerAvailability.clear();
+        this._devContainerAvailabilityLimiter.clear();
+        this._devContainerAvailabilityRefresh.cancel();
+        if (refreshVisiblePicker) {
+            this._devContainerAvailabilityRefresh.schedule();
+        }
+    }
+    _isProviderUnavailable(providerId) {
+        const provider = this.sessionsProvidersService.getProvider(providerId);
+        if (!provider || !isAgentHostProvider(provider) || !provider.connectionStatus) {
+            return false;
+        }
+        const connectionStatus = provider.connectionStatus.get();
+        return RemoteAgentHostConnectionStatus.isIncompatible(connectionStatus) || (!RemoteAgentHostConnectionStatus.isConnected(connectionStatus) && !provider.canConnectOnDemand);
+    }
+    async _connectProviderOnDemand(providerId) {
+        const provider = this.sessionsProvidersService.getProvider(providerId);
+        if (!provider || !isAgentHostProvider(provider) || !provider.connectionStatus) {
+            return true;
+        }
+        const connectionStatus = provider.connectionStatus.get();
+        if (RemoteAgentHostConnectionStatus.isConnected(connectionStatus)) {
+            return true;
+        }
+        if (RemoteAgentHostConnectionStatus.isIncompatible(connectionStatus) || !provider.canConnectOnDemand || !provider.connect) {
+            return false;
+        }
+        const initialMessage = ( localize(3932, "Connecting to {0}...", provider.label));
+        const handle = this.notificationService.notify({
+            severity: Severity$1.Info,
+            message: initialMessage,
+            progress: {
+                infinite: true
+            }
+        });
+        status(initialMessage);
+        const progressListener = provider.onDidReportConnectProgress?.(progress => {
+            if (!provider.remoteAddress || progress.connectionKey === provider.remoteAddress) {
+                handle.updateMessage(progress.message);
+                status(progress.message);
+            }
+        });
+        let connected = false;
+        try {
+            await provider.connect();
+            connected = RemoteAgentHostConnectionStatus.isConnected(provider.connectionStatus.get());
+        } catch {} finally {
+            progressListener?.dispose();
+            handle.close();
+        }
+        if (connected) {
+            return true;
+        }
+        const message = ( localize(3933, "Failed to connect to {0}.", provider.label));
+        this.notificationService.error(message);
+        status(message);
+        return false;
+    }
+    _isSelectedFolder(folderUri) {
+        if (this._getNoWorkspaceOption()?.isSelected || !this._selectedFolderUri || !folderUri) {
+            return false;
+        }
+        return this.uriIdentityService.extUri.isEqual(this._selectedFolderUri, folderUri);
+    }
+    _restoreSelectedWorkspace() {
+        if (!this._canRestoreWorkspace()) {
+            return undefined;
+        }
+        const checked = this._restoreCheckedWorkspace();
+        if (checked && this._canRestoreProviderWorkspace(checked.providerId)) {
+            return {
+                resolved: checked,
+                source: NewSessionWorkspacePreselectionSource.CheckedWorkspace,
+                origin: WorkspaceSelectionOrigin.CheckedWorkspace
+            };
+        }
+        try {
+            for (const recent of this.recentWorkspacesService.getRecentWorkspaces()) {
+                const folderUri = recent.workspace.folders[0]?.root;
+                if (!folderUri || !this._canRestoreProviderWorkspace(recent.providerId) || isWorktreeWorkspaceUri(folderUri) || this._isProviderUnavailable(recent.providerId)) {
+                    continue;
+                }
+                return {
+                    resolved: recent,
+                    source: NewSessionWorkspacePreselectionSource.RecentWorkspace,
+                    origin: recent.source === "agents" ? WorkspaceSelectionOrigin.AgentsRecent : recent.source === "vscodeWorkspace" ? WorkspaceSelectionOrigin.VSCodeWorkspace : WorkspaceSelectionOrigin.VSCodeRecent
+                };
+            }
+            return undefined;
+        } catch {
+            return undefined;
+        }
+    }
+    _resetAutomaticSelection() {
+        this._selectionGeneration++;
+        this._sessionRestoreGeneration++;
+        this._userHasPicked = false;
+        this._connectionStatusWatch.clear();
+        this._applySelection(undefined);
+        this._updateTriggerLabel();
+        this._onDidChangeSelection.fire();
+        this._onDidSelectWorkspace.fire(undefined);
+        this._sessionWorkspaceFallback?.refreshProviders();
+        this._restoreAutomaticSelection();
+    }
+    refreshAutomaticSelection() {
+        return this._restoreAutomaticSelection();
+    }
+    _restoreAutomaticSelection() {
+        if (this._userHasPicked || !this._canRestoreWorkspace()) {
+            return false;
+        }
+        const restored = this._restoreSelectedWorkspace();
+        if (!restored) {
+            if (!this._selectedFolderUri || this._preselectionSource === NewSessionWorkspacePreselectionSource.ExistingSessions) {
+                this._scheduleSessionWorkspaceRestore();
+            }
+            return false;
+        }
+        this._sessionRestoreGeneration++;
+        if (this._isSelectedFolder(restored.resolved.workspace.folders[0]?.root)) {
+            this._selectedResolved = restored.resolved;
+            this._preselectionSource = restored.source;
+            return false;
+        }
+        this._applySelection(restored.resolved, restored.source, restored.origin);
+        this._updateTriggerLabel();
+        this._onDidChangeSelection.fire();
+        this._onDidSelectWorkspace.fire(this._selectedFolderUri);
+        this._watchForConnectionFailure(restored.resolved);
+        return true;
+    }
+    _scheduleSessionWorkspaceRestore() {
+        if (!this._sessionWorkspaceFallback || this._userHasPicked || !this._canRestoreWorkspace()) {
+            return;
+        }
+        const restoreGeneration = ++this._sessionRestoreGeneration;
+        const selectionGeneration = this._selectionGeneration;
+        this._sessionRestoreState = {
+            generation: restoreGeneration,
+            selectionGeneration,
+            state: "pending"
+        };
+        const restoreState = this._sessionRestoreState;
+        void this._sessionWorkspaceFallback.findWorkspace().then(restored => {
+            restoreState.state = "completed";
+            if (restoreGeneration !== this._sessionRestoreGeneration || selectionGeneration !== this._selectionGeneration || this._userHasPicked || !this._canRestoreWorkspace()) {
+                return;
+            }
+            if (this._restoreSelectedWorkspace()) {
+                this._restoreAutomaticSelection();
+                return;
+            }
+            if (!restored) {
+                if (this._preselectionSource === NewSessionWorkspacePreselectionSource.ExistingSessions) {
+                    this._applySelection(undefined);
+                    this._updateTriggerLabel();
+                    this._onDidChangeSelection.fire();
+                    this._onDidSelectWorkspace.fire(undefined);
+                }
+                return;
+            }
+            const folderUri = restored.workspace.folders[0]?.root;
+            if (this._isSelectedFolder(folderUri)) {
+                this._selectedResolved = restored;
+                this._preselectionSource = NewSessionWorkspacePreselectionSource.ExistingSessions;
+                return;
+            }
+            this._applySelection(
+                restored,
+                NewSessionWorkspacePreselectionSource.ExistingSessions,
+                WorkspaceSelectionOrigin.ExistingSessions
+            );
+            this._updateTriggerLabel();
+            this._onDidChangeSelection.fire();
+            this._onDidSelectWorkspace.fire(this._selectedFolderUri);
+            this._watchForConnectionFailure(restored);
+        }).catch(error => {
+            restoreState.state = "error";
+            onUnexpectedError(error);
+        });
+    }
+    _canRestoreProviderWorkspace(providerId) {
+        return !this.options.sessionWorkspaceProviderFilter || this.options.sessionWorkspaceProviderFilter(providerId);
+    }
+    _canRestoreWorkspace() {
+        return !this.isNoWorkspaceSelected() && (this.options.canRestoreWorkspace?.() ?? true);
+    }
+    _restoreCheckedWorkspace() {
+        try {
+            return this.recentWorkspacesService.getRecentWorkspaces(false).find(recent => {
+                const folderUri = recent.workspace.folders[0]?.root;
+                return recent.checked && !!folderUri && !isWorktreeWorkspaceUri(folderUri);
+            });
+        } catch {
+            return undefined;
+        }
+    }
+    _watchForConnectionFailure(resolved) {
+        const provider = this.sessionsProvidersService.getProvider(resolved.providerId);
+        if (!provider || !isAgentHostProvider(provider) || !provider.connectionStatus) {
+            return;
+        }
+        const connStatus = provider.connectionStatus;
+        if (RemoteAgentHostConnectionStatus.isConnected(connStatus.get())) {
+            return;
+        }
+        const folderUri = resolved.workspace.folders[0]?.root;
+        if (!folderUri) {
+            return;
+        }
+        const store = ( new DisposableStore());
+        this._connectionStatusWatch.value = store;
+        const fallback = () => {
+            this._connectionStatusWatch.clear();
+            if (!this._userHasPicked && this._isSelectedFolder(folderUri)) {
+                this._selectedFolderUri = undefined;
+                this._selectedResolved = undefined;
+                this._preselectionSource = NewSessionWorkspacePreselectionSource.None;
+                this._selectionOrigin = WorkspaceSelectionOrigin.None;
+                this._updateTriggerLabel();
+                this._onDidChangeSelection.fire();
+                this._onDidSelectWorkspace.fire(undefined);
+            }
+        };
+        let isFirstRun = true;
+        store.add(autorun(reader => {
+            const status = connStatus.read(reader);
+            const isBusy = RemoteAgentHostConnectionStatus.isConnecting(status) || RemoteAgentHostConnectionStatus.isReconnecting(status);
+            if (RemoteAgentHostConnectionStatus.isConnected(status)) {
+                this._connectionStatusWatch.clear();
+            } else if (!isBusy && !isFirstRun) {
+                fallback();
+            }
+            isFirstRun = false;
+        }));
+        disposableTimeout(() => {
+            if (!RemoteAgentHostConnectionStatus.isConnected(connStatus.get())) {
+                fallback();
+            }
+        }, RESTORE_CONNECT_GRACE_MS, store);
+    }
+    _getRecentWorkspaces() {
+        return this.recentWorkspacesService.getRecentWorkspaces(true, this._useConsolidatedRemoteWorkspaces());
+    }
+    _removeRecentWorkspace(folderUri) {
+        this.recentWorkspacesService.removeRecentWorkspace(folderUri, this._useConsolidatedRemoteWorkspaces());
+        if (this._isSelectedFolder(folderUri)) {
+            this.options.onUserSelection?.();
+            this._hidePicker();
+            this._selectedFolderUri = undefined;
+            this._selectedResolved = undefined;
+            this._preselectionSource = NewSessionWorkspacePreselectionSource.None;
+            this._selectionOrigin = WorkspaceSelectionOrigin.None;
+            this._updateTriggerLabel();
+            this._onDidSelectWorkspace.fire(undefined);
+        }
+    }
+};
+WorkspacePicker = ( __decorate([( __param(1, IActionWidgetService)), ( __param(2, IUriIdentityService)), ( __param(3, ISessionsProvidersService)), ( __param(4, ISessionsRecentWorkspacesService)), ( __param(5, IRemoteAgentHostService)), ( __param(6, IConfigurationService)), ( __param(7, ICommandService)), ( __param(8, IMenuService)), ( __param(9, IContextKeyService)), ( __param(10, IInstantiationService)), ( __param(11, IFileDialogService)), ( __param(12, ITelemetryService)), ( __param(13, INotificationService)), ( __param(14, IHoverService)), ( __param(15, IFileService)), ( __param(16, IDialogService))], WorkspacePicker));
+
+export { WorkspacePicker };