@codingame/monaco-vscode-api 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/sessions/browser/views/sessionsList.js

@@ -0,0 +1,3939 @@
+
+import { registerCss } from '../../../../../../../../css.js';
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import * as sessionsList from '../media/sessionsList.css';
+import { $ as $$1, append, addDisposableListener, EventType, clearNode, getWindow, addStandardDisposableListener, isAncestorOfActiveElement, isMouseEvent, scheduleAtNextAnimationFrame } from '../../../../../base/browser/dom.js';
+import { synchronizeCSSAnimations, pauseCSSAnimationsWhenHidden } from '../../../../../base/browser/animationSync.js';
+import { Gesture } from '../../../../../base/browser/touch.js';
+import { ListDragOverEffectPosition, ListDragOverEffectType, NotSelectableGroupId } from '../../../../../base/browser/ui/list/list.js';
+import { ObjectTreeElementCollapseState } from '../../../../../base/browser/ui/tree/tree.js';
+import { RenderIndentGuides, TreeFindMode } from '../../../../../base/browser/ui/tree/abstractTree.js';
+import { Codicon } from '../../../../../base/common/codicons.js';
+import { onUnexpectedError } from '../../../../../base/common/errors.js';
+import { Emitter } from '../../../../../base/common/event.js';
+import { HighlightedLabel } from '../../../../../base/browser/ui/highlightedlabel/highlightedLabel.js';
+import { createMatches } from '../../../../../base/common/filters.js';
+import { DisposableStore, toDisposable, MutableDisposable, Disposable } from '../../../../../base/common/lifecycle.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { fromNow } from '../../../../../base/common/date.js';
+import { KeyCode } from '../../../../../base/common/keyCodes.js';
+import { isEqual } from '../../../../../base/common/resources.js';
+import { localize } from '../../../../../nls.js';
+import { MenuId, MenuItemAction } from '../../../../../platform/actions/common/actions.js';
+import { IMenuService } from '../../../../../platform/actions/common/actions.service.js';
+import { MenuWorkbenchToolBar } from '../../../../../platform/actions/browser/toolbar.js';
+import { DropdownWithPrimaryActionViewItem } from '../../../../../platform/actions/browser/dropdownWithPrimaryActionViewItem.js';
+import { MenuEntryActionViewItem, getFlatContextMenuActions } from '../../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
+import { RawContextKey } from '../../../../../platform/contextkey/common/contextkey.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
+import { MarshalledId } from '../../../../../base/common/marshallingIds.js';
+import { SessionIsReadContext, SessionIsArchivedContext, SessionSupportsDeleteContext, IsPhoneLayoutContext, SessionTypeContext, SessionProviderIdContext, SessionSupportsRenameContext, SessionHasPullRequestContext } from '../../../../common/contextkeys.js';
+import { ARCHIVE_SESSION_COMMAND_ID, RENAME_SESSION_COMMAND_ID } from '../../../../common/sessionCommands.js';
+import { IContextMenuService } from '../../../../../platform/contextview/browser/contextView.service.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.service.js';
+import { ServiceCollection } from '../../../../../platform/instantiation/common/serviceCollection.js';
+import { WorkbenchObjectTree } from '../../../../../platform/list/browser/listService.js';
+import { defaultButtonStyles, defaultInputBoxStyles, defaultToggleStyles, defaultFindWidgetStyles } from '../../../../../platform/theme/browser/defaultStyles.js';
+import { asCssVariable } from '../../../../../platform/theme/common/colorUtils.js';
+import { chartsOrange } from '../../../../../platform/theme/common/colors/chartsColors.js';
+import { StorageScope, StorageTarget } from '../../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../../platform/storage/common/storage.service.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { IUriIdentityService } from '../../../../../platform/uriIdentity/common/uriIdentity.service.js';
+import { IOpenerService } from '../../../../../platform/opener/common/opener.service.js';
+import { ILabelService } from '../../../../../platform/label/common/label.service.js';
+import { ChatSessionArchiveActionWordingSettingId, getChatSessionArchivedSectionLabel, getChatSessionArchiveActionWording, ChatSessionArchiveActionWording } from '../../../../../platform/chat/common/sessionArchiveActions.js';
+import { SessionStatus, ChatOriginKind, ChatInteractivity, getGitHubPullRequestRefs, getSessionWorkspaceKind, SessionWorkspaceKind, getSessionStatusMessage, GITHUB_REMOTE_FILE_SCHEME, getChatCapabilities } from '../../../../services/sessions/common/session.js';
+import { agentSessionApprovalId, AgentSessionApprovalModel } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentSessionApprovalModel.js';
+import { IVoicePlaybackService } from '../../../../../workbench/contrib/chat/common/voicePlaybackService.service.js';
+import { Button } from '../../../../../base/browser/ui/button/button.js';
+import { IMarkdownRendererService } from '../../../../../platform/markdown/browser/markdownRenderer.service.js';
+import { ActionRunner, Action, toAction, Separator, SubmenuAction } from '../../../../../base/common/actions.js';
+import { IHoverService } from '../../../../../platform/hover/browser/hover.service.js';
+import { createSessionActionViewItemProvider, getSessionArchiveActionViewItemOptions } from '../../../../browser/sessionActionViewItem.js';
+import { HoverStyle } from '../../../../../base/browser/ui/hover/hover.js';
+import { HoverPosition } from '../../../../../base/browser/ui/hover/hoverWidget.js';
+import { getDefaultHoverDelegate } from '../../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+import { ISessionsManagementService } from '../../../../services/sessions/common/sessionsManagement.service.js';
+import { ISessionsService } from '../../../../services/sessions/browser/sessionsService.service.js';
+import { ISessionsListModelService } from '../../../../services/sessions/browser/sessionsListModelService.service.js';
+import { ISessionGroupsService } from '../../../../services/sessions/browser/sessionGroupsService.service.js';
+import { ISessionSectionOrderService } from '../../../../services/sessions/browser/sessionSectionOrderService.service.js';
+import { InputBox } from '../../../../../base/browser/ui/inputbox/inputBox.js';
+import { IWorkbenchAssignmentService } from '../../../../../workbench/services/assignment/common/assignmentService.service.js';
+import { IPreferencesService } from '../../../../../workbench/services/preferences/common/preferences.service.js';
+import { markOnboardingTarget } from '../../../../../workbench/contrib/onboarding/browser/spotlight/onboardingTarget.js';
+import { IAgentSessionsService } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentSessionsService.service.js';
+import { IAgentHostFilterService } from '../../../../services/agentHostFilter/common/agentHostFilter.service.js';
+import { IAgentHostConnectionsService } from '../../../../../platform/agentHost/common/agentHostConnectionsService.service.js';
+import { buildOpenSessionLinkUri } from '../../../../../platform/agentHost/common/openSessionLink.js';
+import { LocalSelectionTransfer } from '../../../../../platform/dnd/browser/dnd.js';
+import { fillSessionChatDragData, DraggedSessionIdentifier, SessionsDataTransfers } from '../../../../browser/dnd.js';
+import { ElementsDragAndDropData, ListViewTargetSector } from '../../../../../base/browser/ui/list/listView.js';
+import { ISessionsProvidersService } from '../../../../services/sessions/browser/sessionsProvidersService.service.js';
+import { getSessionSummaryHoverData, getSessionDiffStats } from '../sessionHoverContent.js';
+import { SessionSummaryHoverWidget } from '../../../../../workbench/contrib/chat/browser/agentSessions/sessionSummaryHover.js';
+import { SessionStatusIcon } from '../../../../browser/sessionStatusIcon.js';
+import { ChatAutomationsEnabledContext } from '../../../../../workbench/contrib/chat/common/automations/automationsEnabled.js';
+import { IAutomationService } from '../../../../../workbench/contrib/chat/common/automations/automationService.service.js';
+import { ICustomViewService } from '../../../../services/customView/browser/customViewService.service.js';
+import { AUTOMATIONS_CUSTOM_VIEW_ID } from '../automationsConstants.js';
+import { AutomationsNewBadgeState } from '../automationsNewBadge.js';
+import { Menus } from '../../../../browser/menus.js';
+import { getSessionConversationStatusAriaLabel } from '../../../../browser/sessionConversationGroups.js';
+import { isAgentMergePullRequestIcon, getSessionAgentMergeConfigurationObservable, getAgentMergeAwarePullRequestIcon } from '../../../../browser/sessionAgentMerge.js';
+import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
+import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
+import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+import { observableSignalFromEvent } from '../../../../../base/common/observableInternal/observables/observableSignalFromEvent.js';
+import { getHighestPriorityPullRequestIcon } from '../../../../../workbench/common/chatPullRequest.js';
+import { constObservable } from '../../../../../base/common/observableInternal/observables/constObservable.js';
+
+var SessionsList_1, SessionsFlatList_1;
+registerCss(sessionsList, 1);
+const $ = $$1;
+const AUTOMATIONS_SECTION_ID = "automations";
+const SESSION_SECTION_FOCUS_FROM_POINTER_CLASS = "session-section-focus-from-pointer";
+const SESSION_HEADER_DROP_TARGET_CLASS = "session-header-drop-target";
+const EMPTY_GUIDE_SESSION_IDS = ( new Set());
+const SessionItemToolbarMenuId = ( new MenuId("SessionItemToolbar"));
+const SessionItemContextMenuId = MenuId.SessionItemContextMenu;
+const SessionSectionToolbarMenuId = ( new MenuId("SessionSectionToolbar"));
+const SessionGroupToolbarMenuId = ( new MenuId("SessionGroupToolbar"));
+const NEW_SESSION_FOR_WORKSPACE_ACTION_ID = "sessionsView.sectionNewSession";
+const SESSIONS_LIST_SHOW_EMPTY_DEFAULT_GROUPS_SETTING = "sessions.list.showEmptyDefaultGroups";
+const IsSessionPinnedContext = new RawContextKey("sessionItem.isPinned", false);
+const SessionItemHasBranchNameContext = new RawContextKey("sessionItem.hasBranchName", false);
+const SessionItemStatusContext = new RawContextKey("sessionItem.status", SessionStatus.Completed);
+const SessionChatItemCanRenameContext = new RawContextKey("sessionChatItem.canRename", false);
+const SessionChatItemCanDeleteContext = new RawContextKey("sessionChatItem.canDelete", false);
+const SessionChatItemIsUntitledContext = new RawContextKey("sessionChatItem.isUntitled", false);
+const SessionsListFocusedChatItemContext = new RawContextKey("sessionsList.focusedChatItem", false);
+const SessionItemInGroupContext = new RawContextKey("sessionItem.inGroup", false);
+const SessionSectionTypeContext = new RawContextKey("sessionSection.type", "");
+const SessionSectionHasGitHubRepositoryContext = new RawContextKey("sessionSection.hasGitHubRepository", false);
+const SessionSectionHasNonCloudRepositoryContext = new RawContextKey("sessionSection.hasNonCloudRepository", false);
+const SessionGroupHasVisibleSessionsContext = new RawContextKey("sessionGroup.hasVisibleSessions", false);
+const SessionGroupIsEmptyContext = new RawContextKey("sessionGroup.isEmpty", false);
+var SessionsGrouping;
+(function(SessionsGrouping) {
+    SessionsGrouping["Workspace"] = "workspace";
+    SessionsGrouping["Date"] = "date";
+})(SessionsGrouping || (SessionsGrouping = {}));
+var SessionsSorting;
+(function(SessionsSorting) {
+    SessionsSorting["Created"] = "created";
+    SessionsSorting["Updated"] = "updated";
+})(SessionsSorting || (SessionsSorting = {}));
+function sortingToMode(sorting) {
+    return sorting === SessionsSorting.Updated ? "updated" : "created";
+}
+const SORT_FALLBACK_STEP_MS = 60_000;
+class SessionChatItem {
+    constructor(session, chat) {
+        this.session = session;
+        this.chat = chat;
+    }
+}
+function isSessionChatItem(item) {
+    return item instanceof SessionChatItem;
+}
+function getChatTitle(chat, reader) {
+    return chat.title.read(reader).trim() || ( localize(4780, "Untitled Chat"));
+}
+function getSessionListChats(session, reader) {
+    const mainChat = session.mainChat.read(reader);
+    return session.chats.read(reader).filter(
+        chat => !isEqual(chat.resource, mainChat.resource) && chat.origin?.kind !== ChatOriginKind.Tool && chat.origin?.kind !== ChatOriginKind.SideChat && chat.interactivity.read(reader) !== ChatInteractivity.Hidden
+    );
+}
+function getSessionRowStatus(session, reader, deriveFromMainChat) {
+    const sessionStatus = session.status.read(reader);
+    if (!deriveFromMainChat) {
+        return sessionStatus;
+    }
+    if (( session.chats.read(reader).some(chat => chat.status.read(reader) === SessionStatus.InProgress))) {
+        return SessionStatus.InProgress;
+    }
+    return session.mainChat.read(reader).status.read(reader);
+}
+function isSessionGroupItem(item) {
+    return "group" in item;
+}
+function isSessionSection(item) {
+    return !isSessionGroupItem(item) && "sessions" in item && Array.isArray(item.sessions);
+}
+function getSessionSectionIcon(sectionId) {
+    switch (sectionId) {
+    case QUICK_CHATS_SECTION_ID:
+        return Codicon.commentDiscussion;
+    case "pinned":
+        return Codicon.pinned;
+    case AUTOMATIONS_SECTION_ID:
+        return Codicon.calendar;
+    case "archived":
+        return Codicon.archive;
+    case "recent":
+        return Codicon.history;
+    case "older":
+        return Codicon.calendar;
+    default:
+        return sectionId.startsWith("workspace:") ? Codicon.folder : undefined;
+    }
+}
+function isSessionShowMore(item) {
+    return "showMore" in item && item.showMore === true;
+}
+function isSessionPlaceholder(item) {
+    return "placeholder" in item && item.placeholder === true;
+}
+function isSessionItem(item) {
+    return !isSessionChatItem(item) && !isSessionGroupItem(item) && !isSessionSection(item) && !isSessionShowMore(item) && !isSessionPlaceholder(item);
+}
+const SHOW_MORE_FOLDERS_LABEL = "__more_folders__";
+const FOUR_DAYS_MS = 4 * 24 * 60 * 60 * 1000;
+const INSET_ROW_GAP = 2;
+const DEFAULT_APPROVAL_ROW_MAX_LINES = 3;
+class SessionsTreeDelegate {
+    static {
+        this.ITEM_HEIGHT = 54;
+    }
+    static {
+        this.ITEM_HEIGHT_QUICK_CHAT = 28;
+    }
+    static {
+        this.CHAT_ITEM_HEIGHT = 28;
+    }
+    static {
+        this.CHAT_ITEM_HEIGHT_PHONE = 44;
+    }
+    static {
+        this.CHAT_APPROVAL_BOTTOM_SLACK = 6;
+    }
+    static {
+        this.ITEM_HEIGHT_PHONE = 76;
+    }
+    static {
+        this.SECTION_HEIGHT = 26;
+    }
+    static {
+        this.SHOW_MORE_HEIGHT = 26;
+    }
+    static {
+        this.PLACEHOLDER_HEIGHT = 26;
+    }
+    constructor(
+        _approvalModel,
+        _isPhone,
+        _approvalRowMaxLines = DEFAULT_APPROVAL_ROW_MAX_LINES,
+        _ciFixModel = undefined,
+        _useCompactQuickChatRows = true,
+        _aggregateChatApprovals = false,
+        _useInsetRowSpacing = false
+    ) {
+        this._approvalModel = _approvalModel;
+        this._isPhone = _isPhone;
+        this._approvalRowMaxLines = _approvalRowMaxLines;
+        this._ciFixModel = _ciFixModel;
+        this._useCompactQuickChatRows = _useCompactQuickChatRows;
+        this._aggregateChatApprovals = _aggregateChatApprovals;
+        this._useInsetRowSpacing = _useInsetRowSpacing;
+    }
+    withInsetRowSpacing(height) {
+        return height + (this._useInsetRowSpacing ? INSET_ROW_GAP : 0);
+    }
+    getHeight(element) {
+        if (isSessionChatItem(element)) {
+            let chatHeight = this._isPhone() ? SessionsTreeDelegate.CHAT_ITEM_HEIGHT_PHONE : SessionsTreeDelegate.CHAT_ITEM_HEIGHT;
+            if (this._approvalModel) {
+                const approval = this._approvalModel.getApproval(element.chat.resource).get();
+                if (approval) {
+                    chatHeight += SessionItemRenderer.getApprovalRowHeight(approval.label, this._approvalRowMaxLines) + SessionsTreeDelegate.CHAT_APPROVAL_BOTTOM_SLACK;
+                }
+            }
+            return this.withInsetRowSpacing(chatHeight);
+        }
+        if (isSessionSection(element) || isSessionGroupItem(element)) {
+            return SessionsTreeDelegate.SECTION_HEIGHT;
+        }
+        if (isSessionShowMore(element)) {
+            return this.withInsetRowSpacing(SessionsTreeDelegate.SHOW_MORE_HEIGHT);
+        }
+        if (isSessionPlaceholder(element)) {
+            return SessionsTreeDelegate.PLACEHOLDER_HEIGHT;
+        }
+        let height;
+        if (this._isPhone()) {
+            height = SessionsTreeDelegate.ITEM_HEIGHT_PHONE;
+        } else if (this._useCompactQuickChatRows && isQuickChatSession(element)) {
+            height = SessionsTreeDelegate.ITEM_HEIGHT_QUICK_CHAT;
+        } else {
+            height = SessionsTreeDelegate.ITEM_HEIGHT;
+        }
+        if (this._approvalModel) {
+            const approval = getSessionRowApproval(this._approvalModel, element, undefined, this._aggregateChatApprovals);
+            if (approval) {
+                height += SessionItemRenderer.getApprovalRowHeight(approval.label, this._approvalRowMaxLines);
+            }
+        }
+        if (this._ciFixModel && this._ciFixModel.getCIFix(element).get()) {
+            height += SessionItemRenderer.CI_ROW_HEIGHT;
+        }
+        return this.withInsetRowSpacing(height);
+    }
+    hasDynamicHeight(element) {
+        if (isSessionChatItem(element)) {
+            return !!this._approvalModel;
+        }
+        return (!!this._approvalModel || !!this._ciFixModel) && isSessionItem(element);
+    }
+    getTemplateId(element) {
+        if (isSessionChatItem(element)) {
+            return SessionChatItemRenderer.TEMPLATE_ID;
+        }
+        if (isSessionGroupItem(element)) {
+            return SessionGroupRenderer.TEMPLATE_ID;
+        }
+        if (isSessionSection(element)) {
+            return SessionSectionRenderer.TEMPLATE_ID;
+        }
+        if (isSessionShowMore(element)) {
+            return SessionShowMoreRenderer.TEMPLATE_ID;
+        }
+        if (isSessionPlaceholder(element)) {
+            return SessionPlaceholderRenderer.TEMPLATE_ID;
+        }
+        return SessionItemRenderer.TEMPLATE_ID;
+    }
+}
+class SessionChatItemRenderer {
+    static {
+        this.TEMPLATE_ID = "session-chat-item";
+    }
+    constructor(
+        hoverService,
+        instantiationService,
+        markdownRendererService,
+        approvalModel,
+        approvalRowMaxLines,
+        activeGuideSessionIds = constObservable(EMPTY_GUIDE_SESSION_IDS)
+    ) {
+        this.hoverService = hoverService;
+        this.instantiationService = instantiationService;
+        this.markdownRendererService = markdownRendererService;
+        this.approvalModel = approvalModel;
+        this.approvalRowMaxLines = approvalRowMaxLines;
+        this.activeGuideSessionIds = activeGuideSessionIds;
+        this.templateId = SessionChatItemRenderer.TEMPLATE_ID;
+        this.rowClassName = "session-list-inset-row";
+        this._onDidChangeItemHeight = ( new Emitter());
+        this.onDidChangeItemHeight = this._onDidChangeItemHeight.event;
+        this._onDidApproveSession = ( new Emitter());
+        this.onDidApproveSession = this._onDidApproveSession.event;
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const elementDisposables = disposables.add(( new DisposableStore()));
+        container.classList.add("session-chat-item");
+        const titleRow = append(container, $(".session-chat-title-row"));
+        const iconContainer = append(titleRow, $(".session-chat-icon"));
+        iconContainer.setAttribute("aria-hidden", "true");
+        const statusIcon = disposables.add(this.instantiationService.createInstance(SessionStatusIcon, iconContainer));
+        const title = disposables.add(( new HighlightedLabel(append(titleRow, $(".session-chat-title")))));
+        const approvalRow = append(container, $(".session-approval-row"));
+        const approvalLabel = append(approvalRow, $("span.session-approval-label"));
+        const approvalButtonContainer = append(approvalRow, $(".session-approval-button"));
+        for (const eventType of ["pointerdown", "pointerup", "click", "dblclick"]) {
+            disposables.add(
+                addDisposableListener(approvalRow, eventType, e => e.stopPropagation())
+            );
+        }
+        disposables.add(Gesture.ignoreTarget(approvalRow));
+        return {
+            container,
+            statusIcon,
+            title,
+            approvalRow,
+            approvalLabel,
+            approvalButtonContainer,
+            disposables,
+            elementDisposables
+        };
+    }
+    renderElement(node, _index, template) {
+        const element = node.element;
+        if (!isSessionChatItem(element)) {
+            return;
+        }
+        template.elementDisposables.clear();
+        const chats = getSessionListChats(element.session);
+        template.container.classList.toggle("last-chat", isEqual(chats.at(-1)?.resource, element.chat.resource));
+        template.elementDisposables.add(autorun(reader => {
+            template.title.set(getChatTitle(element.chat, reader), createMatches(node.filterData));
+            const status = element.chat.status.read(reader);
+            template.statusIcon.setStatus(status, true, false, undefined, element.chat.resource);
+            template.container.classList.toggle("needs-input", status === SessionStatus.NeedsInput);
+        }));
+        template.elementDisposables.add(autorun(reader => {
+            const showGuides = ( this.activeGuideSessionIds.read(reader).has(element.session.sessionId));
+            template.container.classList.toggle("session-hierarchy-guides-visible", showGuides);
+        }));
+        template.elementDisposables.add(this.hoverService.setupDelayedHover(template.title.element, () => ({
+            content: getChatTitle(element.chat)
+        }), {
+            groupId: "sessions-list"
+        }));
+        if (this.approvalModel) {
+            this.renderApprovalRow(element, template);
+        }
+    }
+    renderApprovalRow(element, template) {
+        if (!this.approvalModel || !this.markdownRendererService) {
+            return;
+        }
+        const approvalModel = this.approvalModel;
+        const markdownRendererService = this.markdownRendererService;
+        const chatResource = element.chat.resource;
+        let lastApprovalHeight = approvalRowHeightFor(approvalModel.getApproval(chatResource).get(), this.approvalRowMaxLines);
+        template.approvalRow.classList.toggle("visible", lastApprovalHeight > 0);
+        const buttonStore = template.elementDisposables.add(( new DisposableStore()));
+        template.elementDisposables.add(autorun(reader => {
+            buttonStore.clear();
+            const info = approvalModel.getApproval(chatResource).read(reader);
+            const visible = !!info;
+            template.approvalRow.classList.toggle("visible", visible);
+            if (info) {
+                renderApprovalRowContent(info, {
+                    label: template.approvalLabel,
+                    buttonContainer: template.approvalButtonContainer
+                }, buttonStore, markdownRendererService, this.hoverService, true, this.approvalRowMaxLines, approvalId => {
+                    this._onDidApproveSession.fire({
+                        session: element.session,
+                        approvalId
+                    });
+                });
+            }
+            const height = approvalRowHeightFor(info, this.approvalRowMaxLines);
+            if (height !== lastApprovalHeight) {
+                lastApprovalHeight = height;
+                this._onDidChangeItemHeight.fire(element);
+            }
+        }));
+    }
+    disposeElement(_node, _index, template) {
+        template.elementDisposables.clear();
+    }
+    disposeTemplate(template) {
+        template.disposables.dispose();
+    }
+}
+function approvalRowHeightFor(info, maxLines) {
+    return info ? SessionItemRenderer.getApprovalRowHeight(info.label, maxLines) : 0;
+}
+function renderApprovalRowContent(
+    info,
+    elements,
+    store,
+    markdownRendererService,
+    hoverService,
+    showHover,
+    maxLines,
+    onApprove
+) {
+    const lines = info.label.split("\n");
+    const visibleLines = lines.slice(0, maxLines);
+    if (lines.length > maxLines) {
+        visibleLines[maxLines - 1] = `${visibleLines[maxLines - 1]} \u2026`;
+    }
+    const langId = info.languageId ?? "json";
+    const labelContent = ( new MarkdownString());
+    for (const line of visibleLines) {
+        labelContent.appendCodeblock(langId, line);
+    }
+    elements.label.textContent = "";
+    store.add(markdownRendererService.render(labelContent, {}, elements.label));
+    if (showHover) {
+        const fullContent = ( new MarkdownString()).appendCodeblock(info.languageId ?? "json", info.label);
+        store.add(hoverService.setupDelayedHover(elements.label, {
+            content: fullContent,
+            style: HoverStyle.Pointer,
+            position: {
+                hoverPosition: HoverPosition.BELOW
+            }
+        }));
+    }
+    elements.buttonContainer.textContent = "";
+    const button = store.add(( new Button(elements.buttonContainer, {
+        title: ( localize(4781, "Allow once")),
+        ariaLabel: ( localize(4782, "Allow once: {0}", info.label)),
+        secondary: true,
+        ...defaultButtonStyles
+    })));
+    button.label = ( localize(4783, "Allow"));
+    store.add(button.onDidClick(() => {
+        const approvalId = agentSessionApprovalId(info);
+        info.confirm();
+        onApprove(approvalId);
+    }));
+}
+class SessionItemActionRunner extends ActionRunner {
+    constructor(getMultiSelectedSessions, handleAction) {
+        super();
+        this.getMultiSelectedSessions = getMultiSelectedSessions;
+        this.handleAction = handleAction;
+    }
+    async runAction(action, context) {
+        if (context && !Array.isArray(context)) {
+            if (this.handleAction && (await this.handleAction(action, context))) {
+                return;
+            }
+            await super.runAction(action, this.getMultiSelectedSessions(context));
+            return;
+        }
+        await super.runAction(action, context);
+    }
+}
+const SESSION_TITLE_SHIMMER_ANIMATION_NAME = "session-title-shimmer";
+const SESSION_TITLE_SHIMMER_ANIMATION_NAMES = ( new Set([SESSION_TITLE_SHIMMER_ANIMATION_NAME]));
+const SESSION_TITLE_SHIMMER_PAUSED_CLASS = "session-title-shimmer-paused";
+class SessionItemRenderer {
+    static {
+        this.TEMPLATE_ID = "session-item";
+    }
+    static {
+        this._APPROVAL_ROW_LINE_HEIGHT = 18;
+    }
+    static {
+        this._APPROVAL_ROW_OVERHEAD = 14;
+    }
+    static {
+        this.CI_ROW_HEIGHT = 32;
+    }
+    static getApprovalRowHeight(label, maxLines = DEFAULT_APPROVAL_ROW_MAX_LINES) {
+        const lineCount = Math.min(label.split(/\r?\n/).length, maxLines);
+        return lineCount * SessionItemRenderer._APPROVAL_ROW_LINE_HEIGHT + SessionItemRenderer._APPROVAL_ROW_OVERHEAD;
+    }
+    constructor(
+        options,
+        approvalModel,
+        ciFixModel,
+        instantiationService,
+        contextKeyService,
+        configurationService,
+        markdownRendererService,
+        hoverService,
+        sessionsProvidersService,
+        sessionsManagementService,
+        agentHostConnectionsService,
+        openerService,
+        labelService,
+        preferencesService,
+        agentSessionsService,
+        _voicePlaybackService
+    ) {
+        this.options = options;
+        this.approvalModel = approvalModel;
+        this.ciFixModel = ciFixModel;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.configurationService = configurationService;
+        this.markdownRendererService = markdownRendererService;
+        this.hoverService = hoverService;
+        this.sessionsProvidersService = sessionsProvidersService;
+        this.sessionsManagementService = sessionsManagementService;
+        this.agentHostConnectionsService = agentHostConnectionsService;
+        this.openerService = openerService;
+        this.labelService = labelService;
+        this.preferencesService = preferencesService;
+        this.agentSessionsService = agentSessionsService;
+        this._voicePlaybackService = _voicePlaybackService;
+        this.templateId = SessionItemRenderer.TEMPLATE_ID;
+        this.rowClassName = "session-list-inset-row";
+        this._onDidChangeItemHeight = ( new Emitter());
+        this.onDidChangeItemHeight = this._onDidChangeItemHeight.event;
+        this._onDidApproveSession = ( new Emitter());
+        this.onDidApproveSession = this._onDidApproveSession.event;
+    }
+    getCreatorHoverData(session) {
+        const creationReference = session.createdBySession?.get();
+        if (!creationReference) {
+            return undefined;
+        }
+        const creator = this.sessionsManagementService.getSession(creationReference.session);
+        const resolved = this.agentHostConnectionsService.resolveSessionResource(creationReference.session);
+        if (!creator || !resolved) {
+            return undefined;
+        }
+        const target = buildOpenSessionLinkUri(
+            resolved.backendSession,
+            creationReference.chat?.fragment,
+            creationReference.turnId
+        );
+        return {
+            title: creator.title.get(),
+            onOpen: () => this.openerService.open(target).catch(onUnexpectedError)
+        };
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const elementDisposables = disposables.add(( new DisposableStore()));
+        container.classList.add("session-item");
+        const iconContainer = append(container, $(".session-icon"));
+        const statusIcon = disposables.add(this.instantiationService.createInstance(SessionStatusIcon, iconContainer));
+        const mainCol = append(container, $(".session-main"));
+        const titleRow = append(mainCol, $(".session-title-row"));
+        const titleContainer = append(titleRow, $(".session-title"));
+        const title = disposables.add(( new HighlightedLabel(titleContainer)));
+        disposables.add(
+            addDisposableListener(titleContainer, EventType.ANIMATION_START, e => {
+                if (e.target === titleContainer && e.animationName === SESSION_TITLE_SHIMMER_ANIMATION_NAME) {
+                    synchronizeCSSAnimations(titleContainer, {
+                        animationNames: SESSION_TITLE_SHIMMER_ANIMATION_NAMES
+                    });
+                }
+            })
+        );
+        disposables.add(pauseCSSAnimationsWhenHidden(titleContainer, {
+            pausedClass: SESSION_TITLE_SHIMMER_PAUSED_CLASS,
+            animationNames: SESSION_TITLE_SHIMMER_ANIMATION_NAMES
+        }));
+        const titleToolbarContainer = append(titleRow, $(".session-title-toolbar"));
+        const pendingVoiceIndicator = append(titleRow, $(".session-pending-voice-indicator"));
+        for (const eventType of ["pointerdown", "pointerup", "click", "dblclick"]) {
+            disposables.add(
+                addDisposableListener(titleToolbarContainer, eventType, e => e.stopPropagation())
+            );
+        }
+        disposables.add(Gesture.ignoreTarget(titleToolbarContainer));
+        const detailsRow = append(mainCol, $(".session-details-row"));
+        const approvalRow = append(mainCol, $(".session-approval-row"));
+        const approvalLabel = append(approvalRow, $("span.session-approval-label"));
+        const approvalButtonContainer = append(approvalRow, $(".session-approval-button"));
+        const ciRow = append(mainCol, $(".session-ci-row"));
+        const ciLabel = append(ciRow, $("span.session-ci-label"));
+        const ciButtonContainer = append(ciRow, $(".session-ci-button"));
+        for (const eventType of ["pointerdown", "pointerup", "click", "dblclick"]) {
+            disposables.add(addDisposableListener(ciRow, eventType, e => e.stopPropagation()));
+        }
+        disposables.add(Gesture.ignoreTarget(ciRow));
+        const contextKeyService = disposables.add(this.contextKeyService.createScoped(container));
+        const statusContext = SessionItemStatusContext.bindTo(contextKeyService);
+        const isReadContext = SessionIsReadContext.bindTo(contextKeyService);
+        const isArchivedContext = SessionIsArchivedContext.bindTo(contextKeyService);
+        const supportsDeleteContext = SessionSupportsDeleteContext.bindTo(contextKeyService);
+        const scopedInstantiationService = disposables.add(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService]))));
+        let titleToolbar;
+        const renderedSession = observableValue("renderedSession", undefined);
+        if (this.options.toolbarMenuId) {
+            const actionRunner = disposables.add(( new SessionItemActionRunner(this.options.getMultiSelectedSessions, this.options.handleToolbarAction)));
+            const actionViewItemProvider = createSessionActionViewItemProvider(scopedInstantiationService, this.configurationService);
+            titleToolbar = disposables.add(
+                scopedInstantiationService.createInstance(MenuWorkbenchToolBar, titleToolbarContainer, this.options.toolbarMenuId, {
+                    menuOptions: {
+                        shouldForwardArgs: true
+                    },
+                    actionRunner,
+                    actionViewItemProvider: (action, options) => {
+                        if (action.id !== ARCHIVE_SESSION_COMMAND_ID || !(action instanceof MenuItemAction) || !this.options.archiveOnboardingSession) {
+                            return actionViewItemProvider(action, options);
+                        }
+                        return scopedInstantiationService.createInstance(class extends MenuEntryActionViewItem {
+                            render(container) {
+                                super.render(container);
+                                this._register(autorun(reader => {
+                                    const session = renderedSession.read(reader);
+                                    if (session && this.label) {
+                                        reader.store.add(
+                                            markOnboardingTarget(this.label, getSessionArchiveOnboardingTargetId(session))
+                                        );
+                                    }
+                                }));
+                            }
+                        }, action, getSessionArchiveActionViewItemOptions(options, this.configurationService));
+                    }
+                })
+            );
+        }
+        return {
+            container,
+            statusIcon,
+            title,
+            titleContainer,
+            titleToolbar,
+            renderedSession,
+            pendingVoiceIndicator,
+            detailsRow,
+            approvalRow,
+            approvalLabel,
+            approvalButtonContainer,
+            ciRow,
+            ciLabel,
+            ciButtonContainer,
+            contextKeyService,
+            statusContext,
+            isReadContext,
+            isArchivedContext,
+            supportsDeleteContext,
+            disposables,
+            elementDisposables
+        };
+    }
+    renderElement(node, _index, template) {
+        const element = node.element;
+        if (!isSessionItem(element)) {
+            return;
+        }
+        this.renderSession(element, template, createMatches(node.filterData));
+    }
+    renderSession(element, template, matches) {
+        template.elementDisposables.clear();
+        template.renderedSession.set(element, undefined);
+        template.elementDisposables.add(toDisposable(() => {
+            template.renderedSession.set(undefined, undefined);
+            template.container.classList.remove("archive-onboarding");
+        }));
+        if (this.options.archiveOnboardingSession) {
+            template.elementDisposables.add(autorun(reader => {
+                template.container.classList.toggle(
+                    "archive-onboarding",
+                    this.options.archiveOnboardingSession?.read(reader)?.sessionId === element.sessionId
+                );
+            }));
+        }
+        if (this.options.onDidRequestRename) {
+            template.elementDisposables.add(
+                addDisposableListener(template.title.element, EventType.DBLCLICK, event => {
+                    if (event.button !== 0 || event.altKey || event.ctrlKey || event.metaKey || event.shiftKey || !element.capabilities.get().supportsRename) {
+                        return;
+                    }
+                    event.preventDefault();
+                    event.stopPropagation();
+                    this.options.onDidRequestRename?.(element);
+                })
+            );
+        }
+        this.agentSessionsService.model.observeSession(element.resource);
+        if (this.options.showHover) {
+            template.elementDisposables.add(this.hoverService.setupDelayedHover(template.container, () => ({
+                content: ( new SessionSummaryHoverWidget(getSessionSummaryHoverData(
+                    element,
+                    this.sessionsProvidersService,
+                    this.openerService,
+                    this.labelService,
+                    this.preferencesService,
+                    this.getCreatorHoverData(element)
+                ))).domNode,
+                appearance: {
+                    showPointer: true
+                },
+                position: {
+                    hoverPosition: HoverPosition.RIGHT,
+                    forcePosition: true
+                },
+                persistence: {
+                    hideOnHover: false
+                }
+            }), {
+                groupId: "sessions-list"
+            }));
+        }
+        const pendingVoiceResource = element.resource;
+        template.pendingVoiceIndicator.className = "session-pending-voice-indicator " + ThemeIcon.asClassName(Codicon.unmute);
+        template.elementDisposables.add(this.hoverService.setupManagedHover(
+            getDefaultHoverDelegate("mouse"),
+            template.pendingVoiceIndicator,
+            ( localize(4784, "Voice response ready"))
+        ));
+        template.elementDisposables.add(autorun(reader => {
+            this._voicePlaybackService.pendingResponseVersion.read(reader);
+            template.pendingVoiceIndicator.classList.toggle(
+                "visible",
+                this._voicePlaybackService.hasPendingResponse(pendingVoiceResource)
+            );
+        }));
+        if (template.titleToolbar) {
+            template.titleToolbar.context = element;
+        }
+        const isPinned = this.options.isPinned(element);
+        IsSessionPinnedContext.bindTo(template.contextKeyService).set(isPinned);
+        SessionItemHasBranchNameContext.bindTo(template.contextKeyService).set(!!element.workspace.get()?.folders[0]?.gitRepository?.branchName?.trim());
+        template.elementDisposables.add(autorun(reader => {
+            const isArchived = element.isArchived.read(reader);
+            template.container.classList.toggle("archived", isArchived);
+            template.container.classList.toggle("pinned", isPinned && !isArchived);
+        }));
+        template.elementDisposables.add(autorun(reader => {
+            const showGuides = ( (this.options.activeGuideSessionIds?.read(reader) ?? EMPTY_GUIDE_SESSION_IDS).has(element.sessionId));
+            template.container.classList.toggle("session-hierarchy-guides-visible", showGuides);
+        }));
+        template.elementDisposables.add(autorun(reader => {
+            const wrapper = this.options.visibleSessions.read(reader).find(s => s?.sessionId === element.sessionId);
+            const isSticky = wrapper ? wrapper.sticky.read(reader) : false;
+            template.container.classList.toggle("sticky", isSticky);
+        }));
+        let agentMergeConfiguration;
+        template.elementDisposables.add(autorun(reader => {
+            const sessionStatus = getSessionRowStatus(element, reader, !!this.options.deriveStatusFromMainChat);
+            template.statusContext.set(sessionStatus);
+            const isRead = element.isRead.read(reader);
+            template.isReadContext.set(isRead);
+            const isArchived = element.isArchived.read(reader);
+            template.isArchivedContext.set(isArchived);
+            const capabilities = element.capabilities.read(reader);
+            template.supportsDeleteContext.set(capabilities.supportsDelete === true);
+            const gitHubInfo = element.workspace.read(reader)?.folders[0]?.gitRepository?.gitHubInfo.read(reader);
+            const isQuickChat = element.isQuickChat?.read(reader) ?? false;
+            let completedStateIcon = element.completedStateIcon?.read(reader) ?? getHighestPriorityPullRequestIcon(getGitHubPullRequestRefs(gitHubInfo).map(pullRequest => pullRequest.icon));
+            if (completedStateIcon && isAgentMergePullRequestIcon(completedStateIcon)) {
+                agentMergeConfiguration ??= getSessionAgentMergeConfigurationObservable(element, this.sessionsProvidersService, this.configurationService);
+                completedStateIcon = getAgentMergeAwarePullRequestIcon(completedStateIcon, agentMergeConfiguration.read(reader));
+            }
+            template.statusIcon.setStatus(sessionStatus, isRead, isArchived, completedStateIcon, element.resource);
+            template.container.classList.toggle("in-progress", sessionStatus === SessionStatus.InProgress);
+            template.container.classList.toggle("needs-input", sessionStatus === SessionStatus.NeedsInput);
+            template.container.classList.toggle("unread", !isRead && !isArchived);
+            template.container.classList.toggle("quick-chat", isQuickChat && this.options.useCompactQuickChatRows);
+        }));
+        template.elementDisposables.add(autorun(reader => {
+            const titleText = element.title.read(reader);
+            template.title.set(titleText, matches);
+        }));
+        const timeDisposable = template.elementDisposables.add(( new MutableDisposable()));
+        const descriptionDisposable = template.elementDisposables.add(( new MutableDisposable()));
+        template.elementDisposables.add(autorun(reader => {
+            const sessionStatus = getSessionRowStatus(element, reader, !!this.options.deriveStatusFromMainChat);
+            const workspace = element.workspace.read(reader);
+            const description = element.description.read(reader);
+            const isQuickChat = element.isQuickChat?.read(reader) ?? false;
+            clearNode(template.detailsRow);
+            if (isQuickChat && this.options.useCompactQuickChatRows) {
+                descriptionDisposable.clear();
+                timeDisposable.clear();
+                return;
+            }
+            const diffStats = getSessionDiffStats(element, reader);
+            let timeDate;
+            const hideDetails = sessionStatus === SessionStatus.InProgress || sessionStatus === SessionStatus.NeedsInput;
+            if (!hideDetails) {
+                timeDate = element.updatedAt.read(reader);
+            }
+            const parts = [];
+            if (sessionStatus !== SessionStatus.InProgress) {
+                let icon;
+                if (isQuickChat) {
+                    icon = Codicon.commentDiscussion;
+                } else {
+                    const kind = getSessionWorkspaceKind(workspace, element.worktreePending?.read(reader));
+                    icon = workspace?.typeIcon ?? (kind === SessionWorkspaceKind.Virtual ? Codicon.cloudCompact : kind === SessionWorkspaceKind.Folder ? Codicon.folderCompact : Codicon.worktreeCompact);
+                }
+                const typeIconEl = append(template.detailsRow, $("span.session-details-icon"));
+                append(typeIconEl, $(`span${ThemeIcon.asCSSSelector(icon)}`));
+                parts.push(typeIconEl);
+            }
+            if (!hideDetails) {
+                const badgeLabel = isQuickChat ? ( localize(4785, "No workspace")) : workspace && (this.options.grouping() !== SessionsGrouping.Workspace || this.options.isPinned(element) || element.isArchived.read(reader) || this.options.isRenderedInCustomGroup?.(element)) ? getWorkspaceBadgeLabel(workspace) : undefined;
+                if (badgeLabel) {
+                    const badgeEl = append(template.detailsRow, $("span.session-badge"));
+                    badgeEl.textContent = badgeLabel;
+                    parts.push(badgeEl);
+                }
+            }
+            if (!isQuickChat && !hideDetails && diffStats) {
+                if (parts.length > 0) {
+                    append(template.detailsRow, $("span.session-separator.has-separator"));
+                }
+                const diffEl = append(template.detailsRow, $("span.session-diff"));
+                append(diffEl, $("span.session-diff-added")).textContent = `+${diffStats.insertions}`;
+                append(diffEl, $("span.session-diff-removed")).textContent = `-${diffStats.deletions}`;
+                parts.push(diffEl);
+            }
+            const statusMessage = getSessionStatusMessage(sessionStatus, description);
+            if (statusMessage !== undefined) {
+                if (parts.length > 0) {
+                    append(template.detailsRow, $("span.session-separator.has-separator"));
+                }
+                const statusEl = append(template.detailsRow, $("span.session-description"));
+                if (typeof statusMessage === "string") {
+                    descriptionDisposable.clear();
+                    statusEl.textContent = statusMessage;
+                } else {
+                    descriptionDisposable.value = this.markdownRendererService.render(statusMessage, {
+                        sanitizerConfig: {
+                            replaceWithPlaintext: true
+                        }
+                    }, statusEl);
+                }
+                parts.push(statusEl);
+            } else {
+                descriptionDisposable.clear();
+            }
+            if (!hideDetails && timeDate) {
+                if (parts.length > 0) {
+                    append(template.detailsRow, $("span.session-separator.has-separator"));
+                }
+                const timeEl = append(template.detailsRow, $("span.session-time"));
+                const definiteTimeDate = timeDate;
+                const formatTime = () => {
+                    const seconds = Math.round((Date.now() - definiteTimeDate.getTime()) / 1000);
+                    return seconds < 60 ? ( localize(4786, "now")) : fromNow(definiteTimeDate, true);
+                };
+                timeEl.textContent = formatTime();
+                const targetWindow = getWindow(timeEl);
+                const interval = targetWindow.setInterval(() => {
+                    timeEl.textContent = formatTime();
+                }, 60_000);
+                timeDisposable.value = toDisposable(() => targetWindow.clearInterval(interval));
+            } else {
+                timeDisposable.clear();
+            }
+        }));
+        if (this.approvalModel) {
+            this.renderApprovalRow(element, template);
+        }
+        if (this.ciFixModel) {
+            this.renderCIRow(element, template);
+        }
+    }
+    renderApprovalRow(element, template) {
+        if (!this.approvalModel) {
+            return;
+        }
+        const approvalModel = this.approvalModel;
+        const aggregate = this.options.aggregateChatApprovals;
+        const initialInfo = getSessionRowApproval(approvalModel, element, undefined, aggregate);
+        let lastApprovalHeight = approvalRowHeightFor(initialInfo, this.options.approvalRowMaxLines);
+        template.approvalRow.classList.toggle("visible", lastApprovalHeight > 0);
+        const buttonStore = template.elementDisposables.add(( new DisposableStore()));
+        template.elementDisposables.add(autorun(reader => {
+            buttonStore.clear();
+            const info = getSessionRowApproval(approvalModel, element, reader, aggregate);
+            const visible = !!info;
+            template.approvalRow.classList.toggle("visible", visible);
+            if (info) {
+                renderApprovalRowContent(info, {
+                    label: template.approvalLabel,
+                    buttonContainer: template.approvalButtonContainer
+                }, buttonStore, this.markdownRendererService, this.hoverService, this.options.showHover, this.options.approvalRowMaxLines, approvalId => {
+                    this._onDidApproveSession.fire({
+                        session: element,
+                        approvalId
+                    });
+                });
+            }
+            const height = approvalRowHeightFor(info, this.options.approvalRowMaxLines);
+            if (height !== lastApprovalHeight) {
+                lastApprovalHeight = height;
+                this._onDidChangeItemHeight.fire(element);
+            }
+        }));
+    }
+    renderCIRow(element, template) {
+        if (!this.ciFixModel) {
+            return;
+        }
+        const ciFixModel = this.ciFixModel;
+        const stateObs = ciFixModel.getCIFix(element);
+        let wasVisible = !!stateObs.get();
+        template.ciRow.classList.toggle("visible", wasVisible);
+        const buttonStore = template.elementDisposables.add(( new DisposableStore()));
+        template.elementDisposables.add(autorun(reader => {
+            buttonStore.clear();
+            const state = stateObs.read(reader);
+            const visible = !!state;
+            template.ciRow.classList.toggle("visible", visible);
+            if (state) {
+                template.ciLabel.textContent = ( localize(4787, "{0} checks failed, {1} pending", state.failed, state.pending));
+                template.ciButtonContainer.textContent = "";
+                const button = buttonStore.add(( new Button(template.ciButtonContainer, {
+                    title: ( localize(4788, "Fix failing CI checks")),
+                    ...defaultButtonStyles,
+                    buttonBackground: asCssVariable(chartsOrange),
+                    buttonHoverBackground: `color-mix(in srgb, ${asCssVariable(chartsOrange)} 88%, black)`,
+                    buttonBorder: asCssVariable(chartsOrange)
+                })));
+                button.label = ( localize(4789, "Fix CI"));
+                buttonStore.add(button.onDidClick(() => ciFixModel.fixCI(element)));
+            }
+            if (wasVisible !== visible) {
+                wasVisible = visible;
+                this._onDidChangeItemHeight.fire(element);
+            }
+        }));
+    }
+    disposeElement(_node, _index, template) {
+        template.elementDisposables.clear();
+    }
+    disposeTemplate(template) {
+        template.disposables.dispose();
+    }
+}
+function getSessionArchiveOnboardingTargetId(session) {
+    return `sessions.archiveAction.${session.sessionId}`;
+}
+function getWorkspaceBadgeLabel(workspace) {
+    const folder = workspace.folders[0];
+    if (folder?.root.scheme === GITHUB_REMOTE_FILE_SCHEME) {
+        const parts = folder.root.path.split("/").filter(Boolean);
+        if (parts.length >= 2) {
+            return `${parts[0]}/${parts[1]}`;
+        }
+    }
+    return workspace.label;
+}
+function renderSessionHeaderToolbar(template, element, select) {
+    template.elementDisposables.add(addDisposableListener(
+        template.toolbarContainer,
+        EventType.CONTEXT_MENU,
+        event => select(element, event),
+        true
+    ));
+    template.toolbar.context = element;
+}
+class SessionSectionRenderer {
+    static {
+        this.TEMPLATE_ID = "session-section";
+    }
+    constructor(
+        hideSectionCount,
+        select,
+        instantiationService,
+        contextKeyService,
+        automationService,
+        automationSessions,
+        automationNewBadgePresentation,
+        uriIdentityService,
+        customViewService,
+        menuService
+    ) {
+        this.hideSectionCount = hideSectionCount;
+        this.select = select;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.automationService = automationService;
+        this.automationSessions = automationSessions;
+        this.automationNewBadgePresentation = automationNewBadgePresentation;
+        this.uriIdentityService = uriIdentityService;
+        this.customViewService = customViewService;
+        this.menuService = menuService;
+        this.templateId = SessionSectionRenderer.TEMPLATE_ID;
+        this.templatesByElement = ( new WeakMap());
+        this.templatesById = ( new Map());
+        this.automationStatus = derived(this, reader => {
+            const runs = this.automationService.runs.read(reader);
+            const automationSessions = this.automationSessions.read(reader);
+            const hasNeedsInput = ( runs.some(run => {
+                if (run.status !== "running" || !run.sessionResource) {
+                    return false;
+                }
+                const session = automationSessions.find(
+                    candidate => this.uriIdentityService.extUri.isEqual(candidate.resource, run.sessionResource)
+                );
+                return !!session && session.status.read(reader) === SessionStatus.NeedsInput;
+            }));
+            if (hasNeedsInput) {
+                return SessionStatus.NeedsInput;
+            }
+            if (( runs.some(run => run.status === "pending" || run.status === "running"))) {
+                return SessionStatus.InProgress;
+            }
+            const hasUnreadRun = ( runs.some(run => {
+                if ((run.status !== "completed" && run.status !== "failed") || !run.sessionResource) {
+                    return false;
+                }
+                const sessionResource = run.sessionResource;
+                const session = automationSessions.find(
+                    candidate => this.uriIdentityService.extUri.isEqual(candidate.resource, sessionResource)
+                );
+                return !!session && !session.isRead.read(reader) && !session.isArchived.read(reader);
+            }));
+            if (hasUnreadRun) {
+                return SessionStatus.Completed;
+            }
+            return undefined;
+        });
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const elementDisposables = disposables.add(( new DisposableStore()));
+        const actionViewItemDisposables = disposables.add(( new DisposableStore()));
+        const dropdownAction = disposables.add(( new Action("sessionsView.sectionNewSession.moreActions", ( localize(4790, "More Actions")))));
+        container.classList.add("session-section");
+        const chevron = append(container, $("span.session-section-chevron"));
+        chevron.setAttribute("aria-hidden", "true");
+        const icon = append(container, $("span.session-section-icon"));
+        icon.setAttribute("aria-hidden", "true");
+        const label = append(container, $("span.session-section-label"));
+        const count = append(container, $("span.session-section-count"));
+        const newBadge = append(container, $("span.session-section-new-badge"));
+        newBadge.setAttribute("aria-hidden", "true");
+        newBadge.textContent = ( localize(4791, "New"));
+        const toolbarContainer = append(container, $(".session-section-toolbar"));
+        const contextKeyService = disposables.add(this.contextKeyService.createScoped(container));
+        const scopedInstantiationService = disposables.add(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService]))));
+        const toolbar = disposables.add(
+            scopedInstantiationService.createInstance(MenuWorkbenchToolBar, toolbarContainer, SessionSectionToolbarMenuId, {
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                actionViewItemProvider: (action, options) => {
+                    if (action.id !== NEW_SESSION_FOR_WORKSPACE_ACTION_ID || !(action instanceof MenuItemAction)) {
+                        return undefined;
+                    }
+                    actionViewItemDisposables.clear();
+                    const dropdownActions = getFlatContextMenuActions(
+                        this.menuService.getMenuActions(Menus.SessionSectionNewSession, contextKeyService, {
+                            shouldForwardArgs: true
+                        })
+                    );
+                    if (dropdownActions.length === 0) {
+                        return undefined;
+                    }
+                    const item = scopedInstantiationService.createInstance(
+                        DropdownWithPrimaryActionViewItem,
+                        action,
+                        dropdownAction,
+                        dropdownActions,
+                        "",
+                        {
+                            hoverDelegate: options.hoverDelegate,
+                            menuAsChild: false
+                        }
+                    );
+                    actionViewItemDisposables.add(
+                        item.onDidChangeDropdownVisibility(visible => container.classList.toggle("dropdown-active", visible))
+                    );
+                    actionViewItemDisposables.add(toDisposable(() => container.classList.remove("dropdown-active")));
+                    return item;
+                }
+            })
+        );
+        return {
+            container,
+            icon,
+            label,
+            count,
+            newBadge,
+            toolbarContainer,
+            toolbar,
+            chevron,
+            contextKeyService,
+            elementDisposables,
+            disposables
+        };
+    }
+    renderElement(node, _index, template) {
+        template.elementDisposables.clear();
+        const element = node.element;
+        if (!isSessionSection(element)) {
+            return;
+        }
+        renderSessionHeaderToolbar(template, element, this.select);
+        this.templatesByElement.set(element, template);
+        this.templatesById.set(element.id, template);
+        template.container.classList.remove(SESSION_HEADER_DROP_TARGET_CLASS);
+        template.container.classList.remove("session-section-shortcut");
+        template.newBadge.style.display = "none";
+        template.newBadge.classList.remove(
+            "session-section-new-badge-accent",
+            "session-section-new-badge-soft",
+            "session-section-new-badge-outline"
+        );
+        if (element.id === AUTOMATIONS_SECTION_ID) {
+            template.container.classList.add("session-section-shortcut");
+        }
+        clearNode(template.icon);
+        const sectionIcon = getSessionSectionIcon(element.id);
+        template.icon.className = sectionIcon ? `session-section-icon ${ThemeIcon.asClassName(sectionIcon)}` : "session-section-icon";
+        template.icon.style.display = sectionIcon ? "" : "none";
+        if (element.id === AUTOMATIONS_SECTION_ID) {
+            template.elementDisposables.add(autorun(reader => {
+                const activeCustomView = this.customViewService.activeCustomView.read(reader);
+                template.container.classList.toggle("active", activeCustomView?.id === AUTOMATIONS_CUSTOM_VIEW_ID);
+                const badgeStyle = this.automationNewBadgePresentation.read(reader);
+                template.newBadge.style.display = badgeStyle && badgeStyle !== "unread" ? "inline-flex" : "none";
+                template.newBadge.classList.toggle("session-section-new-badge-accent", badgeStyle === "accent");
+                template.newBadge.classList.toggle("session-section-new-badge-soft", badgeStyle === "soft");
+                template.newBadge.classList.toggle("session-section-new-badge-outline", badgeStyle === "outline");
+            }));
+            const statusIcon = template.elementDisposables.add(this.instantiationService.createInstance(SessionStatusIcon, template.icon));
+            template.elementDisposables.add(autorun(reader => {
+                const automationStatus = this.automationStatus.read(reader);
+                const badgeStyle = this.automationNewBadgePresentation.read(reader);
+                if (automationStatus === SessionStatus.NeedsInput) {
+                    template.icon.className = "session-section-icon";
+                    statusIcon.setStatus(SessionStatus.NeedsInput, true, false);
+                } else if (automationStatus === SessionStatus.InProgress) {
+                    template.icon.className = "session-section-icon";
+                    statusIcon.setStatus(SessionStatus.InProgress, true, false);
+                } else if (automationStatus === SessionStatus.Completed) {
+                    template.icon.className = "session-section-icon";
+                    statusIcon.setStatus(SessionStatus.Completed, false, false);
+                } else if (badgeStyle === "unread") {
+                    template.icon.className = "session-section-icon";
+                    statusIcon.setStatus(SessionStatus.Completed, false, false);
+                } else {
+                    statusIcon.reset();
+                    template.icon.className = `session-section-icon ${ThemeIcon.asClassName(Codicon.calendar)}`;
+                }
+            }));
+        }
+        template.label.textContent = element.label;
+        if (this.hideSectionCount || element.id === AUTOMATIONS_SECTION_ID) {
+            template.count.textContent = "";
+            template.count.style.display = "none";
+        } else {
+            template.count.textContent = String(element.sessions.length);
+            template.count.style.display = "";
+        }
+        this.updateChevron(template, node.collapsible, node.collapsed);
+        template.chevron.classList.toggle("collapsible", node.collapsible);
+        const sectionType = element.id.startsWith("workspace:") ? "workspace" : element.id;
+        SessionSectionTypeContext.bindTo(template.contextKeyService).set(sectionType);
+        const hasGitHubRepository = SessionSectionHasGitHubRepositoryContext.bindTo(template.contextKeyService);
+        const hasNonCloudRepository = SessionSectionHasNonCloudRepositoryContext.bindTo(template.contextKeyService);
+        template.elementDisposables.add(autorun(reader => {
+            let hasGitHub = false;
+            let hasNonCloudWorkspace = false;
+            for (const session of element.sessions) {
+                for (const folder of session.workspace.read(reader)?.folders ?? []) {
+                    if (folder.gitRepository?.gitHubInfo.read(reader) !== undefined) {
+                        hasGitHub = true;
+                    }
+                    hasNonCloudWorkspace ||= folder.root.scheme !== GITHUB_REMOTE_FILE_SCHEME;
+                }
+            }
+            hasGitHubRepository.set(hasGitHub);
+            hasNonCloudRepository.set(hasNonCloudWorkspace);
+        }));
+    }
+    updateCollapseState(element, collapsed) {
+        const template = this.templatesByElement.get(element);
+        if (template) {
+            this.updateChevron(template, true, collapsed);
+        }
+    }
+    setDropTarget(sectionId, active) {
+        const template = this.templatesById.get(sectionId);
+        template?.container.classList.toggle(SESSION_HEADER_DROP_TARGET_CLASS, active);
+    }
+    updateChevron(template, collapsible, collapsed) {
+        template.chevron.className = "session-section-chevron";
+        if (collapsible) {
+            template.chevron.classList.add("collapsible");
+            const icon = collapsed ? Codicon.chevronRight : Codicon.chevronDown;
+            template.chevron.classList.add(...ThemeIcon.asClassNameArray(icon));
+        }
+    }
+    disposeElement(node, _index, template) {
+        template.elementDisposables.clear();
+        if (isSessionSection(node.element)) {
+            this.templatesByElement.delete(node.element);
+            this.templatesById.delete(node.element.id);
+        }
+    }
+    disposeTemplate(template) {
+        template.disposables.dispose();
+    }
+}
+class SessionGroupRenderer {
+    static {
+        this.TEMPLATE_ID = "session-group";
+    }
+    constructor(delegate, instantiationService, contextKeyService) {
+        this.delegate = delegate;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.templateId = SessionGroupRenderer.TEMPLATE_ID;
+        this.templatesByElement = ( new WeakMap());
+        this.templatesById = ( new Map());
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        container.classList.add("session-section", "session-group");
+        const chevron = append(container, $("span.session-section-chevron"));
+        chevron.setAttribute("aria-hidden", "true");
+        const icon = append(container, $("span.session-section-icon"));
+        icon.classList.add(...ThemeIcon.asClassNameArray(Codicon.folderLibrary));
+        icon.setAttribute("aria-hidden", "true");
+        const label = append(container, $("span.session-section-label"));
+        const inputContainer = append(container, $(".session-group-input"));
+        const toolbarContainer = append(container, $(".session-section-toolbar"));
+        const contextKeyService = disposables.add(this.contextKeyService.createScoped(container));
+        const scopedInstantiationService = disposables.add(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService]))));
+        const toolbar = disposables.add(
+            scopedInstantiationService.createInstance(MenuWorkbenchToolBar, toolbarContainer, SessionGroupToolbarMenuId, {
+                menuOptions: {
+                    shouldForwardArgs: true
+                }
+            })
+        );
+        return {
+            container,
+            label,
+            inputContainer,
+            toolbarContainer,
+            toolbar,
+            chevron,
+            contextKeyService,
+            disposables,
+            elementDisposables: disposables.add(( new DisposableStore()))
+        };
+    }
+    renderElement(node, _index, template) {
+        const element = node.element;
+        if (!isSessionGroupItem(element)) {
+            return;
+        }
+        template.elementDisposables.clear();
+        renderSessionHeaderToolbar(template, element, this.delegate.select);
+        this.templatesByElement.set(element, template);
+        this.templatesById.set(element.group.id, template);
+        template.container.classList.remove(SESSION_HEADER_DROP_TARGET_CLASS);
+        template.label.textContent = element.group.name;
+        this.updateChevron(template, node.collapsible, node.collapsed);
+        SessionGroupHasVisibleSessionsContext.bindTo(template.contextKeyService).set(element.sessions.length > 0);
+        SessionGroupIsEmptyContext.bindTo(template.contextKeyService).set(element.isEmpty);
+        template.container.classList.toggle("session-group-editing", element.editing);
+        if (element.editing) {
+            this.renderInput(element, template);
+        } else {
+            template.inputContainer.style.display = "none";
+            template.label.style.display = "";
+        }
+    }
+    renderInput(element, template) {
+        template.label.style.display = "none";
+        template.inputContainer.style.display = "";
+        clearNode(template.inputContainer);
+        const input = template.elementDisposables.add(( new InputBox(template.inputContainer, undefined, {
+            inputBoxStyles: defaultInputBoxStyles,
+            ariaLabel: ( localize(4792, "Group name"))
+        })));
+        input.value = element.group.name;
+        input.focus();
+        input.select();
+        let done = false;
+        const commit = () => {
+            if (done) {
+                return;
+            }
+            done = true;
+            this.delegate.commitEdit(element.group, input.value.trim());
+        };
+        const cancel = () => {
+            if (done) {
+                return;
+            }
+            done = true;
+            this.delegate.cancelEdit(element.group);
+        };
+        template.elementDisposables.add(
+            addStandardDisposableListener(input.inputElement, EventType.KEY_DOWN, e => {
+                if (e.equals(KeyCode.Enter)) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    commit();
+                } else if (e.equals(KeyCode.Escape)) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    cancel();
+                }
+            })
+        );
+        template.elementDisposables.add(
+            addDisposableListener(input.inputElement, EventType.BLUR, () => commit())
+        );
+    }
+    updateCollapseState(element, collapsed) {
+        const template = this.templatesByElement.get(element);
+        if (template) {
+            this.updateChevron(template, true, collapsed);
+        }
+    }
+    setDropTarget(groupId, active) {
+        const template = this.templatesById.get(groupId);
+        template?.container.classList.toggle(SESSION_HEADER_DROP_TARGET_CLASS, active);
+    }
+    updateChevron(template, collapsible, collapsed) {
+        template.chevron.className = "session-section-chevron";
+        if (collapsible) {
+            template.chevron.classList.add("collapsible");
+            const icon = collapsed ? Codicon.chevronRight : Codicon.chevronDown;
+            template.chevron.classList.add(...ThemeIcon.asClassNameArray(icon));
+        }
+    }
+    disposeElement(node, _index, template) {
+        if (isSessionGroupItem(node.element)) {
+            this.templatesByElement.delete(node.element);
+            this.templatesById.delete(node.element.group.id);
+        }
+        template.elementDisposables.clear();
+    }
+    disposeTemplate(template) {
+        template.disposables.dispose();
+    }
+}
+class SessionShowMoreRenderer {
+    constructor() {
+        this.templateId = SessionShowMoreRenderer.TEMPLATE_ID;
+        this.rowClassName = "session-list-inset-row";
+    }
+    static {
+        this.TEMPLATE_ID = "session-show-more";
+    }
+    renderTemplate(container) {
+        container.classList.add("session-show-more");
+        return append(container, $("span.session-show-more-label"));
+    }
+    renderElement(node, _index, template) {
+        const element = node.element;
+        if (!isSessionShowMore(element)) {
+            return;
+        }
+        const container = template.parentElement;
+        container?.classList.toggle("session-show-more-folders", element.kind === "folders");
+        if (element.mode === "less") {
+            template.textContent = element.kind === "folders" ? ( localize(4793, "Show fewer workspaces")) : ( localize(4794, "Show less"));
+        } else {
+            template.textContent = element.kind === "folders" ? element.remainingCount === 1 ? ( localize(4795, "+{0} more workspace", element.remainingCount)) : ( localize(4796, "+{0} more workspaces", element.remainingCount)) : ( localize(4797, "+{0} more", element.remainingCount));
+        }
+    }
+    disposeTemplate(_template) {}
+}
+class SessionPlaceholderRenderer {
+    static {
+        this.TEMPLATE_ID = "session-placeholder";
+    }
+    constructor(hoverService) {
+        this.hoverService = hoverService;
+        this.templateId = SessionPlaceholderRenderer.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        container.classList.add("session-placeholder");
+        return {
+            container,
+            label: append(container, $("span.session-placeholder-label")),
+            hover: ( new MutableDisposable())
+        };
+    }
+    renderElement(node, _index, template) {
+        const element = node.element;
+        if (!isSessionPlaceholder(element)) {
+            return;
+        }
+        template.label.textContent = element.label;
+        template.hover.value = element.hover ? this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), template.container, element.hover) : undefined;
+    }
+    disposeTemplate(template) {
+        template.hover.dispose();
+    }
+}
+class SessionsAccessibilityProvider {
+    constructor(automationStatus, options) {
+        this.automationStatus = automationStatus;
+        this.options = options;
+    }
+    getWidgetAriaLabel() {
+        return localize(4798, "Sessions");
+    }
+    getAriaLabel(element) {
+        if (isSessionChatItem(element)) {
+            return derived(this, reader => ( localize(
+                4799,
+                "{0}, chat, updated {1}, {2}",
+                getChatTitle(element.chat, reader),
+                fromNow(element.chat.updatedAt.read(reader), true),
+                getSessionConversationStatusAriaLabel(element.chat.status.read(reader))
+            )));
+        }
+        if (isSessionGroupItem(element)) {
+            return `${element.group.name}, ${element.sessions.length}`;
+        }
+        if (isSessionSection(element)) {
+            if (element.id === AUTOMATIONS_SECTION_ID) {
+                return derived(this, reader => {
+                    let label = element.label;
+                    switch (this.automationStatus?.read(reader)) {
+                    case SessionStatus.NeedsInput:
+                        label = ( localize(4800, "{0}, run needs input", element.label));
+                        break;
+                    case SessionStatus.InProgress:
+                        label = ( localize(4801, "{0}, run in progress", element.label));
+                        break;
+                    case SessionStatus.Completed:
+                        label = ( localize(4802, "{0}, unread run", element.label));
+                        break;
+                    }
+                    return this.options?.automationNewBadgeVisible?.read(reader) ? ( localize(4803, "{0}, new feature", label)) : label;
+                });
+            }
+            return `${element.label}, ${element.sessions.length}`;
+        }
+        if (isSessionShowMore(element)) {
+            if (element.mode === "less") {
+                return element.kind === "folders" ? ( localize(4804, "Show fewer workspaces")) : ( localize(4805, "Show fewer sessions"));
+            }
+            return element.kind === "folders" ? element.remainingCount === 1 ? ( localize(4806, "Show {0} more workspace", element.remainingCount)) : ( localize(4807, "Show {0} more workspaces", element.remainingCount)) : ( localize(4808, "Show {0} more sessions", element.remainingCount));
+        }
+        if (isSessionPlaceholder(element)) {
+            return element.hover ? ( localize(4809, "{0}. {1}", element.label, element.hover)) : element.label;
+        }
+        return derived(this, reader => {
+            const title = element.title.read(reader);
+            const updated = fromNow(element.updatedAt.read(reader), true);
+            let label;
+            if (this.options?.includeQuickChatInAriaLabel && element.isQuickChat?.read(reader)) {
+                label = ( localize(4810, "{0}, chat, updated {1}", title, updated));
+            } else if (element.worktreePending?.read(reader)) {
+                label = ( localize(4811, "{0}, creating worktree, updated {1}", title, updated));
+            } else {
+                label = ( localize(4812, "{0}, updated {1}", title, updated));
+            }
+            const status = getSessionRowStatus(element, reader, !!this.options?.deriveStatusFromMainChat);
+            if (this.options?.deriveStatusFromMainChat) {
+                label = ( localize(4813, "{0}, {1}", label, getSessionConversationStatusAriaLabel(status)));
+            }
+            const workspace = element.workspace.read(reader);
+            const workspaceLabel = workspace ? getWorkspaceBadgeLabel(workspace) : undefined;
+            if (this.options && status !== SessionStatus.InProgress && status !== SessionStatus.NeedsInput && workspaceLabel && (this.options.grouping() !== SessionsGrouping.Workspace || this.options.isPinned(element) || element.isArchived.read(reader) || this.options.isRenderedInCustomGroup?.(element))) {
+                label = ( localize(4814, "{0}, in {1}", label, workspaceLabel));
+            }
+            return label;
+        });
+    }
+}
+class SessionsListDragAndDrop extends Disposable {
+    constructor(delegate) {
+        super();
+        this.delegate = delegate;
+        this._transfer = LocalSelectionTransfer.getInstance();
+    }
+    getDragURI(element) {
+        if (isSessionGroupItem(element)) {
+            return `sessionGroup:${element.group.id}`;
+        }
+        if (isSessionSection(element)) {
+            return element.id.startsWith("workspace:") ? `sessionWorkspace:${element.id}` : null;
+        }
+        if (isSessionShowMore(element)) {
+            return null;
+        }
+        if (isSessionPlaceholder(element)) {
+            return null;
+        }
+        if (isSessionChatItem(element)) {
+            return ( element.chat.resource.toString());
+        }
+        return ( element.resource.toString());
+    }
+    getDragLabel(elements) {
+        const chatItem = elements.find(isSessionChatItem);
+        if (chatItem) {
+            return getChatTitle(chatItem.chat);
+        }
+        const groupItem = elements.find(isSessionGroupItem);
+        if (groupItem) {
+            return groupItem.group.name;
+        }
+        const workspaceSection = elements.find(e => isSessionSection(e) && e.id.startsWith("workspace:"));
+        if (workspaceSection) {
+            return workspaceSection.label;
+        }
+        const sessions = this.toSessions(elements);
+        if (sessions.length === 0) {
+            return undefined;
+        }
+        if (sessions.length === 1) {
+            return sessions[0].title.get();
+        }
+        return localize(4815, "{0} sessions", sessions.length);
+    }
+    onDragStart(data, originalEvent) {
+        const elements = data instanceof ElementsDragAndDropData ? data.elements : [];
+        const chatItem = elements.find(isSessionChatItem);
+        if (chatItem) {
+            fillSessionChatDragData(originalEvent, chatItem.session.sessionId, chatItem.chat.resource);
+            return;
+        }
+        const sessions = this.toSessions(elements);
+        if (sessions.length === 0) {
+            return;
+        }
+        const identifiers = sessions.map(s => ( new DraggedSessionIdentifier(s.sessionId, s.resource)));
+        this._transfer.setData(identifiers, DraggedSessionIdentifier.prototype);
+        if (originalEvent.dataTransfer) {
+            const payload = JSON.stringify({
+                sessionId: sessions[0].sessionId,
+                resource: ( sessions[0].resource.toString())
+            });
+            originalEvent.dataTransfer.setData(SessionsDataTransfers.SESSION, payload);
+        }
+    }
+    onDragEnd() {
+        this._transfer.clearData(DraggedSessionIdentifier.prototype);
+        this.delegate.setDropTargetHeader(undefined);
+    }
+    onDragOver(data, targetElement, _targetIndex, targetSector) {
+        const draggedHeader = this.draggedHeader(data);
+        if (draggedHeader) {
+            this.delegate.setDropTargetHeader(undefined);
+            return this.onHeaderDragOver(draggedHeader, targetElement, targetSector);
+        }
+        const pinTarget = this.resolvePinTarget(data, targetElement, targetSector);
+        if (pinTarget) {
+            this.delegate.setDropTargetHeader(pinTarget.header);
+            return this.toMembershipDropReaction(pinTarget);
+        }
+        const addToGroupTarget = this.resolveAddToGroupTarget(data, targetElement, targetSector);
+        if (addToGroupTarget) {
+            this.delegate.setDropTargetHeader(addToGroupTarget.header);
+            return this.toMembershipDropReaction(addToGroupTarget);
+        }
+        const removeFromGroupTarget = this.resolveRemoveFromGroupTarget(data, targetElement, targetSector);
+        if (removeFromGroupTarget) {
+            this.delegate.setDropTargetHeader(removeFromGroupTarget.header);
+            return this.toMembershipDropReaction(removeFromGroupTarget);
+        }
+        this.delegate.setDropTargetHeader(undefined);
+        const target = this.resolveReorderTarget(data, targetElement);
+        if (!target) {
+            return false;
+        }
+        const position = sectorToPosition(targetSector);
+        return {
+            accept: true,
+            effect: {
+                type: ListDragOverEffectType.Move,
+                position: position === "after" ? ListDragOverEffectPosition.After : ListDragOverEffectPosition.Before
+            }
+        };
+    }
+    drop(data, targetElement, _targetIndex, targetSector) {
+        this.delegate.setDropTargetHeader(undefined);
+        try {
+            const draggedHeader = this.draggedHeader(data);
+            if (draggedHeader) {
+                if (targetElement) {
+                    const targetRef = this.headerRefOf(targetElement);
+                    if (targetRef && targetRef !== draggedHeader.id) {
+                        this.delegate.reorderSection(
+                            draggedHeader.id,
+                            targetRef,
+                            sectorToPosition(targetSector),
+                            draggedHeader.isWorkspace
+                        );
+                    }
+                }
+                return;
+            }
+            const pinTarget = this.resolvePinTarget(data, targetElement, targetSector);
+            if (pinTarget) {
+                this.delegate.pinSessions(pinTarget.sessions, pinTarget.target, pinTarget.position);
+                return;
+            }
+            const addToGroupTarget = this.resolveAddToGroupTarget(data, targetElement, targetSector);
+            if (addToGroupTarget) {
+                this.delegate.addSessionsToGroup(
+                    addToGroupTarget.sessions,
+                    addToGroupTarget.groupId,
+                    addToGroupTarget.target,
+                    addToGroupTarget.position
+                );
+                return;
+            }
+            const removeFromGroupTarget = this.resolveRemoveFromGroupTarget(data, targetElement, targetSector);
+            if (removeFromGroupTarget) {
+                this.delegate.removeSessionsFromGroup(
+                    removeFromGroupTarget.sessions,
+                    removeFromGroupTarget.target,
+                    removeFromGroupTarget.position
+                );
+                return;
+            }
+            const target = this.resolveReorderTarget(data, targetElement);
+            if (!target) {
+                return;
+            }
+            this.delegate.reorder(this.draggedSessions(data), target, sectorToPosition(targetSector));
+        } finally {
+            this.delegate.setDropTargetHeader(undefined);
+        }
+    }
+    onHeaderDragOver(draggedHeader, targetElement, targetSector) {
+        if (!targetElement) {
+            return false;
+        }
+        const targetRef = this.headerRefOf(targetElement);
+        if (!targetRef || targetRef === draggedHeader.id) {
+            return false;
+        }
+        const position = sectorToPosition(targetSector);
+        return {
+            accept: true,
+            effect: {
+                type: ListDragOverEffectType.Move,
+                position: position === "after" ? ListDragOverEffectPosition.After : ListDragOverEffectPosition.Before
+            }
+        };
+    }
+    resolvePinTarget(data, targetElement, targetSector) {
+        if (!targetElement) {
+            return undefined;
+        }
+        let target;
+        if (isSessionSection(targetElement)) {
+            if (targetElement.id !== "pinned") {
+                return undefined;
+            }
+        } else if (isSessionItem(targetElement) && this.delegate.isSessionPinned(targetElement)) {
+            target = targetElement;
+        } else {
+            return undefined;
+        }
+        const dragged = this.draggedSessions(data);
+        const hasArchived = ( dragged.some(session => session.isArchived.get()));
+        const allPinned = dragged.every(session => this.delegate.isSessionPinned(session));
+        if (dragged.length === 0 || hasArchived || allPinned) {
+            return undefined;
+        }
+        if (target && ( dragged.some(session => session.sessionId === target.sessionId))) {
+            return undefined;
+        }
+        return {
+            sessions: dragged,
+            header: {
+                kind: "section",
+                id: "pinned"
+            },
+            target,
+            position: target ? sectorToPosition(targetSector) : undefined
+        };
+    }
+    resolveAddToGroupTarget(data, targetElement, targetSector) {
+        if (!targetElement) {
+            return undefined;
+        }
+        let groupId;
+        let target;
+        if (isSessionGroupItem(targetElement)) {
+            groupId = targetElement.group.id;
+        } else if (isSessionPlaceholder(targetElement) && targetElement.sectionId.startsWith("group:")) {
+            groupId = targetElement.sectionId.slice("group:".length);
+        } else if (isSessionItem(targetElement)) {
+            groupId = this.delegate.getGroupIdOfSession(targetElement);
+            target = groupId === undefined ? undefined : targetElement;
+        }
+        if (groupId === undefined) {
+            return undefined;
+        }
+        const dragged = this.draggedSessions(data);
+        const hasArchived = ( dragged.some(session => session.isArchived.get()));
+        const allInGroup = dragged.every(session => this.delegate.getGroupIdOfSession(session) === groupId);
+        if (dragged.length === 0 || hasArchived || allInGroup) {
+            return undefined;
+        }
+        if (target && ( dragged.some(session => session.sessionId === target.sessionId))) {
+            return undefined;
+        }
+        return {
+            sessions: dragged,
+            groupId,
+            header: {
+                kind: "group",
+                id: groupId
+            },
+            target,
+            position: target ? sectorToPosition(targetSector) : undefined
+        };
+    }
+    resolveRemoveFromGroupTarget(data, targetElement, targetSector) {
+        if (!targetElement) {
+            return undefined;
+        }
+        let sectionId;
+        let target;
+        if (isSessionSection(targetElement)) {
+            sectionId = targetElement.id.startsWith("workspace:") ? targetElement.id : undefined;
+        } else if (isSessionItem(targetElement) && this.delegate.getGroupIdOfSession(targetElement) === undefined) {
+            sectionId = this.delegate.getWorkspaceSectionIdOfSession(targetElement);
+            target = sectionId === undefined ? undefined : targetElement;
+        }
+        if (sectionId === undefined) {
+            return undefined;
+        }
+        const dragged = this.draggedSessions(data);
+        const canRemove = dragged.every(
+            session => this.delegate.getGroupIdOfSession(session) !== undefined && this.delegate.getWorkspaceSectionIdOfSession(session) === sectionId
+        );
+        if (dragged.length === 0 || !canRemove) {
+            return undefined;
+        }
+        return {
+            sessions: dragged,
+            header: {
+                kind: "section",
+                id: sectionId
+            },
+            target,
+            position: target ? sectorToPosition(targetSector) : undefined
+        };
+    }
+    resolveReorderTarget(data, targetElement) {
+        if (!targetElement || !isSessionItem(targetElement)) {
+            return undefined;
+        }
+        const target = targetElement;
+        if (!this.delegate.isReorderable(target)) {
+            return undefined;
+        }
+        const dragged = this.draggedSessions(data);
+        if (dragged.length === 0 || ( dragged.some(s => s.sessionId === target.sessionId))) {
+            return undefined;
+        }
+        if (( dragged.some(s => !this.delegate.isReorderable(s)))) {
+            return undefined;
+        }
+        if (!this.delegate.canDropOn(dragged, target)) {
+            return undefined;
+        }
+        return target;
+    }
+    toMembershipDropReaction(target) {
+        let position = ListDragOverEffectPosition.Over;
+        if (target.position === "after") {
+            position = ListDragOverEffectPosition.After;
+        } else if (target.position === "before") {
+            position = ListDragOverEffectPosition.Before;
+        }
+        return {
+            accept: true,
+            effect: {
+                type: ListDragOverEffectType.Move,
+                position
+            }
+        };
+    }
+    draggedHeader(data) {
+        if (!(data instanceof ElementsDragAndDropData)) {
+            return undefined;
+        }
+        const elements = data.elements;
+        const groupItem = elements.find(isSessionGroupItem);
+        if (groupItem) {
+            return {
+                id: `group:${groupItem.group.id}`,
+                isWorkspace: false
+            };
+        }
+        const workspaceSection = elements.find(e => isSessionSection(e) && e.id.startsWith("workspace:"));
+        if (workspaceSection) {
+            return {
+                id: workspaceSection.id,
+                isWorkspace: true
+            };
+        }
+        return undefined;
+    }
+    headerRefOf(element) {
+        if (isSessionGroupItem(element)) {
+            return `group:${element.group.id}`;
+        }
+        if (isSessionSection(element) && element.id.startsWith("workspace:")) {
+            return element.id;
+        }
+        return undefined;
+    }
+    draggedSessions(data) {
+        return this.toSessions(data instanceof ElementsDragAndDropData ? data.elements : []);
+    }
+    toSessions(elements) {
+        return elements.filter(isSessionItem);
+    }
+}
+function sectorToPosition(sector) {
+    return sector !== undefined && sector >= ListViewTargetSector.CENTER_BOTTOM ? "after" : "before";
+}
+let SessionsList = class SessionsList extends Disposable {
+    static {
+        SessionsList_1 = this;
+    }
+    static {
+        this.SECTION_COLLAPSE_STATE_KEY = "sessionsListControl.sectionCollapseState";
+    }
+    static {
+        this.EXCLUDED_TYPES_KEY = "sessionsListControl.excludedSessionTypes";
+    }
+    static {
+        this.EXCLUDED_STATUSES_KEY = "sessionsListControl.excludedStatuses";
+    }
+    static {
+        this.EXCLUDE_ARCHIVED_KEY = "sessionsListControl.excludeArchived";
+    }
+    static {
+        this.EXCLUDE_READ_KEY = "sessionsListControl.excludeRead";
+    }
+    static {
+        this.WORKSPACE_GROUP_CAPPED_KEY = "sessionsListControl.workspaceGroupCapped";
+    }
+    static {
+        this.DEFAULT_SESSION_GROUP_LIMIT = 5;
+    }
+    static {
+        this.SESSION_GROUP_LIMIT_TREATMENT = "sessions.workspaceGroupLimit";
+    }
+    get element() {
+        return this.listContainer;
+    }
+    async resetAutomationsNewBadge() {
+        if (this.customViewService.activeCustomView.get()?.id === AUTOMATIONS_CUSTOM_VIEW_ID) {
+            this.customViewService.hideCustomView();
+        }
+        await this.automationsNewBadgeState.reset();
+    }
+    constructor(
+        container,
+        options,
+        _sessionsManagementService,
+        _sessionsService,
+        customViewService,
+        _sessionsListModelService,
+        _sessionGroupsService,
+        _sessionSectionOrderService,
+        _agentHostFilterService,
+        instantiationService,
+        contextKeyService,
+        storageService,
+        contextMenuService,
+        menuService,
+        keybindingService,
+        commandService,
+        automationService,
+        _listVoicePlaybackService,
+        assignmentService,
+        configurationService,
+        uriIdentityService,
+        agentHostConnectionsService,
+        openerService,
+        labelService,
+        preferencesService
+    ) {
+        super();
+        this.options = options;
+        this._sessionsManagementService = _sessionsManagementService;
+        this._sessionsService = _sessionsService;
+        this.customViewService = customViewService;
+        this._sessionsListModelService = _sessionsListModelService;
+        this._sessionGroupsService = _sessionGroupsService;
+        this._sessionSectionOrderService = _sessionSectionOrderService;
+        this._agentHostFilterService = _agentHostFilterService;
+        this.contextKeyService = contextKeyService;
+        this.storageService = storageService;
+        this.contextMenuService = contextMenuService;
+        this.menuService = menuService;
+        this.keybindingService = keybindingService;
+        this.commandService = commandService;
+        this.automationService = automationService;
+        this._listVoicePlaybackService = _listVoicePlaybackService;
+        this.assignmentService = assignmentService;
+        this.configurationService = configurationService;
+        this.uriIdentityService = uriIdentityService;
+        this.agentHostConnectionsService = agentHostConnectionsService;
+        this.openerService = openerService;
+        this.labelService = labelService;
+        this.preferencesService = preferencesService;
+        this.sessions = [];
+        this.sessionChatsObserver = this._register(( new MutableDisposable()));
+        this.activeSessionUpdate = this._register(( new MutableDisposable()));
+        this.chatApprovalHeightReconcile = this._register(( new MutableDisposable()));
+        this.automationSessions = observableValue(this, []);
+        this.hoveredGuideSessionId = observableValue(this, undefined);
+        this.selectedGuideSessionIds = observableValue(this, EMPTY_GUIDE_SESSION_IDS);
+        this.focusedGuideSessionIds = observableValue(this, EMPTY_GUIDE_SESSION_IDS);
+        this.activeGuideSessionIds = derived(this, reader => {
+            const hovered = this.hoveredGuideSessionId.read(reader);
+            const selected = this.selectedGuideSessionIds.read(reader);
+            const focused = this.focusedGuideSessionIds.read(reader);
+            if (!hovered && focused.size === 0) {
+                return selected;
+            }
+            const ids = ( new Set(selected));
+            for (const id of focused) {
+                ids.add(id);
+            }
+            if (hovered) {
+                ids.add(hovered);
+            }
+            return ids;
+        });
+        this.visible = true;
+        this.archiveOnboardingSession = observableValue(this, undefined);
+        this.sessionGroupLimit = observableValue(this, SessionsList_1.DEFAULT_SESSION_GROUP_LIMIT);
+        this.expandedSessionGroups = ( new Set());
+        this.expandedMoreFolders = false;
+        this.hasFindPattern = false;
+        this.suspendCollapseStatePersistence = false;
+        this._topLevelOrder = [];
+        this._onDidUpdate = this._register(( new Emitter()));
+        this.onDidUpdate = this._onDidUpdate.event;
+        this._onDidChangeFindOpenState = this._register(( new Emitter()));
+        this.onDidChangeFindOpenState = this._onDidChangeFindOpenState.event;
+        this.automationsNewBadgeState = this._register(instantiationService.createInstance(AutomationsNewBadgeState));
+        this.excludedSessionTypes = this.loadExcludedSessionTypes();
+        this.excludedStatuses = this.loadExcludedStatuses();
+        this._excludeArchived = this.storageService.getBoolean(SessionsList_1.EXCLUDE_ARCHIVED_KEY, StorageScope.PROFILE, true);
+        this._excludeRead = this.storageService.getBoolean(SessionsList_1.EXCLUDE_READ_KEY, StorageScope.PROFILE, false);
+        this.workspaceGroupCapped = this.storageService.getBoolean(SessionsList_1.WORKSPACE_GROUP_CAPPED_KEY, StorageScope.PROFILE, true);
+        this.listContainer = append(container, $(".sessions-list-control.session-list-row-spacing"));
+        this._register(
+            addDisposableListener(this.listContainer, EventType.POINTER_DOWN, () => {
+                this.listContainer.classList.add(SESSION_SECTION_FOCUS_FROM_POINTER_CLASS);
+            })
+        );
+        this._register(
+            addDisposableListener(this.listContainer.ownerDocument, EventType.KEY_DOWN, () => {
+                this.listContainer.classList.remove(SESSION_SECTION_FOCUS_FROM_POINTER_CLASS);
+            }, true)
+        );
+        const approvalModel = this.options.approvalModel ?? this._register(instantiationService.createInstance(AgentSessionApprovalModel));
+        this._approvalModel = approvalModel;
+        const markdownRendererService = instantiationService.invokeFunction(accessor => accessor.get(IMarkdownRendererService));
+        const hoverService = instantiationService.invokeFunction(accessor => accessor.get(IHoverService));
+        const sessionsProvidersService = instantiationService.invokeFunction(accessor => accessor.get(ISessionsProvidersService));
+        this._sessionsProvidersService = sessionsProvidersService;
+        const providerCapabilityListeners = this._register(( new DisposableStore()));
+        const subscribeProviderCapabilities = () => {
+            providerCapabilityListeners.clear();
+            for (const provider of sessionsProvidersService.getProviders()) {
+                if (provider.onDidChangeCapabilities) {
+                    providerCapabilityListeners.add(provider.onDidChangeCapabilities(() => this.update()));
+                }
+            }
+        };
+        subscribeProviderCapabilities();
+        this._register(sessionsProvidersService.onDidChangeProviders(() => {
+            subscribeProviderCapabilities();
+            this.update();
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(SESSIONS_LIST_SHOW_EMPTY_DEFAULT_GROUPS_SETTING) || e.affectsConfiguration(ChatSessionArchiveActionWordingSettingId)) {
+                this.update();
+            }
+        }));
+        const agentSessionsService = instantiationService.invokeFunction(accessor => accessor.get(IAgentSessionsService));
+        const voicePlaybackService = instantiationService.invokeFunction(accessor => accessor.get(IVoicePlaybackService));
+        const sessionRenderer = ( new SessionItemRenderer({
+            grouping: this.options.grouping,
+            isPinned: s => this.isSessionPinned(s),
+            isRenderedInCustomGroup: s => this.isRenderedInCustomGroup(s),
+            visibleSessions: this._sessionsService.visibleSessions,
+            getMultiSelectedSessions: s => this.getMultiSelectedSessions(s),
+            showHover: true,
+            useCompactQuickChatRows: true,
+            approvalRowMaxLines: DEFAULT_APPROVAL_ROW_MAX_LINES,
+            aggregateChatApprovals: false,
+            toolbarMenuId: SessionItemToolbarMenuId,
+            onDidRequestRename: session => {
+                this.commandService.executeCommand(RENAME_SESSION_COMMAND_ID, session).catch(onUnexpectedError);
+            },
+            activeGuideSessionIds: this.activeGuideSessionIds,
+            deriveStatusFromMainChat: true,
+            archiveOnboardingSession: this.archiveOnboardingSession
+        }, approvalModel, undefined, instantiationService, contextKeyService, this.configurationService, markdownRendererService, hoverService, sessionsProvidersService, this._sessionsManagementService, this.agentHostConnectionsService, this.openerService, this.labelService, this.preferencesService, agentSessionsService, voicePlaybackService));
+        const showMoreRenderer = ( new SessionShowMoreRenderer());
+        const placeholderRenderer = ( new SessionPlaceholderRenderer(hoverService));
+        const chatRenderer = ( new SessionChatItemRenderer(
+            hoverService,
+            instantiationService,
+            markdownRendererService,
+            approvalModel,
+            DEFAULT_APPROVAL_ROW_MAX_LINES,
+            this.activeGuideSessionIds
+        ));
+        const selectHeader = (element, event) => {
+            this.tree.setFocus([element], event);
+            this.tree.setSelection([element], event);
+        };
+        const sectionRenderer = ( new SessionSectionRenderer(
+            true ,
+            selectHeader,
+            instantiationService,
+            contextKeyService,
+            this.automationService,
+            this.automationSessions,
+            this.automationsNewBadgeState.presentation,
+            this.uriIdentityService,
+            this.customViewService,
+            this.menuService
+        ));
+        this._sectionRenderer = sectionRenderer;
+        const groupRenderer = ( new SessionGroupRenderer({
+            commitEdit: (group, name) => this.commitGroupEdit(group, name),
+            cancelEdit: group => this.cancelGroupEdit(group),
+            select: selectHeader
+        }, instantiationService, contextKeyService));
+        this._groupRenderer = groupRenderer;
+        const delegate = ( new SessionsTreeDelegate(
+            approvalModel,
+            () => !!IsPhoneLayoutContext.getValue(contextKeyService),
+            DEFAULT_APPROVAL_ROW_MAX_LINES,
+            undefined,
+            true ,
+            false ,
+            true
+        ));
+        this._delegate = delegate;
+        this.tree = this._register(
+            instantiationService.createInstance(WorkbenchObjectTree, "SessionsListTree", this.listContainer, delegate, [
+                sessionRenderer,
+                chatRenderer,
+                sectionRenderer,
+                groupRenderer,
+                showMoreRenderer,
+                placeholderRenderer
+            ], {
+                accessibilityProvider: ( new SessionsAccessibilityProvider(sectionRenderer.automationStatus, {
+                    grouping: this.options.grouping,
+                    isPinned: session => this.isSessionPinned(session),
+                    isRenderedInCustomGroup: session => this.isRenderedInCustomGroup(session),
+                    deriveStatusFromMainChat: true,
+                    automationNewBadgeVisible: this.automationsNewBadgeState.showNewBadge
+                })),
+                dnd: this._register(( new SessionsListDragAndDrop({
+                    isReorderable: session => this.isReorderable(session),
+                    isSessionPinned: session => this.isSessionPinned(session),
+                    canDropOn: (dragged, target) => this.canReorderOnto(dragged, target),
+                    reorder: (dragged, target, position) => this.reorderSessions(dragged, target, position),
+                    getGroupIdOfSession: session => this._sessionGroupsService.getGroupOfSession(session.sessionId),
+                    getWorkspaceSectionIdOfSession: session => this.getWorkspaceSectionIdOfSession(session),
+                    addSessionsToGroup: (sessions, groupId, target, position) => this.addSessionsToGroup(sessions, groupId, target, position),
+                    removeSessionsFromGroup: (sessions, target, position) => this.removeSessionsFromGroup(sessions, target, position),
+                    pinSessions: (sessions, target, position) => this.pinSessions(sessions, target, position),
+                    setDropTargetHeader: header => this.setDropTargetHeader(header),
+                    reorderSection: (draggedId, targetId, position, isWorkspace) => this.reorderSection(draggedId, targetId, position, isWorkspace)
+                }))),
+                identityProvider: {
+                    getId: element => {
+                        if (isSessionGroupItem(element)) {
+                            return `group:${element.group.id}`;
+                        }
+                        if (isSessionSection(element)) {
+                            return `section:${element.id}`;
+                        }
+                        if (isSessionShowMore(element)) {
+                            return `show-more:${element.kind}:${element.mode}:${element.sectionId}`;
+                        }
+                        if (isSessionPlaceholder(element)) {
+                            return `placeholder:${element.sectionId}`;
+                        }
+                        if (isSessionChatItem(element)) {
+                            return `chat:${element.session.sessionId}:${( element.chat.resource.toString())}`;
+                        }
+                        return ( element.resource.toString());
+                    },
+                    getGroupId: element => {
+                        if (isSessionGroupItem(element)) {
+                            return NotSelectableGroupId;
+                        }
+                        if (isSessionSection(element)) {
+                            return NotSelectableGroupId;
+                        }
+                        if (isSessionShowMore(element)) {
+                            return NotSelectableGroupId;
+                        }
+                        if (isSessionPlaceholder(element)) {
+                            return NotSelectableGroupId;
+                        }
+                        if (isSessionChatItem(element)) {
+                            return 3;
+                        }
+                        return element.isArchived.get() ? 2 : 1;
+                    }
+                },
+                horizontalScrolling: false,
+                multipleSelectionSupport: true,
+                expandOnlyOnTwistieClick: element => isSessionItem(element),
+                findWidgetEnabled: true,
+                defaultFindMode: TreeFindMode.Filter,
+                findWidgetContainer: this.options.findWidgetContainer,
+                findWidgetStyles: {
+                    ...defaultFindWidgetStyles,
+                    toggleStyles: {
+                        ...defaultToggleStyles,
+                        inputActiveOptionBorder: "transparent"
+                    }
+                },
+                keyboardNavigationLabelProvider: {
+                    getKeyboardNavigationLabel: element => {
+                        if (isSessionGroupItem(element)) {
+                            return element.group.name;
+                        }
+                        if (isSessionSection(element)) {
+                            return element.label;
+                        }
+                        if (isSessionShowMore(element)) {
+                            return element.sectionLabel;
+                        }
+                        if (isSessionPlaceholder(element)) {
+                            return element.label;
+                        }
+                        if (isSessionChatItem(element)) {
+                            return getChatTitle(element.chat);
+                        }
+                        return element.title.get();
+                    }
+                },
+                overrideStyles: this.options.overrideStyles,
+                renderIndentGuides: RenderIndentGuides.None,
+                twistieAdditionalCssClass: element => isSessionItem(element) && getSessionListChats(element).length > 0 ? "session-chat-twistie" : "force-no-twistie"
+            })
+        );
+        const focusedChatItemContext = SessionsListFocusedChatItemContext.bindTo(this.tree.contextKeyService);
+        this.tree.updateOptions({
+            indent: 0,
+            defaultIndent: 0,
+            expandOnDoubleClick: false
+        });
+        const guideOwnerSessionId = element => {
+            if (element && isSessionItem(element)) {
+                return element.sessionId;
+            }
+            if (element && isSessionChatItem(element)) {
+                return element.session.sessionId;
+            }
+            return undefined;
+        };
+        const guideOwnerSessionIds = elements => {
+            const ids = ( new Set());
+            for (const element of elements) {
+                const id = guideOwnerSessionId(element);
+                if (id) {
+                    ids.add(id);
+                }
+            }
+            return ids;
+        };
+        this._register(this.tree.onMouseOver(e => {
+            this.hoveredGuideSessionId.set(guideOwnerSessionId(e.element), undefined);
+        }));
+        this._register(this.tree.onMouseOut(e => {
+            if (guideOwnerSessionId(e.element) === this.hoveredGuideSessionId.get()) {
+                this.hoveredGuideSessionId.set(undefined, undefined);
+            }
+        }));
+        this._register(this.tree.onDidChangeSelection(() => {
+            this.selectedGuideSessionIds.set(guideOwnerSessionIds(this.tree.getSelection()), undefined);
+        }));
+        const updateFocusedGuideSessionIds = () => {
+            this.focusedGuideSessionIds.set(guideOwnerSessionIds(this.tree.getFocus()), undefined);
+            focusedChatItemContext.set(isAncestorOfActiveElement(this.listContainer) && ( this.tree.getFocus().some(item => !!item && isSessionChatItem(item))));
+        };
+        this._register(this.tree.onDidChangeFocus(updateFocusedGuideSessionIds));
+        this._register(this.tree.onDidFocus(updateFocusedGuideSessionIds));
+        this._register(this.tree.onDidBlur(() => {
+            this.focusedGuideSessionIds.set(EMPTY_GUIDE_SESSION_IDS, undefined);
+            focusedChatItemContext.reset();
+        }));
+        this._register(this.tree.onDidOpen(async e => {
+            const element = e.element;
+            if (!element) {
+                return;
+            }
+            if (isSessionShowMore(element)) {
+                if (element.kind === "folders") {
+                    this.expandedMoreFolders = element.mode === "more";
+                } else {
+                    if (element.mode === "more") {
+                        this.expandedSessionGroups.add(element.sectionId);
+                    } else {
+                        this.expandedSessionGroups.delete(element.sectionId);
+                    }
+                }
+                this.update();
+                return;
+            }
+            if (isSessionPlaceholder(element)) {
+                return;
+            }
+            if (isSessionChatItem(element)) {
+                if (this.options.canOpenSession && !(await this.options.canOpenSession(element.session))) {
+                    return;
+                }
+                this.markRead(element.session);
+                const isLeftClick = isMouseEvent(e.browserEvent) && e.browserEvent.button === 0;
+                const preserveFocus = isLeftClick ? false : (e.editorOptions.preserveFocus ?? false);
+                if (this.options.onChatOpen) {
+                    this.options.onChatOpen(element.session, element.chat, preserveFocus, e.sideBySide);
+                } else {
+                    this._sessionsService.openChat(element.session, element.chat.resource, {
+                        preserveFocus
+                    }).catch(onUnexpectedError);
+                }
+                return;
+            }
+            if (isSessionSection(element) && element.id === AUTOMATIONS_SECTION_ID) {
+                this.tree.setSelection([]);
+                this.commandService.executeCommand("sessionsView.manageAutomations");
+                return;
+            }
+            if (!isSessionSection(element) && !isSessionGroupItem(element)) {
+                if (this.options.canOpenSession && !(await this.options.canOpenSession(element))) {
+                    return;
+                }
+                this.markRead(element);
+                const isLeftClick = isMouseEvent(e.browserEvent) && e.browserEvent.button === 0;
+                const preserveFocus = isLeftClick ? false : (e.editorOptions.preserveFocus ?? false);
+                this.options.onSessionOpen(element.resource, preserveFocus, e.sideBySide);
+                if (this._listVoicePlaybackService.hasPendingResponse(element.resource)) {
+                    this.commandService.executeCommand("_chat.voice.activateSession", ( element.resource.toString()));
+                }
+            }
+        }));
+        this._register(sessionRenderer.onDidChangeItemHeight(session => {
+            if (this.tree.hasElement(session)) {
+                this.tree.updateElementHeight(session, delegate.getHeight(session));
+            }
+        }));
+        this._register(chatRenderer.onDidChangeItemHeight(chatItem => {
+            if (this.tree.hasElement(chatItem)) {
+                this.tree.updateElementHeight(chatItem, delegate.getHeight(chatItem));
+            }
+        }));
+        const phoneKeys = ( new Set([IsPhoneLayoutContext.key]));
+        const automationKeys = ( new Set([ChatAutomationsEnabledContext.key]));
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(automationKeys)) {
+                this.update();
+            }
+            if (!e.affectsSome(phoneKeys)) {
+                return;
+            }
+            const updateNodeHeights = node => {
+                if (node.element && (isSessionItem(node.element) || isSessionChatItem(node.element))) {
+                    this.tree.updateElementHeight(node.element, delegate.getHeight(node.element));
+                }
+                for (const child of node.children) {
+                    updateNodeHeights(child);
+                }
+            };
+            updateNodeHeights(this.tree.getNode());
+        }));
+        this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
+        this._register(this.tree.onDidChangeCollapseState(e => {
+            const element = e.node.element;
+            if (element && isSessionGroupItem(element)) {
+                this._groupRenderer.updateCollapseState(element, e.node.collapsed);
+                if (!this.suspendCollapseStatePersistence) {
+                    this.saveSectionCollapseState(`group:${element.group.id}`, e.node.collapsed);
+                }
+            } else if (element && isSessionSection(element)) {
+                sectionRenderer.updateCollapseState(element, e.node.collapsed);
+                if (!this.suspendCollapseStatePersistence) {
+                    this.saveSectionCollapseState(element.id, e.node.collapsed);
+                }
+            }
+        }));
+        let isFindOpen = false;
+        let findPattern = "";
+        const updateFindPatternState = () => {
+            const hasFindPattern = isFindOpen && findPattern.length > 0;
+            if (hasFindPattern !== this.hasFindPattern) {
+                this.hasFindPattern = hasFindPattern;
+                this.update();
+            }
+        };
+        this._register(this.tree.onDidChangeFindOpenState(open => {
+            isFindOpen = open;
+            this._onDidChangeFindOpenState.fire(open);
+            updateFindPatternState();
+        }));
+        this._register(this.tree.onDidChangeFindPattern(pattern => {
+            findPattern = pattern;
+            updateFindPatternState();
+        }));
+        this._register(this._sessionsManagementService.onDidChangeSessions(e => {
+            if (this.visible) {
+                this.refresh();
+            }
+            if (e.removed.length > 0) {
+                this._sessionSectionOrderService.retain(this.liveSectionOrderIds());
+            }
+        }));
+        this._register(this._sessionsListModelService.onDidChange(() => {
+            if (this.visible) {
+                this.update();
+            }
+        }));
+        this._register(this._sessionGroupsService.onDidChange(e => {
+            if (this.visible) {
+                this.update();
+            }
+            if (e.groupsChanged) {
+                this._sessionSectionOrderService.retain(this.liveSectionOrderIds());
+            }
+        }));
+        this._register(this._sessionSectionOrderService.onDidChange(() => {
+            if (this.visible) {
+                this.update();
+            }
+        }));
+        this._register(this._agentHostFilterService.onDidChange(() => {
+            if (this.visible) {
+                this.update();
+            }
+        }));
+        this._register(autorun(reader => {
+            const activeSession = this._sessionsService.activeSession.read(reader);
+            activeSession?.activeChat.read(reader);
+            this.activeSessionUpdate.value = scheduleAtNextAnimationFrame(getWindow(this.listContainer), () => {
+                if (this.visible) {
+                    this.update();
+                    this.syncActiveChatSelection(activeSession);
+                }
+            });
+        }));
+        const assignmentRefetchSignal = observableSignalFromEvent(this, this.assignmentService.onDidRefetchAssignments);
+        this._register(autorun(reader => {
+            assignmentRefetchSignal.read(reader);
+            this.updateSessionGroupLimit();
+        }));
+        this.refresh();
+        this.syncActiveChatSelection(this._sessionsService.activeSession.get());
+    }
+    updateSessionGroupLimit() {
+        this.assignmentService.getTreatment(SessionsList_1.SESSION_GROUP_LIMIT_TREATMENT).then(value => {
+            const limit = typeof value === "number" && Number.isInteger(value) && value > 0 ? value : SessionsList_1.DEFAULT_SESSION_GROUP_LIMIT;
+            if (this.sessionGroupLimit.get() !== limit) {
+                this.sessionGroupLimit.set(limit, undefined);
+                if (this.visible) {
+                    this.update();
+                }
+            }
+        });
+    }
+    refresh() {
+        this.sessions = this._sessionsManagementService.getSessions();
+        let initialized = false;
+        this.sessionChatsObserver.value = autorun(reader => {
+            for (const session of this.sessions) {
+                getSessionListChats(session, reader);
+            }
+            if (initialized && this.visible) {
+                this.update();
+            }
+            initialized = true;
+        });
+        this.automationSessions.set(this.sessions, undefined);
+        for (const session of this.sessions) {
+            this._sessionsListModelService.migrateLegacyReadState(session);
+        }
+        this.update();
+    }
+    update(expandAll) {
+        const activeSession = this._sessionsService.activeSession.get();
+        const archiveOnboardingSession = this.archiveOnboardingSession.get();
+        let filtered = this.sessions.filter(session => !isAutomationSession(session));
+        const scopedProviderIds = this._agentHostFilterService.selectedHost?.providerIds;
+        if (scopedProviderIds) {
+            const scoped = ( new Set(scopedProviderIds));
+            filtered = filtered.filter(s => ( scoped.has(s.providerId)));
+        }
+        if (this.excludedSessionTypes.size > 0) {
+            filtered = filtered.filter(s => !( this.excludedSessionTypes.has(s.sessionType)));
+        }
+        if (this.excludedStatuses.size > 0) {
+            filtered = filtered.filter(s => !( this.excludedStatuses.has(s.status.get())));
+        }
+        if (this._excludeArchived) {
+            filtered = filtered.filter(s => !s.isArchived.get());
+        }
+        if (this._excludeRead) {
+            filtered = filtered.filter(s => !s.isRead.get());
+        }
+        for (const revealedSession of [activeSession, archiveOnboardingSession]) {
+            if (revealedSession && !( filtered.some(s => s.sessionId === revealedSession.sessionId))) {
+                const match = this.sessions.find(s => s.sessionId === revealedSession.sessionId && !isAutomationSession(s));
+                if (match) {
+                    filtered = [...filtered, match];
+                }
+            }
+        }
+        const grouping = this.options.grouping();
+        const sorting = this.options.sorting();
+        const sortKeyForGrouping = (s, srt) => this._sessionsListModelService.getSortKey(s, sortingToMode(srt));
+        const groupedMembers = ( new Map());
+        const groupedRegularIds = ( new Set());
+        for (const s of filtered) {
+            const group = this.getRenderedSessionGroup(s);
+            if (group) {
+                let members = groupedMembers.get(group.id);
+                if (!members) {
+                    members = [];
+                    groupedMembers.set(group.id, members);
+                }
+                members.push(s);
+                groupedRegularIds.add(s.sessionId);
+            }
+        }
+        const forSections = groupedRegularIds.size > 0 ? filtered.filter(s => !( groupedRegularIds.has(s.sessionId))) : filtered;
+        const groupItemsById = ( new Map());
+        for (const group of this._sessionGroupsService.getGroups()) {
+            const members = groupedMembers.get(group.id) ?? [];
+            const sortedMembers = sortSessions(members, sorting, sortKeyForGrouping);
+            groupItemsById.set(group.id, {
+                group,
+                sessions: sortedMembers,
+                isEmpty: this._sessionGroupsService.getSessionIdsInGroup(group.id).length === 0,
+                editing: group.id === this._editingGroupId
+            });
+        }
+        const defaultGroupIds = [...( groupItemsById.values())].sort((a, b) => b.group.createdAt - a.group.createdAt).map(item => `group:${item.group.id}`);
+        const sections = groupSessionsForList(
+            forSections,
+            grouping,
+            sorting,
+            session => this.isSessionPinned(session),
+            (s, srt) => this._sessionsListModelService.getSortKey(s, sortingToMode(srt)),
+            getChatSessionArchivedSectionLabel(getChatSessionArchiveActionWording(this.configurationService))
+        );
+        const hasRecentSessions = ( sections.some(s => s.id === "recent" && s.sessions.length > 0));
+        const showEmptyDefaultGroups = this.configurationService.getValue(SESSIONS_LIST_SHOW_EMPTY_DEFAULT_GROUPS_SETTING);
+        if (showEmptyDefaultGroups && this._someProviderSupportsQuickChats() && !( sections.some(s => s.id === QUICK_CHATS_SECTION_ID))) {
+            sections.push({
+                id: QUICK_CHATS_SECTION_ID,
+                label: ( localize(4816, "Chats")),
+                sessions: []
+            });
+        }
+        const partitionFolders = grouping === SessionsGrouping.Workspace && !this.hasFindPattern && this.workspaceGroupCapped;
+        const moreFolderSectionIds = ( new Set());
+        if (partitionFolders) {
+            const workspaceSections = sections.filter(s => s.id.startsWith("workspace:"));
+            if (workspaceSections.length > 0) {
+                const now = Date.now();
+                const isRecent = section => ( section.sessions.some(s => s.updatedAt.get().getTime() >= now - FOUR_DAYS_MS));
+                const isOpenWindow = section => !!this.openWindowSourceFolder && ( section.sessions.some(s => sessionMatchesFolder(s, this.openWindowSourceFolder)));
+                const meetsCriteria = section => isRecent(section) || isOpenWindow(section);
+                let anyMeets = false;
+                for (const section of workspaceSections) {
+                    if (meetsCriteria(section)) {
+                        anyMeets = true;
+                        break;
+                    }
+                }
+                let fallbackId;
+                if (!anyMeets) {
+                    let bestTime = -Infinity;
+                    for (const section of workspaceSections) {
+                        for (const s of section.sessions) {
+                            const t = s.updatedAt.get().getTime();
+                            if (t > bestTime) {
+                                bestTime = t;
+                                fallbackId = section.id;
+                            }
+                        }
+                    }
+                }
+                for (const section of workspaceSections) {
+                    if (!meetsCriteria(section) && section.id !== fallbackId && !this._sessionSectionOrderService.isPromoted(section.id) && !( section.sessions.some(session => session.sessionId === archiveOnboardingSession?.sessionId))) {
+                        moreFolderSectionIds.add(section.id);
+                    }
+                }
+            }
+        }
+        const children = [];
+        const sessionGroupLimit = this.sessionGroupLimit.get();
+        const toSessionChildren = sessions => sessions.map(session => {
+            const chats = getSessionListChats(session);
+            return {
+                element: session,
+                collapsible: chats.length > 0,
+                collapsed: ObjectTreeElementCollapseState.PreserveOrExpanded,
+                children: chats.length > 0 ? chats.map(chat => ({
+                    element: ( new SessionChatItem(session, chat))
+                })) : undefined
+            };
+        });
+        const renderSessionChildren = (sessions, sectionId, sectionLabel, enabled) => {
+            const limited = limitSessionsForList(sessions, sessionGroupLimit, {
+                enabled,
+                expanded: ( this.expandedSessionGroups.has(sectionId)),
+                sectionId,
+                sectionLabel,
+                revealSessionId: archiveOnboardingSession?.sessionId
+            });
+            const children = toSessionChildren(limited.sessions);
+            if (limited.showMore) {
+                children.push({
+                    element: limited.showMore
+                });
+            }
+            return children;
+        };
+        const renderSection = section => {
+            if (section.id === AUTOMATIONS_SECTION_ID) {
+                return {
+                    element: section,
+                    children: [],
+                    collapsible: false
+                };
+            }
+            const isWorkspaceGroup = grouping === SessionsGrouping.Workspace && section.id.startsWith("workspace:");
+            const limitSessions = isWorkspaceGroup && !this.hasFindPattern && this.workspaceGroupCapped;
+            let sectionChildren = renderSessionChildren(section.sessions, section.id, section.label, limitSessions);
+            if (section.id === QUICK_CHATS_SECTION_ID && section.sessions.length === 0) {
+                sectionChildren = [{
+                    element: {
+                        placeholder: true,
+                        sectionId: section.id,
+                        label: ( localize(4817, "No chats"))
+                    }
+                }];
+            }
+            let defaultCollapsed = ObjectTreeElementCollapseState.PreserveOrExpanded;
+            if (grouping === SessionsGrouping.Date && hasRecentSessions) {
+                const olderSections = ["older", "archived"];
+                if (olderSections.includes(section.id)) {
+                    defaultCollapsed = ObjectTreeElementCollapseState.PreserveOrCollapsed;
+                }
+            }
+            if (section.id === "archived") {
+                defaultCollapsed = ObjectTreeElementCollapseState.PreserveOrCollapsed;
+            }
+            if (section.id === "pinned" || section.id === QUICK_CHATS_SECTION_ID) {
+                defaultCollapsed = ObjectTreeElementCollapseState.PreserveOrCollapsed;
+            }
+            return {
+                element: section,
+                collapsible: true,
+                collapsed: this.getSavedCollapseState(section.id) ?? defaultCollapsed,
+                children: sectionChildren
+            };
+        };
+        const renderGroup = groupItem => {
+            const sectionId = `group:${groupItem.group.id}`;
+            const groupChildren = groupItem.sessions.length === 0 ? [{
+                element: {
+                    placeholder: true,
+                    sectionId,
+                    label: ( localize(4818, "No session")),
+                    hover: ( localize(
+                        4819,
+                        "Use Add to Group from a session's context menu, or drag it into this group."
+                    ))
+                }
+            }] : renderSessionChildren(
+                groupItem.sessions,
+                sectionId,
+                groupItem.group.name,
+                !this.hasFindPattern && this.workspaceGroupCapped
+            );
+            return {
+                element: groupItem,
+                collapsible: true,
+                collapsed: this.getSavedCollapseState(sectionId) ?? ObjectTreeElementCollapseState.PreserveOrExpanded,
+                children: groupChildren
+            };
+        };
+        if (this.contextKeyService.getContextKeyValue(ChatAutomationsEnabledContext.key)) {
+            void this.automationsNewBadgeState.initialize().catch(onUnexpectedError);
+            children.push(renderSection({
+                id: AUTOMATIONS_SECTION_ID,
+                label: ( localize(4820, "Automations")),
+                sessions: []
+            }));
+        }
+        const pinnedSection = sections.find(s => s.id === "pinned");
+        if (pinnedSection) {
+            children.push(renderSection(pinnedSection));
+        }
+        const quickChatsSection = sections.find(s => s.id === QUICK_CHATS_SECTION_ID);
+        if (quickChatsSection) {
+            children.push(renderSection(quickChatsSection));
+        }
+        const renderGroupById = id => {
+            const groupItem = groupItemsById.get(id.slice("group:".length));
+            if (groupItem) {
+                children.push(renderGroup(groupItem));
+            }
+        };
+        if (grouping === SessionsGrouping.Date) {
+            const resolvedGroupIds = this._sessionSectionOrderService.resolveOrder(defaultGroupIds);
+            this._topLevelOrder = resolvedGroupIds;
+            for (const id of resolvedGroupIds) {
+                renderGroupById(id);
+            }
+            for (const section of sections) {
+                if (section.id === "pinned" || section.id === "archived" || section.id === QUICK_CHATS_SECTION_ID) {
+                    continue;
+                }
+                children.push(renderSection(section));
+            }
+            const archived = sections.find(s => s.id === "archived");
+            if (archived) {
+                children.push(renderSection(archived));
+            }
+        } else {
+            const workspaceSections = sections.filter(s => s.id.startsWith("workspace:"));
+            const sectionById = ( new Map(workspaceSections.map(s => [s.id, s])));
+            const primaryWorkspaceIds = workspaceSections.filter(s => !( moreFolderSectionIds.has(s.id))).map(s => s.id);
+            const defaultOrder = [...defaultGroupIds, ...primaryWorkspaceIds];
+            const resolvedIds = this._sessionSectionOrderService.resolveOrder(defaultOrder);
+            this._topLevelOrder = resolvedIds;
+            for (const id of resolvedIds) {
+                if (id.startsWith("group:")) {
+                    renderGroupById(id);
+                } else {
+                    const section = sectionById.get(id);
+                    if (section) {
+                        children.push(renderSection(section));
+                    }
+                }
+            }
+            const moreFolderSections = workspaceSections.filter(s => ( moreFolderSectionIds.has(s.id)));
+            if (moreFolderSections.length > 0) {
+                if (this.expandedMoreFolders) {
+                    for (const section of moreFolderSections) {
+                        children.push(renderSection(section));
+                    }
+                    children.push({
+                        element: {
+                            showMore: true,
+                            kind: "folders",
+                            mode: "less",
+                            sectionId: SHOW_MORE_FOLDERS_LABEL,
+                            sectionLabel: SHOW_MORE_FOLDERS_LABEL,
+                            remainingCount: 0
+                        }
+                    });
+                } else {
+                    children.push({
+                        element: {
+                            showMore: true,
+                            kind: "folders",
+                            mode: "more",
+                            sectionId: SHOW_MORE_FOLDERS_LABEL,
+                            sectionLabel: SHOW_MORE_FOLDERS_LABEL,
+                            remainingCount: moreFolderSections.length
+                        }
+                    });
+                }
+            }
+            const archivedSection = sections.find(s => s.id === "archived");
+            if (archivedSection) {
+                children.push(renderSection(archivedSection));
+            }
+        }
+        this.tree.setChildren(null, children);
+        this.reconcileChatApprovalHeights();
+        this._onDidUpdate.fire();
+    }
+    reconcileChatApprovalHeights() {
+        const chatItems = [];
+        const collect = node => {
+            if (node.element && isSessionChatItem(node.element)) {
+                chatItems.push(node.element);
+            }
+            for (const child of node.children) {
+                collect(child);
+            }
+        };
+        collect(this.tree.getNode());
+        if (chatItems.length === 0) {
+            this.chatApprovalHeightReconcile.clear();
+            return;
+        }
+        this.chatApprovalHeightReconcile.value = autorun(reader => {
+            for (const chatItem of chatItems) {
+                this._approvalModel.getApproval(chatItem.chat.resource).read(reader);
+                if (this.tree.hasElement(chatItem)) {
+                    this.tree.updateElementHeight(chatItem, this._delegate.getHeight(chatItem));
+                }
+            }
+        });
+    }
+    syncActiveChatSelection(activeSession) {
+        if (!activeSession) {
+            return;
+        }
+        const session = this.sessions.find(candidate => candidate.sessionId === activeSession.sessionId);
+        if (!session || !this.tree.hasElement(session)) {
+            return;
+        }
+        const activeChat = activeSession.activeChat.get();
+        const chatItem = this.tree.getNode(session).children.map(node => node.element).find(
+            element => !!element && isSessionChatItem(element) && this.uriIdentityService.extUri.isEqual(element.chat.resource, activeChat.resource)
+        );
+        if (!chatItem || !isSessionChatItem(chatItem)) {
+            this.tree.setFocus([session]);
+            this.tree.setSelection([session]);
+            return;
+        }
+        this.tree.expand(session);
+        this.tree.reveal(chatItem, 0.5);
+        this.tree.setFocus([chatItem]);
+        this.tree.setSelection([chatItem]);
+    }
+    getVisibleSessions() {
+        const sessions = ( new Set(this.sessions));
+        const visibleSessions = [];
+        const collect = node => {
+            if (!node.visible) {
+                return;
+            }
+            if (node.element && ( sessions.has(node.element))) {
+                visibleSessions.push(node.element);
+            }
+            if (node.collapsed) {
+                return;
+            }
+            for (const child of node.children) {
+                collect(child);
+            }
+        };
+        const root = this.tree.getNode();
+        for (const child of root.children) {
+            collect(child);
+        }
+        return visibleSessions;
+    }
+    reveal(sessionResource) {
+        const resourceStr = ( sessionResource.toString());
+        for (const session of this.sessions) {
+            if (( session.resource.toString()) === resourceStr) {
+                if (this.tree.hasElement(session)) {
+                    if (this.tree.getRelativeTop(session) === null) {
+                        this.tree.reveal(session, 0.5);
+                    }
+                    this.tree.setFocus([session]);
+                    this.tree.setSelection([session]);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    revealArchiveAction(session) {
+        this.customViewService.hideCustomView();
+        this.closeFind();
+        this.archiveOnboardingSession.set(session, undefined);
+        const release = toDisposable(() => {
+            this.archiveOnboardingSession.set(undefined, undefined);
+            if (!this._store.isDisposed) {
+                this.update();
+            }
+        });
+        try {
+            this.update();
+            if (!this.reveal(session.resource)) {
+                throw ( new Error(( localize(4821, "The session could not be revealed in the sessions list. Try again."))));
+            }
+        } catch (error) {
+            release.dispose();
+            throw error;
+        }
+        return {
+            targetId: getSessionArchiveOnboardingTargetId(session),
+            dispose: () => release.dispose()
+        };
+    }
+    clearFocus() {
+        this.tree.setFocus([]);
+        this.tree.setSelection([]);
+    }
+    hasFocusOrSelection() {
+        return this.tree.getFocus().length > 0 || this.tree.getSelection().length > 0;
+    }
+    getFocusedSessions() {
+        if (!isAncestorOfActiveElement(this.listContainer)) {
+            return undefined;
+        }
+        const focusedSession = this.tree.getFocus().find(item => !!item && isSessionItem(item));
+        return focusedSession ? this.getMultiSelectedSessions(focusedSession) : [];
+    }
+    getFocusedChatItem() {
+        if (!isAncestorOfActiveElement(this.listContainer)) {
+            return undefined;
+        }
+        return this.tree.getFocus().find(item => !!item && isSessionChatItem(item));
+    }
+    setVisible(visible) {
+        if (this.visible === visible) {
+            return;
+        }
+        this.visible = visible;
+        if (this.visible) {
+            this.refresh();
+        }
+    }
+    layout(height, width) {
+        this.tree.layout(height, width);
+    }
+    focus() {
+        this.tree.domFocus();
+        if (this.tree.getFocus().length === 0) {
+            this.tree.focusFirst();
+        }
+    }
+    openFind() {
+        this.tree.openFind();
+    }
+    closeFind() {
+        this.tree.closeFind();
+    }
+    isReorderable(session) {
+        return !session.isArchived.get();
+    }
+    canReorderOnto(dragged, target) {
+        const targetPinned = this.isSessionPinned(target);
+        if (( dragged.some(s => this.isSessionPinned(s) !== targetPinned))) {
+            return false;
+        }
+        if (targetPinned) {
+            return true;
+        }
+        const targetGroup = this._sessionGroupsService.getGroupOfSession(target.sessionId);
+        if (( dragged.some(
+            s => this._sessionGroupsService.getGroupOfSession(s.sessionId) !== targetGroup
+        ))) {
+            return false;
+        }
+        if (targetGroup === undefined && this.options.grouping() === SessionsGrouping.Workspace) {
+            const targetLabel = sessionWorkspaceLabel(target);
+            return dragged.every(s => sessionWorkspaceLabel(s) === targetLabel);
+        }
+        return true;
+    }
+    reorderSessions(dragged, target, position) {
+        const mode = sortingToMode(this.options.sorting());
+        const grouping = this.options.grouping();
+        const getKey = s => this._sessionsListModelService.getSortKey(s, mode);
+        const targetPinned = this.isSessionPinned(target);
+        let scope = this.getVisibleSessions().filter(s => this.isReorderable(s));
+        scope = scope.filter(s => this.isSessionPinned(s) === targetPinned);
+        if (!targetPinned) {
+            const targetGroup = this._sessionGroupsService.getGroupOfSession(target.sessionId);
+            scope = scope.filter(
+                s => this._sessionGroupsService.getGroupOfSession(s.sessionId) === targetGroup
+            );
+            if (targetGroup === undefined && grouping === SessionsGrouping.Workspace) {
+                const targetLabel = sessionWorkspaceLabel(target);
+                scope = scope.filter(s => sessionWorkspaceLabel(s) === targetLabel);
+            }
+        }
+        const draggedIds = ( new Set(dragged.map(s => s.sessionId)));
+        const draggedOrdered = scope.filter(s => ( draggedIds.has(s.sessionId)));
+        if (draggedOrdered.length === 0) {
+            return;
+        }
+        const remaining = scope.filter(s => !( draggedIds.has(s.sessionId)));
+        const targetIndex = remaining.findIndex(s => s.sessionId === target.sessionId);
+        if (targetIndex === -1) {
+            return;
+        }
+        const insertIndex = position === "before" ? targetIndex : targetIndex + 1;
+        const above = remaining[insertIndex - 1];
+        const below = remaining[insertIndex];
+        const {
+            set,
+            clear
+        } = computeReorderSortChanges({
+            draggedIds: draggedOrdered.map(s => s.sessionId),
+            naturalKeys: draggedOrdered.map(s => this._sessionsListModelService.getNaturalSortKey(s, mode)),
+            aboveKey: above ? getKey(above) : undefined,
+            belowKey: below ? getKey(below) : undefined,
+            now: Date.now(),
+            fallbackStep: SORT_FALLBACK_STEP_MS
+        });
+        this._sessionsListModelService.applySortChanges(mode, set, clear);
+    }
+    createGroupFromSessions(sessions) {
+        const groupSessions = sessions.filter(session => !session.isArchived.get());
+        if (groupSessions.length === 0) {
+            return;
+        }
+        this.createGroup(groupSessions);
+    }
+    createGroup(groupSessions) {
+        this._sessionsListModelService.unpinSessions(groupSessions);
+        const group = this._sessionGroupsService.createGroup(( localize(4822, "New Group")), groupSessions.map(s => s.sessionId));
+        this._editingGroupId = group.id;
+        this.update();
+        this.revealGroup(group.id);
+    }
+    revealGroup(groupId) {
+        const root = this.tree.getNode();
+        for (const node of root.children) {
+            const element = node.element;
+            if (element && isSessionGroupItem(element) && element.group.id === groupId) {
+                if (this.tree.hasElement(element) && this.tree.getRelativeTop(element) === null) {
+                    this.tree.reveal(element, 0.5);
+                }
+                return;
+            }
+        }
+    }
+    beginRenameGroup(groupId) {
+        if (!this._sessionGroupsService.getGroup(groupId)) {
+            return;
+        }
+        this._editingGroupId = groupId;
+        this.update();
+    }
+    addSessionsToGroup(sessions, groupId, target, position) {
+        const groupSessions = sessions.filter(session => !session.isArchived.get());
+        this._sessionsListModelService.unpinSessions(groupSessions);
+        this._sessionGroupsService.addToGroup(groupSessions.map(s => s.sessionId), groupId);
+        if (target && position) {
+            this.reorderSessions(groupSessions, target, position);
+        }
+    }
+    removeSessionsFromGroup(sessions, target, position) {
+        const groupedSessions = sessions.filter(
+            session => this._sessionGroupsService.getGroupOfSession(session.sessionId) !== undefined
+        );
+        if (groupedSessions.length === 0) {
+            return;
+        }
+        for (const session of groupedSessions) {
+            this._sessionGroupsService.removeFromGroup(session.sessionId);
+        }
+        if (target && position) {
+            this.reorderSessions(groupedSessions, target, position);
+        }
+    }
+    getWorkspaceSectionIdOfSession(session) {
+        if (this.options.grouping() !== SessionsGrouping.Workspace || session.isArchived.get() || this.isSessionPinned(session) || isQuickChatSession(session)) {
+            return undefined;
+        }
+        return `workspace:${sessionWorkspaceLabel(session)}`;
+    }
+    commitGroupEdit(group, name) {
+        this._editingGroupId = undefined;
+        const trimmed = name.trim();
+        if (trimmed) {
+            this._sessionGroupsService.renameGroup(group.id, trimmed);
+        }
+        this.update();
+    }
+    cancelGroupEdit(_group) {
+        this._editingGroupId = undefined;
+        this.update();
+    }
+    reorderSection(draggedId, targetId, position, isWorkspace) {
+        this._sessionSectionOrderService.reorder(
+            this._topLevelOrder,
+            draggedId,
+            targetId,
+            position,
+            isWorkspace ? draggedId : undefined
+        );
+    }
+    getGroupsInDisplayOrder() {
+        const groups = this._sessionGroupsService.getGroups();
+        const byId = ( new Map(groups.map(g => [`group:${g.id}`, g])));
+        const defaultIds = [...groups].sort((a, b) => b.createdAt - a.createdAt).map(g => `group:${g.id}`);
+        return this._sessionSectionOrderService.resolveOrder(defaultIds).map(id => byId.get(id)).filter(g => !!g);
+    }
+    liveSectionOrderIds() {
+        const ids = ( new Set());
+        for (const group of this._sessionGroupsService.getGroups()) {
+            ids.add(`group:${group.id}`);
+        }
+        for (const session of this._sessionsManagementService.getSessions()) {
+            ids.add(`workspace:${sessionWorkspaceLabel(session)}`);
+        }
+        return ids;
+    }
+    setDropTargetHeader(header) {
+        const current = this._dropTargetHeader;
+        if (current?.kind === header?.kind && current?.id === header?.id) {
+            this.toggleDropTargetHeader(header, header !== undefined);
+            return;
+        }
+        this.toggleDropTargetHeader(current, false);
+        this._dropTargetHeader = header;
+        this.toggleDropTargetHeader(header, true);
+    }
+    toggleDropTargetHeader(header, active) {
+        if (!header) {
+            return;
+        }
+        if (header.kind === "group") {
+            this._groupRenderer.setDropTarget(header.id, active);
+        } else {
+            this._sectionRenderer.setDropTarget(header.id, active);
+        }
+    }
+    getMultiSelectedSessions(session) {
+        const selection = this.tree.getSelection().filter(s => !!s && isSessionItem(s));
+        return selection.includes(session) ? [session, ...selection.filter(s => s !== session)] : [session];
+    }
+    onContextMenu(e) {
+        const element = e.element;
+        if (element && isSessionChatItem(element)) {
+            this.showChatContextMenu(element, e.anchor);
+            return;
+        }
+        if (!element || isSessionSection(element) || isSessionShowMore(element) || isSessionPlaceholder(element)) {
+            this.showCreateGroupContextMenu(e.anchor);
+            return;
+        }
+        if (isSessionGroupItem(element)) {
+            this.showGroupContextMenu(element, e.anchor);
+            return;
+        }
+        const selectedSessions = this.getMultiSelectedSessions(element);
+        const inGroup = this._sessionGroupsService.getGroupOfSession(element.sessionId) !== undefined;
+        const contextOverlay = [
+            [IsSessionPinnedContext.key, this.isSessionPinned(element)],
+            [SessionIsArchivedContext.key, element.isArchived.get()],
+            [SessionIsReadContext.key, element.isRead.get()],
+            [
+                SessionItemHasBranchNameContext.key,
+                !!element.workspace.get()?.folders[0]?.gitRepository?.branchName?.trim()
+            ],
+            [SessionItemInGroupContext.key, inGroup],
+            [SessionTypeContext.key, element.sessionType],
+            [SessionProviderIdContext.key, element.providerId],
+            [
+                SessionSupportsRenameContext.key,
+                element.capabilities.get().supportsRename ?? false
+            ],
+            [
+                SessionSupportsDeleteContext.key,
+                element.capabilities.get().supportsDelete ?? false
+            ],
+            [
+                SessionHasPullRequestContext.key,
+                !!element.workspace.get()?.folders[0]?.gitRepository?.gitHubInfo.get()?.pullRequest
+            ]
+        ];
+        const disposables = ( new DisposableStore());
+        const menu = disposables.add(this.menuService.createMenu(
+            SessionItemContextMenuId,
+            this.contextKeyService.createOverlay(contextOverlay)
+        ));
+        const marshalledArg = {
+            $mid: MarshalledId.AgentSessionContext,
+            session: {
+                resource: element.resource
+            },
+            sessions: selectedSessions.map(s => ({
+                resource: s.resource
+            }))
+        };
+        const wrapForExtensions = action => {
+            if (!(action instanceof MenuItemAction) || !action.item.source) {
+                return action;
+            }
+            return toAction({
+                id: action.id,
+                label: action.label,
+                class: action.class,
+                enabled: action.enabled,
+                tooltip: action.tooltip,
+                checked: action.checked,
+                run: () => this.commandService.executeCommand(action.id, marshalledArg)
+            });
+        };
+        const baseActions = Separator.join(...menu.getActions({
+            arg: selectedSessions,
+            shouldForwardArgs: true
+        }).map(([, actions]) => actions.map(wrapForExtensions)));
+        const groupActions = this.getGroupSessionActions(selectedSessions);
+        const actions = groupActions.length > 0 ? [...baseActions, ( new Separator()), ...groupActions] : baseActions;
+        if (actions.length === 0) {
+            disposables.dispose();
+            return;
+        }
+        this.contextMenuService.showContextMenu({
+            getActions: () => actions,
+            getAnchor: () => e.anchor,
+            getKeyBinding: action => this.keybindingService.lookupKeybinding(action.id) ?? undefined,
+            onHide: () => disposables.dispose()
+        });
+    }
+    showChatContextMenu(element, anchor) {
+        const capabilities = getChatCapabilities(element.chat, element.session, undefined);
+        const contextKeyService = this.contextKeyService.createOverlay([
+            [SessionChatItemCanRenameContext.key, capabilities.canRename],
+            [SessionChatItemCanDeleteContext.key, capabilities.canDelete],
+            [
+                SessionChatItemIsUntitledContext.key,
+                element.chat.status.get() === SessionStatus.Untitled
+            ],
+            [SessionProviderIdContext.key, element.session.providerId]
+        ]);
+        const menu = this.menuService.createMenu(Menus.SessionChatItemContext, contextKeyService);
+        const actions = Separator.join(...menu.getActions({
+            arg: element,
+            shouldForwardArgs: true
+        }).map(([, groupActions]) => groupActions));
+        if (actions.length === 0) {
+            menu.dispose();
+            return;
+        }
+        this.contextMenuService.showContextMenu({
+            getActions: () => actions,
+            getAnchor: () => anchor,
+            getKeyBinding: action => this.keybindingService.lookupKeybinding(action.id) ?? undefined,
+            onHide: () => menu.dispose()
+        });
+    }
+    getGroupSessionActions(selected) {
+        const actions = [];
+        if (( selected.some(session => session.isArchived.get()))) {
+            return actions;
+        }
+        actions.push(this.getCreateGroupAction(selected));
+        const currentGroupIds = ( new Set(
+            selected.map(s => this._sessionGroupsService.getGroupOfSession(s.sessionId))
+        ));
+        const currentGroupId = currentGroupIds.size === 1 ? [...currentGroupIds][0] : undefined;
+        const targetGroups = this.getGroupsInDisplayOrder().filter(g => g.id !== currentGroupId);
+        if (targetGroups.length > 0) {
+            const subActions = targetGroups.map(g => toAction({
+                id: `sessions.addToGroup.${g.id}`,
+                label: g.name,
+                run: () => this.addSessionsToGroup(selected, g.id)
+            }));
+            const label = currentGroupId !== undefined ? ( localize(4823, "Move to Group")) : ( localize(4824, "Add to Group"));
+            actions.push(( new SubmenuAction("sessions.addToGroupSubmenu", label, subActions)));
+        }
+        if (currentGroupId !== undefined) {
+            actions.push(toAction({
+                id: "sessions.removeFromGroup",
+                label: ( localize(4825, "Remove from Group")),
+                run: () => {
+                    for (const session of selected) {
+                        this._sessionGroupsService.removeFromGroup(session.sessionId);
+                    }
+                }
+            }));
+        }
+        return actions;
+    }
+    getCreateGroupAction(sessions) {
+        return toAction({
+            id: "sessions.createGroup",
+            label: ( localize(4826, "Create Group")),
+            run: () => {
+                if (sessions) {
+                    this.createGroupFromSessions(sessions);
+                } else {
+                    this.createGroup([]);
+                }
+            }
+        });
+    }
+    showCreateGroupContextMenu(anchor) {
+        this.contextMenuService.showContextMenu({
+            getActions: () => [this.getCreateGroupAction()],
+            getAnchor: () => anchor
+        });
+    }
+    showGroupContextMenu(groupItem, anchor) {
+        const actions = [this.getCreateGroupAction(), ( new Separator()), toAction({
+            id: "sessions.renameGroupAction",
+            label: ( localize(4827, "Rename...")),
+            run: () => this.beginRenameGroup(groupItem.group.id)
+        }), toAction({
+            id: "sessions.deleteGroupAction",
+            label: ( localize(4828, "Delete Group")),
+            run: () => this._sessionGroupsService.deleteGroup(groupItem.group.id)
+        })];
+        this.contextMenuService.showContextMenu({
+            getActions: () => actions,
+            getAnchor: () => anchor
+        });
+    }
+    resetSectionCollapseState() {
+        this.storageService.remove(SessionsList_1.SECTION_COLLAPSE_STATE_KEY, StorageScope.PROFILE);
+    }
+    pinSession(session) {
+        this._sessionsListModelService.pinSession(session);
+    }
+    pinSessions(sessions, target, position) {
+        const pinnable = sessions.filter(session => !session.isArchived.get());
+        for (const session of pinnable) {
+            this._sessionsListModelService.pinSession(session);
+        }
+        if (target && position) {
+            this.reorderSessions(pinnable, target, position);
+        }
+    }
+    unpinSession(session) {
+        this._sessionsListModelService.unpinSession(session);
+    }
+    isSessionPinned(session) {
+        return this._sessionsListModelService.isSessionPinned(session);
+    }
+    getRenderedSessionGroup(session) {
+        if (session.isArchived.get() || this.isSessionPinned(session)) {
+            return undefined;
+        }
+        const groupId = this._sessionGroupsService.getGroupOfSession(session.sessionId);
+        return groupId === undefined ? undefined : this._sessionGroupsService.getGroup(groupId);
+    }
+    isRenderedInCustomGroup(session) {
+        return this.getRenderedSessionGroup(session) !== undefined;
+    }
+    _someProviderSupportsQuickChats() {
+        return ( this._sessionsProvidersService.getProviders().some(p => !!p.supportsQuickChats));
+    }
+    markRead(session) {
+        this._sessionsManagementService.markRead(session);
+    }
+    markUnread(session) {
+        this._sessionsManagementService.markUnread(session);
+    }
+    setSessionTypeExcluded(sessionTypeId, excluded) {
+        if (excluded) {
+            this.excludedSessionTypes.add(sessionTypeId);
+        } else {
+            this.excludedSessionTypes.delete(sessionTypeId);
+        }
+        this.saveExcludedSessionTypes();
+        this.update();
+    }
+    isSessionTypeExcluded(sessionTypeId) {
+        return ( this.excludedSessionTypes.has(sessionTypeId));
+    }
+    loadExcludedSessionTypes() {
+        const raw = this.storageService.get(SessionsList_1.EXCLUDED_TYPES_KEY, StorageScope.PROFILE);
+        if (raw) {
+            try {
+                const arr = JSON.parse(raw);
+                if (Array.isArray(arr)) {
+                    return ( new Set(arr));
+                }
+            } catch {}
+        }
+        return ( new Set());
+    }
+    saveExcludedSessionTypes() {
+        if (this.excludedSessionTypes.size === 0) {
+            this.storageService.remove(SessionsList_1.EXCLUDED_TYPES_KEY, StorageScope.PROFILE);
+        } else {
+            this.storageService.store(
+                SessionsList_1.EXCLUDED_TYPES_KEY,
+                JSON.stringify([...this.excludedSessionTypes]),
+                StorageScope.PROFILE,
+                StorageTarget.USER
+            );
+        }
+    }
+    setStatusExcluded(status, excluded) {
+        if (excluded) {
+            this.excludedStatuses.add(status);
+        } else {
+            this.excludedStatuses.delete(status);
+        }
+        this.saveExcludedStatuses();
+        this.update();
+    }
+    isStatusExcluded(status) {
+        return ( this.excludedStatuses.has(status));
+    }
+    loadExcludedStatuses() {
+        const raw = this.storageService.get(SessionsList_1.EXCLUDED_STATUSES_KEY, StorageScope.PROFILE);
+        if (raw) {
+            try {
+                const arr = JSON.parse(raw);
+                if (Array.isArray(arr)) {
+                    return ( new Set(arr));
+                }
+            } catch {}
+        }
+        return ( new Set());
+    }
+    saveExcludedStatuses() {
+        if (this.excludedStatuses.size === 0) {
+            this.storageService.remove(SessionsList_1.EXCLUDED_STATUSES_KEY, StorageScope.PROFILE);
+        } else {
+            this.storageService.store(
+                SessionsList_1.EXCLUDED_STATUSES_KEY,
+                JSON.stringify([...this.excludedStatuses]),
+                StorageScope.PROFILE,
+                StorageTarget.USER
+            );
+        }
+    }
+    setExcludeArchived(exclude) {
+        this._excludeArchived = exclude;
+        this.storageService.store(
+            SessionsList_1.EXCLUDE_ARCHIVED_KEY,
+            exclude,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+        this.update();
+    }
+    isExcludeArchived() {
+        return this._excludeArchived;
+    }
+    setExcludeRead(exclude) {
+        this._excludeRead = exclude;
+        this.storageService.store(
+            SessionsList_1.EXCLUDE_READ_KEY,
+            exclude,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+        this.update();
+    }
+    isExcludeRead() {
+        return this._excludeRead;
+    }
+    resetFilters() {
+        this.excludedSessionTypes.clear();
+        this.saveExcludedSessionTypes();
+        this.excludedStatuses.clear();
+        this.saveExcludedStatuses();
+        this._excludeArchived = true;
+        this.storageService.store(
+            SessionsList_1.EXCLUDE_ARCHIVED_KEY,
+            true,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+        this._excludeRead = false;
+        this.storageService.store(
+            SessionsList_1.EXCLUDE_READ_KEY,
+            false,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+        this.workspaceGroupCapped = true;
+        this.storageService.store(
+            SessionsList_1.WORKSPACE_GROUP_CAPPED_KEY,
+            true,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+        this.expandedSessionGroups.clear();
+        this.expandedMoreFolders = false;
+        this.update();
+    }
+    setWorkspaceGroupCapped(capped) {
+        this.workspaceGroupCapped = capped;
+        this.storageService.store(
+            SessionsList_1.WORKSPACE_GROUP_CAPPED_KEY,
+            capped,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+        if (capped) {
+            this.expandedSessionGroups.clear();
+        }
+        this.update();
+    }
+    isWorkspaceGroupCapped() {
+        return this.workspaceGroupCapped;
+    }
+    setOpenWindowSourceFolder(folder) {
+        const before = this.openWindowSourceFolder?.toString();
+        const after = folder?.toString();
+        if (before === after) {
+            return;
+        }
+        this.openWindowSourceFolder = folder;
+        this.update();
+    }
+    collapseAllSections() {
+        this.suspendCollapseStatePersistence = true;
+        try {
+            this.tree.collapseAll();
+        } finally {
+            this.suspendCollapseStatePersistence = false;
+        }
+        this.saveBulkCollapseState(true);
+    }
+    getSavedCollapseState(sectionId) {
+        const raw = this.storageService.get(SessionsList_1.SECTION_COLLAPSE_STATE_KEY, StorageScope.PROFILE);
+        if (raw) {
+            try {
+                const state = JSON.parse(raw);
+                if (typeof state[sectionId] === "boolean") {
+                    return state[sectionId];
+                }
+            } catch {}
+        }
+        return undefined;
+    }
+    saveSectionCollapseState(sectionId, collapsed) {
+        let state = {};
+        const raw = this.storageService.get(SessionsList_1.SECTION_COLLAPSE_STATE_KEY, StorageScope.PROFILE);
+        if (raw) {
+            try {
+                const parsed = JSON.parse(raw);
+                if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+                    state = parsed;
+                }
+            } catch {}
+        }
+        state[sectionId] = collapsed;
+        this.storageService.store(
+            SessionsList_1.SECTION_COLLAPSE_STATE_KEY,
+            JSON.stringify(state),
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+    }
+    saveBulkCollapseState(collapsed) {
+        const state = {};
+        for (const child of this.tree.getNode(null).children) {
+            if (child.element && isSessionSection(child.element)) {
+                state[child.element.id] = collapsed;
+            }
+        }
+        this.storageService.store(
+            SessionsList_1.SECTION_COLLAPSE_STATE_KEY,
+            JSON.stringify(state),
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+    }
+};
+SessionsList = SessionsList_1 = ( __decorate([( __param(2, ISessionsManagementService)), ( __param(3, ISessionsService)), ( __param(4, ICustomViewService)), ( __param(5, ISessionsListModelService)), ( __param(6, ISessionGroupsService)), ( __param(7, ISessionSectionOrderService)), ( __param(8, IAgentHostFilterService)), ( __param(9, IInstantiationService)), ( __param(10, IContextKeyService)), ( __param(11, IStorageService)), ( __param(12, IContextMenuService)), ( __param(13, IMenuService)), ( __param(14, IKeybindingService)), ( __param(15, ICommandService)), ( __param(16, IAutomationService)), ( __param(17, IVoicePlaybackService)), ( __param(18, IWorkbenchAssignmentService)), ( __param(19, IConfigurationService)), ( __param(20, IUriIdentityService)), ( __param(21, IAgentHostConnectionsService)), ( __param(22, IOpenerService)), ( __param(23, ILabelService)), ( __param(24, IPreferencesService))], SessionsList));
+function getFirstApprovalAcrossChats(approvalModel, session, reader) {
+    let oldest;
+    for (const chat of session.chats.read(reader)) {
+        const approval = approvalModel.getApproval(chat.resource).read(reader);
+        if (approval && (!oldest || approval.since.getTime() < oldest.since.getTime())) {
+            oldest = approval;
+        }
+    }
+    return oldest;
+}
+function getMainChatApproval(approvalModel, session, reader) {
+    const mainChat = session.mainChat.read(reader);
+    if (!mainChat?.resource) {
+        return undefined;
+    }
+    return approvalModel.getApproval(mainChat.resource).read(reader);
+}
+function getSessionRowApproval(approvalModel, session, reader, aggregate) {
+    return aggregate ? getFirstApprovalAcrossChats(approvalModel, session, reader) : getMainChatApproval(approvalModel, session, reader);
+}
+function sessionMatchesFolder(session, folder) {
+    const workspace = session.workspace.get();
+    if (!workspace) {
+        return false;
+    }
+    const folderStr = ( folder.toString());
+    for (const folder of workspace.folders) {
+        if (folder.workingDirectory?.toString() === folderStr || ( folder.root.toString()) === folderStr) {
+            return true;
+        }
+    }
+    return false;
+}
+function sortSessions(sessions, sorting, getSortKey) {
+    const key = getSortKey ?? defaultSortKey;
+    return [...sessions].sort((a, b) => key(b, sorting) - key(a, sorting));
+}
+function limitSessionsForList(sessions, limit, options) {
+    if (!options.enabled || sessions.length <= limit) {
+        return {
+            sessions,
+            showMore: undefined
+        };
+    }
+    if (options.expanded) {
+        return {
+            sessions,
+            showMore: {
+                showMore: true,
+                kind: "sessions",
+                mode: "less",
+                sectionId: options.sectionId,
+                sectionLabel: options.sectionLabel,
+                remainingCount: 0
+            }
+        };
+    }
+    const visibleSessions = sessions.slice(0, limit);
+    if (options.revealSessionId !== undefined) {
+        const revealIndex = sessions.findIndex(session => session.sessionId === options.revealSessionId);
+        if (revealIndex >= limit) {
+            visibleSessions.push(sessions[revealIndex]);
+        }
+    }
+    const remainingCount = sessions.length - visibleSessions.length;
+    return {
+        sessions: visibleSessions,
+        showMore: remainingCount > 0 ? {
+            showMore: true,
+            kind: "sessions",
+            mode: "more",
+            sectionId: options.sectionId,
+            sectionLabel: options.sectionLabel,
+            remainingCount
+        } : undefined
+    };
+}
+function defaultSortKey(session, sorting) {
+    if (sorting === SessionsSorting.Updated) {
+        return session.updatedAt.get().getTime();
+    }
+    return session.createdAt.getTime();
+}
+function computeReorderSortChanges(input) {
+    const {
+        draggedIds,
+        naturalKeys,
+        aboveKey,
+        belowKey,
+        now,
+        fallbackStep
+    } = input;
+    const count = draggedIds.length;
+    const upperFit = aboveKey ?? Number.POSITIVE_INFINITY;
+    const lowerFit = belowKey ?? Number.NEGATIVE_INFINITY;
+    let naturalFits = true;
+    for (let i = 0; i < count; i++) {
+        if (!(naturalKeys[i] < upperFit && naturalKeys[i] > lowerFit)) {
+            naturalFits = false;
+            break;
+        }
+        if (i > 0 && !(naturalKeys[i] < naturalKeys[i - 1])) {
+            naturalFits = false;
+            break;
+        }
+    }
+    const set = ( new Map());
+    const clear = [];
+    if (naturalFits) {
+        for (const id of draggedIds) {
+            clear.push(id);
+        }
+    } else {
+        const upper = aboveKey ?? now;
+        const lower = belowKey ?? (upper - (count + 1) * fallbackStep);
+        const step = (upper - lower) / (count + 1);
+        for (let i = 0; i < count; i++) {
+            set.set(draggedIds[i], upper - (i + 1) * step);
+        }
+    }
+    return {
+        set,
+        clear
+    };
+}
+const QUICK_CHATS_SECTION_ID = "quickchats";
+function isQuickChatSession(session) {
+    return session.isQuickChat?.get() ?? false;
+}
+function isAutomationSession(session) {
+    return session.isAutomation?.get() ?? false;
+}
+function groupSessionsForList(
+    sessions,
+    grouping,
+    sorting,
+    isSessionPinned,
+    getSortKey,
+    archivedSectionLabel = getChatSessionArchivedSectionLabel(ChatSessionArchiveActionWording.MarkAsDone)
+) {
+    const sorted = sortSessions(
+        sessions.filter(session => !isAutomationSession(session)),
+        sorting,
+        getSortKey
+    );
+    const pinned = [];
+    const archived = [];
+    const quickChats = [];
+    const regular = [];
+    for (const session of sorted) {
+        if (session.isArchived.get()) {
+            archived.push(session);
+        } else if (isSessionPinned(session)) {
+            pinned.push(session);
+        } else if (isQuickChatSession(session)) {
+            quickChats.push(session);
+        } else {
+            regular.push(session);
+        }
+    }
+    const sections = [];
+    if (pinned.length > 0) {
+        sections.push({
+            id: "pinned",
+            label: ( localize(4829, "Pinned")),
+            sessions: pinned
+        });
+    }
+    if (quickChats.length > 0) {
+        sections.push({
+            id: QUICK_CHATS_SECTION_ID,
+            label: ( localize(4816, "Chats")),
+            sessions: quickChats
+        });
+    }
+    sections.push(
+        ...(grouping === SessionsGrouping.Workspace ? groupByWorkspace(regular) : groupByDate(regular, sorting, getSortKey))
+    );
+    if (archived.length > 0) {
+        sections.push({
+            id: "archived",
+            label: archivedSectionLabel,
+            sessions: archived
+        });
+    }
+    return sections;
+}
+function sessionWorkspaceLabel(session) {
+    return session.workspace.get()?.label || ( localize(4830, "Unknown"));
+}
+function groupByWorkspace(sessions) {
+    const groups = ( new Map());
+    for (const session of sessions) {
+        const label = sessionWorkspaceLabel(session);
+        let group = groups.get(label);
+        if (!group) {
+            group = [];
+            groups.set(label, group);
+        }
+        group.push(session);
+    }
+    const unknownWorkspaceLabel = ( localize(4830, "Unknown"));
+    const order = [...( groups.keys())].filter(k => k !== unknownWorkspaceLabel).sort((a, b) => a.localeCompare(b));
+    const result = order.map(label => ({
+        id: `workspace:${label}`,
+        label,
+        sessions: groups.get(label)
+    }));
+    const unknownWorkspace = groups.get(unknownWorkspaceLabel);
+    if (unknownWorkspace) {
+        result.push({
+            id: `workspace:${unknownWorkspaceLabel}`,
+            label: unknownWorkspaceLabel,
+            sessions: unknownWorkspace
+        });
+    }
+    return result;
+}
+const RECENT_SESSIONS_LIMIT = 10;
+const RECENT_SESSIONS_LIMIT_WITH_UPDATES = 15;
+const RECENTLY_UPDATED_SESSION_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+function groupByDate(sessions, sorting, getSortKey) {
+    const key = getSortKey ?? defaultSortKey;
+    const now = ( new Date());
+    const startOfToday = ( new Date(now.getFullYear(), now.getMonth(), now.getDate())).getTime();
+    const startOfWeek = startOfToday - 7 * 86_400_000;
+    const recentlyUpdatedThreshold = now.getTime() - RECENTLY_UPDATED_SESSION_THRESHOLD_MS;
+    const recent = [];
+    const older = [];
+    for (const session of sessions) {
+        const time = key(session, sorting);
+        const wasRecentlyUpdated = sorting === SessionsSorting.Created && session.updatedAt.get().getTime() >= recentlyUpdatedThreshold;
+        const isWithinRecentLimit = recent.length < RECENT_SESSIONS_LIMIT && time >= startOfWeek;
+        const isWithinUpdatedRecentLimit = recent.length < RECENT_SESSIONS_LIMIT_WITH_UPDATES && wasRecentlyUpdated;
+        if (isWithinRecentLimit || isWithinUpdatedRecentLimit) {
+            recent.push(session);
+        } else {
+            older.push(session);
+        }
+    }
+    const sections = [];
+    const addGroup = (id, label, groupSessions) => {
+        if (groupSessions.length > 0) {
+            sections.push({
+                id,
+                label,
+                sessions: groupSessions
+            });
+        }
+    };
+    addGroup("recent", ( localize(4831, "Recent")), recent);
+    addGroup("older", ( localize(4832, "Older")), older);
+    return sections;
+}
+let SessionsFlatList = class SessionsFlatList extends Disposable {
+    static {
+        SessionsFlatList_1 = this;
+    }
+    static {
+        this.ROW_HEIGHT = 54;
+    }
+    constructor(
+        container,
+        options,
+        _sessionsService,
+        _sessionsListModelService,
+        _sessionsManagementService,
+        instantiationService,
+        contextKeyService,
+        markdownRendererService,
+        hoverService,
+        menuService,
+        contextMenuService,
+        keybindingService,
+        configurationService,
+        sessionsProvidersService,
+        voicePlaybackService,
+        agentHostConnectionsService,
+        openerService,
+        labelService,
+        preferencesService
+    ) {
+        super();
+        this.options = options;
+        this._sessionsService = _sessionsService;
+        this._sessionsListModelService = _sessionsListModelService;
+        this._sessionsManagementService = _sessionsManagementService;
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+        this.contextMenuService = contextMenuService;
+        this.keybindingService = keybindingService;
+        this._onDidChangeContentHeight = this._register(( new Emitter()));
+        this.onDidChangeContentHeight = this._onDidChangeContentHeight.event;
+        this._onDidApproveSession = this._register(( new Emitter()));
+        this.onDidApproveSession = this._onDidApproveSession.event;
+        this._sessions = [];
+        const listRoot = append(container, $(".sessions-list-control"));
+        const approvalModel = this.options.approvalModel ?? this._register(instantiationService.createInstance(AgentSessionApprovalModel));
+        const agentSessionsService = instantiationService.invokeFunction(accessor => accessor.get(IAgentSessionsService));
+        const useCompactQuickChatRows = this.options.useCompactQuickChatRows ?? true;
+        const sessionRenderer = ( new SessionItemRenderer({
+            grouping: () => SessionsGrouping.Date,
+            isPinned: s => this._sessionsListModelService.isSessionPinned(s),
+            visibleSessions: this._sessionsService.visibleSessions,
+            getMultiSelectedSessions: s => [s],
+            showHover: this.options.showSessionHover ?? true,
+            useCompactQuickChatRows,
+            approvalRowMaxLines: this.options.approvalRowMaxLines ?? DEFAULT_APPROVAL_ROW_MAX_LINES,
+            aggregateChatApprovals: true,
+            toolbarMenuId: this.options.toolbarMenuId ?? SessionItemToolbarMenuId,
+            handleToolbarAction: this.options.onToolbarAction
+        }, approvalModel, this.options.ciFixModel, instantiationService, contextKeyService, configurationService, markdownRendererService, hoverService, sessionsProvidersService, this._sessionsManagementService, agentHostConnectionsService, openerService, labelService, preferencesService, agentSessionsService, voicePlaybackService));
+        this._delegate = ( new SessionsTreeDelegate(
+            approvalModel,
+            () => false,
+            this.options.approvalRowMaxLines ?? DEFAULT_APPROVAL_ROW_MAX_LINES,
+            this.options.ciFixModel,
+            useCompactQuickChatRows,
+            true
+        ));
+        this.tree = this._register(instantiationService.createInstance(
+            WorkbenchObjectTree,
+            "SessionsFlatList",
+            listRoot,
+            this._delegate,
+            [sessionRenderer],
+            {
+                accessibilityProvider: ( new SessionsAccessibilityProvider(undefined, {
+                    grouping: () => SessionsGrouping.Date,
+                    isPinned: session => this._sessionsListModelService.isSessionPinned(session),
+                    includeQuickChatInAriaLabel: !useCompactQuickChatRows
+                })),
+                identityProvider: {
+                    getId: element => ( element.resource.toString())
+                },
+                horizontalScrolling: false,
+                alwaysConsumeMouseWheel: this.options.alwaysConsumeMouseWheel ?? true,
+                multipleSelectionSupport: false,
+                indent: 0,
+                overrideStyles: this.options.overrideStyles,
+                renderIndentGuides: RenderIndentGuides.None,
+                twistieAdditionalCssClass: () => "force-no-twistie"
+            }
+        ));
+        this._register(this.tree.onDidOpen(e => {
+            const element = e.element;
+            if (!element || !isSessionItem(element)) {
+                return;
+            }
+            if (this.options.markSessionReadOnOpen !== false) {
+                this._sessionsManagementService.markRead(element);
+            }
+            const isLeftClick = isMouseEvent(e.browserEvent) && e.browserEvent.button === 0;
+            const preserveFocus = isLeftClick ? false : (e.editorOptions.preserveFocus ?? false);
+            this.options.onSessionOpen(element.resource, preserveFocus, e.sideBySide);
+        }));
+        if (this.options.contextMenuId) {
+            this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
+        }
+        this._register(sessionRenderer.onDidChangeItemHeight(session => {
+            if (this.tree.hasElement(session)) {
+                this.tree.updateElementHeight(session, this._delegate.getHeight(session));
+                this._onDidChangeContentHeight.fire();
+            }
+        }));
+        this._register(
+            sessionRenderer.onDidApproveSession(approved => this._onDidApproveSession.fire(approved))
+        );
+    }
+    onContextMenu(e) {
+        const session = e.element;
+        if (!session || !isSessionItem(session) || !this.options.contextMenuId) {
+            return;
+        }
+        const disposables = ( new DisposableStore());
+        const contextKeyService = this.contextKeyService.createOverlay([
+            [SessionIsArchivedContext.key, session.isArchived.get()],
+            [SessionIsReadContext.key, session.isRead.get()],
+            [SessionTypeContext.key, session.sessionType],
+            [SessionProviderIdContext.key, session.providerId],
+            [
+                SessionSupportsRenameContext.key,
+                session.capabilities.get().supportsRename ?? false
+            ],
+            [
+                SessionSupportsDeleteContext.key,
+                session.capabilities.get().supportsDelete ?? false
+            ],
+            [SessionItemStatusContext.key, session.status.get()]
+        ]);
+        const menu = disposables.add(this.menuService.createMenu(this.options.contextMenuId, contextKeyService));
+        const actions = Separator.join(...menu.getActions({
+            shouldForwardArgs: true
+        }).map(([, groupActions]) => groupActions));
+        if (actions.length === 0) {
+            disposables.dispose();
+            return;
+        }
+        const actionRunner = disposables.add(( new SessionItemActionRunner(selected => [selected], this.options.onContextMenuAction)));
+        this.contextMenuService.showContextMenu({
+            getActions: () => actions,
+            getActionsContext: () => session,
+            getAnchor: () => e.anchor,
+            getKeyBinding: action => this.keybindingService.lookupKeybinding(action.id, contextKeyService, true) ?? undefined,
+            actionRunner,
+            onHide: () => disposables.dispose()
+        });
+    }
+    setSessions(sessions) {
+        this._sessions = sessions;
+        this.tree.setChildren(null, sessions.map(session => ({
+            element: session
+        })));
+    }
+    getContentHeight() {
+        return this._sessions.reduce((total, session) => total + this._delegate.getHeight(session), 0);
+    }
+    getRowHeight() {
+        return SessionsFlatList_1.ROW_HEIGHT;
+    }
+    layout(height, width) {
+        this.tree.layout(height, width);
+    }
+    focus() {
+        this.tree.domFocus();
+    }
+    focusSession(session) {
+        if (!this.tree.hasElement(session)) {
+            return;
+        }
+        this.tree.setFocus([session]);
+        this.tree.domFocus();
+    }
+};
+SessionsFlatList = SessionsFlatList_1 = ( __decorate([( __param(2, ISessionsService)), ( __param(3, ISessionsListModelService)), ( __param(4, ISessionsManagementService)), ( __param(5, IInstantiationService)), ( __param(6, IContextKeyService)), ( __param(7, IMarkdownRendererService)), ( __param(8, IHoverService)), ( __param(9, IMenuService)), ( __param(10, IContextMenuService)), ( __param(11, IKeybindingService)), ( __param(12, IConfigurationService)), ( __param(13, ISessionsProvidersService)), ( __param(14, IVoicePlaybackService)), ( __param(15, IAgentHostConnectionsService)), ( __param(16, IOpenerService)), ( __param(17, ILabelService)), ( __param(18, IPreferencesService))], SessionsFlatList));
+
+export { IsSessionPinnedContext, NEW_SESSION_FOR_WORKSPACE_ACTION_ID, QUICK_CHATS_SECTION_ID, SESSIONS_LIST_SHOW_EMPTY_DEFAULT_GROUPS_SETTING, SessionChatItem, SessionChatItemCanDeleteContext, SessionChatItemCanRenameContext, SessionChatItemIsUntitledContext, SessionGroupHasVisibleSessionsContext, SessionGroupIsEmptyContext, SessionGroupToolbarMenuId, SessionItemContextMenuId, SessionItemHasBranchNameContext, SessionItemInGroupContext, SessionItemStatusContext, SessionItemToolbarMenuId, SessionSectionHasGitHubRepositoryContext, SessionSectionHasNonCloudRepositoryContext, SessionSectionRenderer, SessionSectionToolbarMenuId, SessionSectionTypeContext, SessionsFlatList, SessionsGrouping, SessionsList, SessionsListFocusedChatItemContext, SessionsSorting, computeReorderSortChanges, getFirstApprovalAcrossChats, getSessionArchiveOnboardingTargetId, groupByDate, groupByWorkspace, groupSessionsForList, isAutomationSession, isQuickChatSession, limitSessionsForList, sortSessions };