@codingame/monaco-vscode-api 37.6.1 → 38.0.1

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

@@ -2,7 +2,8 @@
 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 { $ as $$1, append, addDisposableListener, clearNode, getWindow, EventType, isActiveElement, addStandardDisposableListener, scheduleAtNextAnimationFrame, isAncestorOfActiveElement, isMouseEvent } from '../../../../../base/browser/dom.js';
+import { renderAsPlaintext } from '../../../../../base/browser/markdownRenderer.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';
@@ -10,115 +11,144 @@ import { ObjectTreeElementCollapseState } from '../../../../../base/browser/ui/t
 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 { Emitter, Event } 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 { ThemeIcon, themeColorFromId } from '../../../../../base/common/themables.js';
+import { hasKey } from '../../../../../base/common/types.js';
 import { fromNow } from '../../../../../base/common/date.js';
 import { KeyCode } from '../../../../../base/common/keyCodes.js';
+import { OS } from '../../../../../base/common/platform.js';
 import { isEqual } from '../../../../../base/common/resources.js';
 import { localize } from '../../../../../nls.js';
-import { MenuId, MenuItemAction } from '../../../../../platform/actions/common/actions.js';
+import { MenuId, MenuItemAction, SubmenuItemAction } 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 { createActionViewItem, 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 { SessionIsReadContext, SessionIsArchivedContext, IsQuickChatSessionContext, SessionSupportsMultipleChatsContext, SessionSupportsDeleteContext, IsPhoneLayoutContext, SessionItemIsMultiSelectionContext, SessionTypeContext, SessionProviderIdContext, SessionSupportsRenameContext, SessionHasPullRequestContext } from '../../../../common/contextkeys.js';
+import { ARCHIVE_SESSION_COMMAND_ID, RENAME_SESSION_COMMAND_ID, RENAME_CHAT_COMMAND_ID } from '../../../../common/sessionCommands.js';
+import { ExternalSessionApplicationBadgeMode, SESSIONS_LIST_GROUP_EXTERNAL_SESSIONS_SETTING, SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SETTING, SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SHOW_FROM_SETTING } from '../../../../common/sessionConfig.js';
+import { IContextMenuService, IContextViewService } 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 { WorkbenchList, WorkbenchObjectTree } from '../../../../../platform/list/browser/listService.js';
+import { defaultButtonStyles, defaultInputBoxStyles, defaultKeybindingLabelStyles, defaultToggleStyles, defaultFindWidgetStyles } from '../../../../../platform/theme/browser/defaultStyles.js';
 import { chartsOrange } from '../../../../../platform/theme/common/colors/chartsColors.js';
+import { asCssVariable } from '../../../../../platform/theme/common/colorUtils.js';
 import { StorageScope, StorageTarget } from '../../../../../platform/storage/common/storage.js';
 import { IStorageService } from '../../../../../platform/storage/common/storage.service.js';
+import { isConfigured } from '../../../../../platform/configuration/common/configuration.js';
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { observableConfigValue } from '../../../../../platform/observable/common/platformObservableUtils.js';
+import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.service.js';
+import { logSettingExperimentTrigger } from '../../../../../platform/telemetry/common/experimentTrigger.js';
+import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.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 { SessionStatus, getUntitledSessionTitle, ChatOriginKind, ChatInteractivity, BRANCH_CHANGES_CHANGESET_ID, isActiveSessionStatus, getGitHubPullRequestRefs, getChatCapabilities, getSessionStatusMessage, getSessionWorkspaceKind, SessionWorkspaceKind, GITHUB_REMOTE_FILE_SCHEME } from '../../../../services/sessions/common/session.js';
+import { readChatChangesStats } from '../../../../services/sessions/common/sessionChangesStatsCache.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 { createSessionActionViewItemProvider, SessionArchiveActionViewItem, 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 { SessionComparisonParticipantRole, getSessionComparisonHarnessLabel, getSessionComparisonParticipantsInDisplayOrder } from '../../../../services/sessions/common/sessionComparison.js';
+import { ISessionComparisonService } from '../../../../services/sessions/common/sessionComparison.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 { InputBox, MessageType } 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 { OPEN_SESSION_COMPARISON_COMMAND_ID } from '../../../sessionComparison/common/sessionComparison.js';
 import { IAgentSessionsService } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentSessionsService.service.js';
 import { IAgentHostFilterService } from '../../../../services/agentHostFilter/common/agentHostFilter.service.js';
+import { SessionsListFilters } from './sessionsListFilters.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 { getSessionDiffStats, createSessionSummaryHover, getSessionSummaryHoverData, getChatSummaryHoverData } from '../sessionHoverContent.js';
 import { SessionStatusIcon } from '../../../../browser/sessionStatusIcon.js';
 import { ChatAutomationsEnabledContext } from '../../../../../workbench/contrib/chat/common/automations/automationsEnabled.js';
+import { AICustomizationManagementEditorInput } from '../../../../../workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagementEditorInput.js';
 import { IAutomationService } from '../../../../../workbench/contrib/chat/common/automations/automationService.service.js';
+import { IEditorService } from '../../../../../workbench/services/editor/common/editorService.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 { OPEN_AI_CUSTOMIZATIONS_COMMAND_ID } from '../customizationsConstants.js';
+import { NEW_SESSION_ACTION_ID } from '../../../chat/common/constants.js';
 import { Menus } from '../../../../browser/menus.js';
 import { getSessionConversationStatusAriaLabel } from '../../../../browser/sessionConversationGroups.js';
 import { isAgentMergePullRequestIcon, getSessionAgentMergeConfigurationObservable, getAgentMergeAwarePullRequestIcon } from '../../../../browser/sessionAgentMerge.js';
+import { BlockedSessions, BlockedSessionReason } from '../../../blockedSessions/browser/blockedSessions.js';
+import { KeybindingLabel } from '../../../../../base/browser/ui/keybindingLabel/keybindingLabel.js';
+import { logSessionsInteraction } from '../../../../common/sessionsTelemetry.js';
 import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
-import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
+import { constObservable } from '../../../../../base/common/observableInternal/observables/constObservable.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';
+import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
+import { observableFromEvent } from '../../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { observableSignalFromEvent } from '../../../../../base/common/observableInternal/observables/observableSignalFromEvent.js';
 
 var SessionsList_1, SessionsFlatList_1;
 registerCss(sessionsList, 1);
 const $ = $$1;
+const NEW_SESSION_SECTION_ID = "newSession";
 const AUTOMATIONS_SECTION_ID = "automations";
+const CUSTOMIZATIONS_SECTION_ID = "customizations";
+const EXTERNAL_SESSIONS_SECTION_ID = "external";
+const SESSION_SHORTCUT_SECTION_TEMPLATE_ID = "session-shortcut-section";
+const SESSION_SHORTCUT_ROW_HEIGHT = 28;
 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 SESSIONS_LIST_SHOW_UNREAD_IN_COLLAPSED_SECTIONS_SETTING = "sessions.list.showUnreadInCollapsedSections";
+const SESSIONS_LIST_SHOW_ARCHIVED_BY_DEFAULT_SETTING = "sessions.list.showArchivedByDefault";
 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 SessionChatItemCanArchiveContext = new RawContextKey("sessionChatItem.canArchive", false);
 const SessionChatItemCanDeleteContext = new RawContextKey("sessionChatItem.canDelete", false);
+const SessionChatItemIsArchivedContext = new RawContextKey("sessionChatItem.isArchived", false);
 const SessionChatItemIsUntitledContext = new RawContextKey("sessionChatItem.isUntitled", false);
 const SessionsListFocusedChatItemContext = new RawContextKey("sessionsList.focusedChatItem", false);
 const SessionItemInGroupContext = new RawContextKey("sessionItem.inGroup", false);
+const SessionItemInExternalSectionContext = new RawContextKey("sessionItem.inExternalSection", false);
+const SessionItemCanImportContext = new RawContextKey("sessionItem.canImport", 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);
+const SessionGroupIsComparisonContext = new RawContextKey("sessionGroup.isComparison", false);
 var SessionsGrouping;
 (function(SessionsGrouping) {
     SessionsGrouping["Workspace"] = "workspace";
@@ -134,32 +164,105 @@ function sortingToMode(sorting) {
 }
 const SORT_FALLBACK_STEP_MS = 60_000;
 class SessionChatItem {
-    constructor(session, chat) {
+    constructor(session, chat, isLast) {
         this.session = session;
         this.chat = chat;
+        this.isLast = isLast;
     }
 }
 function isSessionChatItem(item) {
     return item instanceof SessionChatItem;
 }
 function getChatTitle(chat, reader) {
-    return chat.title.read(reader).trim() || ( localize(4898, "Untitled Chat"));
+    if (chat.status.read(reader) === SessionStatus.Untitled) {
+        return getUntitledSessionTitle(false);
+    }
+    return chat.title.read(reader).trim() || ( localize(6110, "Untitled Chat"));
+}
+function formatSessionListTime(date) {
+    const seconds = Math.round((Date.now() - date.getTime()) / 1000);
+    return seconds < 60 ? ( localize(6111, "now")) : fromNow(date, true);
 }
-function getSessionListChats(session, reader) {
+function getSessionListChats(session, reader, showArchived = false) {
     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
+        chat => !isEqual(chat.resource, mainChat.resource) && chat.origin?.kind !== ChatOriginKind.Tool && chat.origin?.kind !== ChatOriginKind.SideChat && (!chat.isArchived.read(reader) || showArchived) && chat.interactivity.read(reader) !== ChatInteractivity.Hidden
     );
 }
-function getSessionRowStatus(session, reader, deriveFromMainChat) {
+function hasArchivedListContent(session) {
+    return session.isArchived.get() || ( getSessionListChats(session, undefined, true).some(chat => chat.isArchived.get()));
+}
+function getSessionListChatDiffStats(session, chat, activeSession, reader) {
+    const active = activeSession?.read(reader);
+    if (active?.sessionId === session.sessionId && isEqual(active.activeChat.read(reader).resource, chat.resource)) {
+        const chatStats = readChatChangesStats(chat, reader, BRANCH_CHANGES_CHANGESET_ID);
+        if (chatStats !== undefined) {
+            return chatStats.insertions > 0 || chatStats.deletions > 0 ? chatStats : undefined;
+        }
+    }
+    return getSessionDiffStats(session, reader);
+}
+function getChatListDiffStats(chat, reader) {
+    const summary = chat.changesSummary?.read(reader);
+    return summary && (summary.additions > 0 || summary.deletions > 0) ? {
+        files: summary.files,
+        insertions: summary.additions,
+        deletions: summary.deletions
+    } : undefined;
+}
+function getSessionRowStatus(session, reader, deriveFromMainChat, collapsed = true) {
     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;
+    let rowStatus = session.mainChat.read(reader).status.read(reader);
+    if (rowStatus === SessionStatus.NeedsInput) {
+        return rowStatus;
+    }
+    const chats = session.chats.read(reader);
+    let excludedSideChatInProgress = false;
+    for (const chat of chats) {
+        if (chat.origin?.kind !== ChatOriginKind.SideChat) {
+            continue;
+        }
+        if (chat.isArchived.read(reader) || chat.interactivity.read(reader) === ChatInteractivity.Hidden) {
+            excludedSideChatInProgress ||= collapsed && sessionStatus === SessionStatus.InProgress && chat.status.read(reader) === SessionStatus.InProgress;
+            continue;
+        }
+        const status = chat.status.read(reader);
+        if (status === SessionStatus.NeedsInput) {
+            return status;
+        }
+        if (status === SessionStatus.InProgress) {
+            rowStatus = status;
+        }
+    }
+    if (rowStatus === SessionStatus.InProgress) {
+        return rowStatus;
+    }
+    if (collapsed && sessionStatus === SessionStatus.InProgress) {
+        if (!excludedSideChatInProgress || ( chats.some(
+            chat => chat.origin?.kind !== ChatOriginKind.SideChat && chat.status.read(reader) === SessionStatus.InProgress
+        ))) {
+            return SessionStatus.InProgress;
+        }
     }
-    return session.mainChat.read(reader).status.read(reader);
+    return rowStatus;
+}
+function getSessionRowIsRead(session, reader, deriveFromMainChat) {
+    return deriveFromMainChat ? session.mainChat.read(reader).isRead.read(reader) : session.isRead.read(reader);
+}
+function isSessionActive(session, reader) {
+    return isActiveSessionStatus(session.status.read(reader));
+}
+function getComparisonSessions(comparison, sessionsManagementService) {
+    return comparison.participants.flatMap(participant => {
+        if (!participant.sessionResource) {
+            return [];
+        }
+        const session = sessionsManagementService.getSession(participant.sessionResource);
+        return session ? [session] : [];
+    });
 }
 function isSessionGroupItem(item) {
     return "group" in item;
@@ -169,12 +272,18 @@ function isSessionSection(item) {
 }
 function getSessionSectionIcon(sectionId) {
     switch (sectionId) {
+    case NEW_SESSION_SECTION_ID:
+        return Codicon.plus;
     case QUICK_CHATS_SECTION_ID:
         return Codicon.commentDiscussion;
     case "pinned":
         return Codicon.pinned;
+    case EXTERNAL_SESSIONS_SECTION_ID:
+        return Codicon.chatImport;
     case AUTOMATIONS_SECTION_ID:
         return Codicon.calendar;
+    case CUSTOMIZATIONS_SECTION_ID:
+        return Codicon.extensions;
     case "archived":
         return Codicon.archive;
     case "recent":
@@ -185,6 +294,9 @@ function getSessionSectionIcon(sectionId) {
         return sectionId.startsWith("workspace:") ? Codicon.folder : undefined;
     }
 }
+function isShortcutSection(sectionId) {
+    return sectionId === NEW_SESSION_SECTION_ID || sectionId === AUTOMATIONS_SECTION_ID || sectionId === CUSTOMIZATIONS_SECTION_ID;
+}
 function isSessionShowMore(item) {
     return "showMore" in item && item.showMore === true;
 }
@@ -203,16 +315,25 @@ class SessionsTreeDelegate {
         this.ITEM_HEIGHT = 54;
     }
     static {
-        this.ITEM_HEIGHT_QUICK_CHAT = 28;
+        this.ITEM_HEIGHT_COMPACT = 28;
     }
     static {
-        this.CHAT_ITEM_HEIGHT = 28;
+        this.ITEM_HEIGHT_COMPARISON_ATTEMPT = 28;
+    }
+    static {
+        this.INPUT_NEEDED_ROW_HEIGHT = 32;
+    }
+    static {
+        this.ITEM_HEIGHT_QUICK_CHAT = 28;
     }
     static {
         this.CHAT_ITEM_HEIGHT_PHONE = 44;
     }
     static {
-        this.CHAT_APPROVAL_BOTTOM_SLACK = 6;
+        this.CHAT_FOLDER_ROW_HEIGHT = 16;
+    }
+    static {
+        this.CHAT_APPROVAL_PHONE_BOTTOM_SLACK = 6;
     }
     static {
         this.ITEM_HEIGHT_PHONE = 76;
@@ -220,44 +341,52 @@ class SessionsTreeDelegate {
     static {
         this.SECTION_HEIGHT = 26;
     }
+    static {
+        this.COMPARISON_SECTION_HEIGHT = 44;
+    }
     static {
         this.SHOW_MORE_HEIGHT = 26;
     }
     static {
-        this.PLACEHOLDER_HEIGHT = 26;
+        this.PLACEHOLDER_HEIGHT = SessionsTreeDelegate.ITEM_HEIGHT_QUICK_CHAT;
     }
     constructor(
         _approvalModel,
         _isPhone,
+        _isCompact,
+        _getSessionStatus,
         _approvalRowMaxLines = DEFAULT_APPROVAL_ROW_MAX_LINES,
         _ciFixModel = undefined,
         _useCompactQuickChatRows = true,
         _aggregateChatApprovals = false,
-        _useInsetRowSpacing = false
+        _useInsetRowSpacing = false,
+        _isComparisonAttempt = () => false
     ) {
         this._approvalModel = _approvalModel;
         this._isPhone = _isPhone;
+        this._isCompact = _isCompact;
+        this._getSessionStatus = _getSessionStatus;
         this._approvalRowMaxLines = _approvalRowMaxLines;
         this._ciFixModel = _ciFixModel;
         this._useCompactQuickChatRows = _useCompactQuickChatRows;
         this._aggregateChatApprovals = _aggregateChatApprovals;
         this._useInsetRowSpacing = _useInsetRowSpacing;
+        this._isComparisonAttempt = _isComparisonAttempt;
     }
     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);
+            return this.withInsetRowSpacing(this.withChatApprovalHeight(element, this.getChatBaseHeight()));
+        }
+        if (isSessionGroupItem(element) && element.comparison) {
+            return SessionsTreeDelegate.COMPARISON_SECTION_HEIGHT;
+        }
+        if (isSessionSection(element)) {
+            return isShortcutSection(element.id) ? this.withInsetRowSpacing(SessionsTreeDelegate.SECTION_HEIGHT) : SessionsTreeDelegate.SECTION_HEIGHT;
         }
-        if (isSessionSection(element) || isSessionGroupItem(element)) {
+        if (isSessionGroupItem(element)) {
             return SessionsTreeDelegate.SECTION_HEIGHT;
         }
         if (isSessionShowMore(element)) {
@@ -269,22 +398,50 @@ class SessionsTreeDelegate {
         let height;
         if (this._isPhone()) {
             height = SessionsTreeDelegate.ITEM_HEIGHT_PHONE;
+        } else if (this._isComparisonAttempt(element)) {
+            height = SessionsTreeDelegate.ITEM_HEIGHT_COMPARISON_ATTEMPT;
         } else if (this._useCompactQuickChatRows && isQuickChatSession(element)) {
             height = SessionsTreeDelegate.ITEM_HEIGHT_QUICK_CHAT;
+        } else if (this._isCompact()) {
+            height = SessionsTreeDelegate.ITEM_HEIGHT_COMPACT;
         } else {
             height = SessionsTreeDelegate.ITEM_HEIGHT;
         }
+        const session = element;
+        let approval;
         if (this._approvalModel) {
-            const approval = getSessionRowApproval(this._approvalModel, element, undefined, this._aggregateChatApprovals);
+            approval = getSessionRowApproval(this._approvalModel, session, undefined, this._aggregateChatApprovals);
             if (approval) {
                 height += SessionItemRenderer.getApprovalRowHeight(approval.label, this._approvalRowMaxLines);
             }
         }
+        if (!approval && this._isCompact() && this._getSessionStatus(session) === SessionStatus.NeedsInput) {
+            height += SessionsTreeDelegate.INPUT_NEEDED_ROW_HEIGHT;
+        }
         if (this._ciFixModel && this._ciFixModel.getCIFix(element).get()) {
             height += SessionItemRenderer.CI_ROW_HEIGHT;
         }
         return this.withInsetRowSpacing(height);
     }
+    getHeightWithoutChatWorkspace(element) {
+        return this.withInsetRowSpacing(this.withChatApprovalHeight(element, this.getChatBaseHeight()));
+    }
+    getChatBaseHeight() {
+        if (this._isPhone()) {
+            return SessionsTreeDelegate.CHAT_ITEM_HEIGHT_PHONE + (this._isCompact() ? 0 : SessionsTreeDelegate.CHAT_FOLDER_ROW_HEIGHT);
+        }
+        return this._isCompact() ? SessionsTreeDelegate.ITEM_HEIGHT_COMPACT : SessionsTreeDelegate.ITEM_HEIGHT;
+    }
+    withChatApprovalHeight(element, height) {
+        if (!this._approvalModel) {
+            return height;
+        }
+        const approval = this._approvalModel.getApproval(element.chat.resource).get();
+        if (!approval) {
+            return height;
+        }
+        return height + SessionItemRenderer.getApprovalRowHeight(approval.label, this._approvalRowMaxLines) + (this._isPhone() ? SessionsTreeDelegate.CHAT_APPROVAL_PHONE_BOTTOM_SLACK : 0);
+    }
     hasDynamicHeight(element) {
         if (isSessionChatItem(element)) {
             return !!this._approvalModel;
@@ -299,7 +456,7 @@ class SessionsTreeDelegate {
             return SessionGroupRenderer.TEMPLATE_ID;
         }
         if (isSessionSection(element)) {
-            return SessionSectionRenderer.TEMPLATE_ID;
+            return isShortcutSection(element.id) ? SESSION_SHORTCUT_SECTION_TEMPLATE_ID : SessionSectionRenderer.TEMPLATE_ID;
         }
         if (isSessionShowMore(element)) {
             return SessionShowMoreRenderer.TEMPLATE_ID;
@@ -310,6 +467,46 @@ class SessionsTreeDelegate {
         return SessionItemRenderer.TEMPLATE_ID;
     }
 }
+function withSessionsListHoverPresentation(hover) {
+    return {
+        ...hover,
+        appearance: {
+            showPointer: true
+        },
+        position: {
+            hoverPosition: HoverPosition.RIGHT,
+            forcePosition: true
+        },
+        persistence: {
+            hideOnHover: false
+        }
+    };
+}
+function getCreatorHoverData(
+    session,
+    sessionsManagementService,
+    agentHostConnectionsService,
+    openerService
+) {
+    const creationReference = session.createdBySession?.get();
+    if (!creationReference) {
+        return undefined;
+    }
+    const creator = sessionsManagementService.getSession(creationReference.session);
+    const resolved = 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: () => openerService.open(target).catch(onUnexpectedError)
+    };
+}
 class SessionChatItemRenderer {
     static {
         this.TEMPLATE_ID = "session-chat-item";
@@ -317,16 +514,32 @@ class SessionChatItemRenderer {
     constructor(
         hoverService,
         instantiationService,
+        contextKeyService,
+        sessionsManagementService,
+        contextViewService,
         markdownRendererService,
         approvalModel,
         approvalRowMaxLines,
+        onDidDoubleClickRename,
+        onDidFinishRename,
+        getSummaryHoverOptions,
+        compact,
+        onDidChangeUpdatedAt,
         activeGuideSessionIds = constObservable(EMPTY_GUIDE_SESSION_IDS)
     ) {
         this.hoverService = hoverService;
         this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.sessionsManagementService = sessionsManagementService;
+        this.contextViewService = contextViewService;
         this.markdownRendererService = markdownRendererService;
         this.approvalModel = approvalModel;
         this.approvalRowMaxLines = approvalRowMaxLines;
+        this.onDidDoubleClickRename = onDidDoubleClickRename;
+        this.onDidFinishRename = onDidFinishRename;
+        this.getSummaryHoverOptions = getSummaryHoverOptions;
+        this.compact = compact;
+        this.onDidChangeUpdatedAt = onDidChangeUpdatedAt;
         this.activeGuideSessionIds = activeGuideSessionIds;
         this.templateId = SessionChatItemRenderer.TEMPLATE_ID;
         this.rowClassName = "session-list-inset-row";
@@ -334,6 +547,7 @@ class SessionChatItemRenderer {
         this.onDidChangeItemHeight = this._onDidChangeItemHeight.event;
         this._onDidApproveSession = ( new Emitter());
         this.onDidApproveSession = this._onDidApproveSession.event;
+        this.editingChat = observableValue(this, undefined);
     }
     renderTemplate(container) {
         const disposables = ( new DisposableStore());
@@ -343,7 +557,40 @@ class SessionChatItemRenderer {
         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 titleContainer = append(titleRow, $(".session-chat-title"));
+        const title = disposables.add(( new HighlightedLabel(titleContainer)));
+        const titleInputContainer = append(titleRow, $(".session-chat-title-input.session-inline-rename-input"));
+        const compactHoverDescription = append(titleRow, $(".session-compact-hover-description"));
+        const folderRow = append(container, $(".session-chat-folder-row"));
+        folderRow.setAttribute("aria-hidden", "true");
+        const titleToolbarContainer = append(titleRow, $(".session-title-toolbar"));
+        for (const eventType of ["pointerdown", "pointerup", "click", "dblclick"]) {
+            disposables.add(
+                addDisposableListener(titleInputContainer, eventType, e => e.stopPropagation())
+            );
+            disposables.add(
+                addDisposableListener(titleToolbarContainer, eventType, e => e.stopPropagation())
+            );
+        }
+        disposables.add(Gesture.ignoreTarget(titleInputContainer));
+        disposables.add(Gesture.ignoreTarget(titleToolbarContainer));
+        const contextKeyService = disposables.add(this.contextKeyService.createScoped(container));
+        const canArchiveContext = SessionChatItemCanArchiveContext.bindTo(contextKeyService);
+        const canDeleteContext = SessionChatItemCanDeleteContext.bindTo(contextKeyService);
+        const isUntitledContext = SessionChatItemIsUntitledContext.bindTo(contextKeyService);
+        const isArchivedContext = SessionChatItemIsArchivedContext.bindTo(contextKeyService);
+        const scopedInstantiationService = disposables.add(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService]))));
+        const titleToolbar = disposables.add(scopedInstantiationService.createInstance(
+            MenuWorkbenchToolBar,
+            titleToolbarContainer,
+            Menus.SessionChatItemToolbar,
+            {
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                telemetrySource: "sessionsList.chatRow"
+            }
+        ));
         const approvalRow = append(container, $(".session-approval-row"));
         const approvalLabel = append(approvalRow, $("span.session-approval-label"));
         const approvalButtonContainer = append(approvalRow, $(".session-approval-button"));
@@ -357,9 +604,18 @@ class SessionChatItemRenderer {
             container,
             statusIcon,
             title,
+            titleContainer,
+            titleInputContainer,
+            compactHoverDescription,
+            folderRow,
+            titleToolbar,
             approvalRow,
             approvalLabel,
             approvalButtonContainer,
+            canArchiveContext,
+            canDeleteContext,
+            isUntitledContext,
+            isArchivedContext,
             disposables,
             elementDisposables
         };
@@ -370,27 +626,218 @@ class SessionChatItemRenderer {
             return;
         }
         template.elementDisposables.clear();
-        const chats = getSessionListChats(element.session);
-        template.container.classList.toggle("last-chat", isEqual(chats.at(-1)?.resource, element.chat.resource));
+        template.titleToolbar.context = element;
+        template.elementDisposables.add(toDisposable(() => template.container.classList.remove("renaming")));
+        template.container.classList.toggle("last-chat", element.isLast);
         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);
+            const isArchived = element.chat.isArchived.read(reader);
+            const isRead = element.chat.isRead.read(reader);
+            const completedStateIcon = (element.session.workspace.read(reader)?.folders.length ?? 0) > 1 ? getHighestPriorityPullRequestIcon(element.chat.workspace.read(reader)?.folders.flatMap(
+                folder => getGitHubPullRequestRefs(folder.gitRepository?.gitHubInfo.read(reader)).map(pullRequest => pullRequest.icon)
+            ) ?? []) : undefined;
+            const capabilities = getChatCapabilities(element.chat, element.session, reader);
+            template.canArchiveContext.set(capabilities.canArchive);
+            template.canDeleteContext.set(capabilities.canDelete);
+            template.isUntitledContext.set(status === SessionStatus.Untitled);
+            template.isArchivedContext.set(isArchived);
+            template.statusIcon.setStatus(status, isRead, isArchived, completedStateIcon, element.chat.resource);
+            template.container.classList.toggle("archived", isArchived);
+            template.container.classList.toggle("unread", !isRead && !isArchived);
             template.container.classList.toggle("needs-input", status === SessionStatus.NeedsInput);
         }));
+        const descriptionDisposable = template.elementDisposables.add(( new MutableDisposable()));
+        let previousUpdatedAtTimestamp = element.chat.updatedAt.get()?.getTime();
+        template.elementDisposables.add(autorun(reader => {
+            const sessionWorkspace = element.session.workspace.read(reader);
+            const chatWorkspace = element.chat.workspace.read(reader);
+            const folderLabel = getChatWorkspaceBadgeLabel(sessionWorkspace, chatWorkspace);
+            const status = element.chat.status.read(reader);
+            const statusMessage = getSessionStatusMessage(status, element.chat.description.read(reader));
+            const sortUpdatedAt = element.chat.updatedAt.read(reader);
+            const updatedAt = status === SessionStatus.InProgress ? undefined : sortUpdatedAt;
+            const updatedAtTimestamp = sortUpdatedAt?.getTime();
+            if (previousUpdatedAtTimestamp !== updatedAtTimestamp) {
+                previousUpdatedAtTimestamp = updatedAtTimestamp;
+                this.onDidChangeUpdatedAt();
+            }
+            template.container.classList.toggle("has-folder-label", !!folderLabel);
+            clearNode(template.compactHoverDescription);
+            if (folderLabel) {
+                const badge = append(
+                    template.compactHoverDescription,
+                    $("span.session-badge", undefined, folderLabel)
+                );
+                reader.store.add(this.hoverService.setupDelayedHover(badge, {
+                    content: folderLabel
+                }, {
+                    groupId: "sessions-list"
+                }));
+            }
+            const showDetailsRow = !this.compact();
+            const diffStats = status === SessionStatus.InProgress || status === SessionStatus.NeedsInput ? undefined : getChatListDiffStats(element.chat, reader);
+            template.folderRow.hidden = !showDetailsRow;
+            descriptionDisposable.clear();
+            clearNode(template.folderRow);
+            if (showDetailsRow && statusMessage !== undefined) {
+                const statusElement = append(template.folderRow, $("span.session-description"));
+                const statusDescription = typeof statusMessage === "string" ? statusMessage : renderAsPlaintext(statusMessage, {
+                    omitMarkdownSyntax: true
+                });
+                if (typeof statusMessage === "string" || !this.markdownRendererService) {
+                    statusElement.textContent = statusDescription;
+                } else {
+                    descriptionDisposable.value = this.markdownRendererService.render(statusMessage, {
+                        sanitizerConfig: {
+                            replaceWithPlaintext: true
+                        }
+                    }, statusElement);
+                }
+                reader.store.add(this.hoverService.setupDelayedHover(statusElement, {
+                    content: statusDescription
+                }, {
+                    groupId: "sessions-list"
+                }));
+            } else if (showDetailsRow && folderLabel && chatWorkspace) {
+                const kind = getSessionWorkspaceKind(chatWorkspace, false);
+                const icon = kind === SessionWorkspaceKind.Worktree ? Codicon.worktreeCompact : Codicon.folderCompact;
+                const iconContainer = append(template.folderRow, $("span.session-chat-folder-icon"));
+                append(iconContainer, $(`span${ThemeIcon.asCSSSelector(icon)}`));
+                const label = append(
+                    template.folderRow,
+                    $("span.session-chat-folder-label", undefined, folderLabel)
+                );
+                reader.store.add(this.hoverService.setupDelayedHover(label, {
+                    content: folderLabel
+                }, {
+                    groupId: "sessions-list"
+                }));
+            }
+            const hasLeadingDetail = statusMessage !== undefined || !!folderLabel;
+            if (showDetailsRow && diffStats) {
+                if (hasLeadingDetail) {
+                    append(template.folderRow, $("span.session-chat-separator", undefined, "·"));
+                }
+                const diffEl = append(template.folderRow, $("span.session-chat-diff"));
+                append(diffEl, $("span.session-chat-diff-added")).textContent = `+${diffStats.insertions}`;
+                append(diffEl, $("span.session-chat-diff-removed")).textContent = `-${diffStats.deletions}`;
+            }
+            if (showDetailsRow && updatedAt) {
+                if (hasLeadingDetail || diffStats) {
+                    append(template.folderRow, $("span.session-chat-separator", undefined, "·"));
+                }
+                const time = append(template.folderRow, $("span.session-chat-time"));
+                time.textContent = formatSessionListTime(updatedAt);
+                const targetWindow = getWindow(time);
+                const interval = targetWindow.setInterval(() => time.textContent = formatSessionListTime(updatedAt), 60_000);
+                reader.store.add(toDisposable(() => targetWindow.clearInterval(interval)));
+            }
+        }));
         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"
+        template.elementDisposables.add(
+            this.hoverService.setupDelayedHover(template.container, () => this.getSummaryHoverOptions(element), {
+                groupId: "sessions-list"
+            })
+        );
+        template.elementDisposables.add(
+            addDisposableListener(template.titleContainer, EventType.DBLCLICK, event => {
+                if (event.button !== 0 || event.altKey || event.ctrlKey || event.metaKey || event.shiftKey || !this.canRename(element)) {
+                    return;
+                }
+                event.preventDefault();
+                event.stopPropagation();
+                if (this.beginRename(element)) {
+                    this.onDidDoubleClickRename(element);
+                }
+            })
+        );
+        template.elementDisposables.add(autorun(reader => {
+            const editing = this.editingChat.read(reader);
+            const isEditing = !!editing && this.isSameChat(editing, element);
+            template.container.classList.toggle("renaming", isEditing);
+            if (isEditing) {
+                this.renderRenameInput(element, template, reader.store);
+            }
         }));
         if (this.approvalModel) {
             this.renderApprovalRow(element, template);
         }
     }
+    beginRename(item) {
+        const target = this.resolveRenameTarget(item);
+        if (!target) {
+            return false;
+        }
+        if (this.activeRenameInput && this.isSameChat(this.activeRenameInput.item, target)) {
+            this.activeRenameInput.input.focus();
+            this.activeRenameInput.input.select();
+            return true;
+        }
+        if (!this.renameState || !this.isSameChat(this.renameState.item, target)) {
+            const initialValue = getChatTitle(target.chat);
+            this.renameState = {
+                item: target,
+                initialValue,
+                value: initialValue
+            };
+        }
+        this.editingChat.set(target, undefined);
+        return true;
+    }
+    canRename(item) {
+        return !!this.resolveRenameTarget(item);
+    }
+    isSameChat(first, second) {
+        return isEqual(first.session.resource, second.session.resource) && isEqual(first.chat.resource, second.chat.resource);
+    }
+    resolveRenameTarget(item) {
+        const session = this.sessionsManagementService.getSessions().find(session => isEqual(session.resource, item.session.resource));
+        const chat = session?.chats.get().find(chat => isEqual(chat.resource, item.chat.resource));
+        if (!session || !chat || isEqual(chat.resource, session.mainChat.get().resource) || chat.status.get() === SessionStatus.Untitled || !getChatCapabilities(chat, session, undefined).canRename) {
+            return undefined;
+        }
+        return {
+            session,
+            chat
+        };
+    }
+    renderRenameInput(item, template, disposables) {
+        const renameState = this.renameState;
+        if (!renameState || !this.isSameChat(renameState.item, item)) {
+            return;
+        }
+        const input = renderInlineRenameInput(
+            template.titleInputContainer,
+            this.contextViewService,
+            renameState,
+            ( localize(6112, "Rename chat. Press Enter to confirm or Escape to cancel.")),
+            disposables,
+            (title, restoreListFocus) => {
+                this.editingChat.set(undefined, undefined);
+                this.renameState = undefined;
+                if (restoreListFocus) {
+                    this.onDidFinishRename();
+                }
+                const target = this.resolveRenameTarget(item);
+                if (title && target) {
+                    this.sessionsManagementService.renameChat(target.session, target.chat.resource, title).catch(onUnexpectedError);
+                }
+            }
+        );
+        this.activeRenameInput = {
+            item,
+            input
+        };
+        disposables.add(toDisposable(() => {
+            if (this.activeRenameInput?.input === input) {
+                this.activeRenameInput = undefined;
+            }
+        }));
+    }
     renderApprovalRow(element, template) {
         if (!this.approvalModel || !this.markdownRendererService) {
             return;
@@ -424,7 +871,11 @@ class SessionChatItemRenderer {
             }
         }));
     }
-    disposeElement(_node, _index, template) {
+    disposeElement(node, _index, template) {
+        if (isSessionChatItem(node.element) && this.renameState && this.isSameChat(this.renameState.item, node.element) && !this.resolveRenameTarget(node.element)) {
+            this.editingChat.set(undefined, undefined);
+            this.renameState = undefined;
+        }
         template.elementDisposables.clear();
     }
     disposeTemplate(template) {
@@ -434,6 +885,19 @@ class SessionChatItemRenderer {
 function approvalRowHeightFor(info, maxLines) {
     return info ? SessionItemRenderer.getApprovalRowHeight(info.label, maxLines) : 0;
 }
+function getCompactInputNeededMessage(session, reader, options, approvalModel) {
+    if (!options.compact?.()) {
+        return undefined;
+    }
+    const sessionStatus = getSessionRowStatus(
+        session,
+        reader,
+        !!options.deriveStatusFromMainChat,
+        options.collapsedSessionIds?.read(reader).has(session.sessionId) ?? true
+    );
+    const approval = approvalModel ? getSessionRowApproval(approvalModel, session, reader, options.aggregateChatApprovals ?? false) : undefined;
+    return sessionStatus === SessionStatus.NeedsInput && !approval ? getSessionStatusMessage(sessionStatus, session.description.read(reader)) : undefined;
+}
 function renderApprovalRowContent(
     info,
     elements,
@@ -468,12 +932,12 @@ function renderApprovalRowContent(
     }
     elements.buttonContainer.textContent = "";
     const button = store.add(( new Button(elements.buttonContainer, {
-        title: ( localize(4899, "Allow once")),
-        ariaLabel: ( localize(4900, "Allow once: {0}", info.label)),
+        title: ( localize(6113, "Allow once")),
+        ariaLabel: ( localize(6114, "Allow once: {0}", info.label)),
         secondary: true,
         ...defaultButtonStyles
     })));
-    button.label = ( localize(4901, "Allow"));
+    button.label = ( localize(6115, "Allow"));
     store.add(button.onDidClick(() => {
         const approvalId = agentSessionApprovalId(info);
         info.confirm();
@@ -500,6 +964,82 @@ class SessionItemActionRunner extends ActionRunner {
 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";
+function renderInlineRenameInput(container, contextViewService, state, ariaLabel, disposables, onFinish) {
+    clearNode(container);
+    const input = ( new InputBox(container, contextViewService, {
+        inputBoxStyles: defaultInputBoxStyles,
+        ariaLabel,
+        validationOptions: {
+            validation: value => value.trim() ? null : {
+                content: ( localize(6116, "Title cannot be empty")),
+                type: MessageType.ERROR
+            }
+        }
+    }));
+    disposables.add(toDisposable(() => {
+        state.selection = {
+            start: input.inputElement.selectionStart ?? input.value.length,
+            end: input.inputElement.selectionEnd ?? input.value.length,
+            direction: input.inputElement.selectionDirection ?? "none"
+        };
+        state.wasFocused = isActiveElement(input.inputElement);
+        input.hideMessage();
+        input.dispose();
+    }));
+    input.value = state.value;
+    if (state.selection) {
+        if (state.wasFocused) {
+            input.focus();
+        }
+        input.inputElement.setSelectionRange(state.selection.start, state.selection.end, state.selection.direction);
+    } else {
+        input.focus();
+        input.select();
+    }
+    let done = false;
+    const finish = (commit, restoreListFocus) => {
+        if (done) {
+            return;
+        }
+        const title = input.value.trim();
+        if (commit && !title) {
+            if (restoreListFocus) {
+                input.validate();
+                input.focus();
+                return;
+            }
+            commit = false;
+        }
+        done = true;
+        input.hideMessage();
+        onFinish(
+            commit && title !== state.initialValue.trim() ? title : undefined,
+            restoreListFocus
+        );
+    };
+    disposables.add(
+        addDisposableListener(input.inputElement, EventType.INPUT, () => state.value = input.value)
+    );
+    disposables.add(
+        addStandardDisposableListener(input.inputElement, EventType.KEY_DOWN, event => {
+            if (event.equals(KeyCode.Enter)) {
+                event.preventDefault();
+                event.stopPropagation();
+                finish(true, true);
+            } else if (event.equals(KeyCode.Escape)) {
+                event.preventDefault();
+                event.stopPropagation();
+                finish(false, true);
+            }
+        })
+    );
+    disposables.add(
+        addDisposableListener(input.inputElement, EventType.BLUR, () => finish(true, false))
+    );
+    disposables.add(toDisposable(() => clearNode(container)));
+    return input;
+}
+const SESSION_EXTERNAL_APPLICATION_BADGE_HOVERED_CLASS = "external-application-badge-hovered";
 class SessionItemRenderer {
     static {
         this.TEMPLATE_ID = "session-item";
@@ -557,30 +1097,12 @@ class SessionItemRenderer {
         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)
-        };
+        this.editingSession = observableValue(this, undefined);
     }
     renderTemplate(container) {
         const disposables = ( new DisposableStore());
         const elementDisposables = disposables.add(( new DisposableStore()));
+        const renderedSession = observableValue("renderedSession", undefined);
         container.classList.add("session-item");
         const iconContainer = append(container, $(".session-icon"));
         const statusIcon = disposables.add(this.instantiationService.createInstance(SessionStatusIcon, iconContainer));
@@ -588,6 +1110,31 @@ class SessionItemRenderer {
         const titleRow = append(mainCol, $(".session-title-row"));
         const titleContainer = append(titleRow, $(".session-title"));
         const title = disposables.add(( new HighlightedLabel(titleContainer)));
+        const externalApplicationBadge = append(titleRow, $(
+            "span.session-external-application-badge.session-external-application-badge-title"
+        ));
+        externalApplicationBadge.setAttribute("aria-hidden", "true");
+        const externalApplicationBadgeLabel = append(
+            externalApplicationBadge,
+            $("span.session-external-application-badge-label")
+        );
+        disposables.add(
+            addDisposableListener(externalApplicationBadge, EventType.MOUSE_ENTER, () => {
+                externalApplicationBadge.closest(".monaco-list-row")?.classList.add(SESSION_EXTERNAL_APPLICATION_BADGE_HOVERED_CLASS);
+            })
+        );
+        disposables.add(
+            addDisposableListener(externalApplicationBadge, EventType.MOUSE_LEAVE, () => {
+                externalApplicationBadge.closest(".monaco-list-row")?.classList.remove(SESSION_EXTERNAL_APPLICATION_BADGE_HOVERED_CLASS);
+            })
+        );
+        const titleInputContainer = append(titleRow, $(".session-title-input.session-inline-rename-input"));
+        for (const eventType of ["pointerdown", "pointerup", "click", "dblclick"]) {
+            disposables.add(
+                addDisposableListener(titleInputContainer, eventType, e => e.stopPropagation())
+            );
+        }
+        disposables.add(Gesture.ignoreTarget(titleInputContainer));
         disposables.add(
             addDisposableListener(titleContainer, EventType.ANIMATION_START, e => {
                 if (e.target === titleContainer && e.animationName === SESSION_TITLE_SHIMMER_ANIMATION_NAME) {
@@ -601,8 +1148,13 @@ class SessionItemRenderer {
             pausedClass: SESSION_TITLE_SHIMMER_PAUSED_CLASS,
             animationNames: SESSION_TITLE_SHIMMER_ANIMATION_NAMES
         }));
+        const compactHoverDescription = append(titleRow, $(".session-compact-hover-description"));
         const titleToolbarContainer = append(titleRow, $(".session-title-toolbar"));
         const pendingVoiceIndicator = append(titleRow, $(".session-pending-voice-indicator"));
+        const comparisonAttemptStatus = append(titleRow, $("span.session-comparison-attempt-status"));
+        const comparisonAttemptStatusIcon = append(comparisonAttemptStatus, $("span.session-comparison-attempt-status-icon"));
+        comparisonAttemptStatusIcon.setAttribute("aria-hidden", "true");
+        const comparisonAttemptStatusLabel = append(comparisonAttemptStatus, $("span.session-comparison-attempt-status-label"));
         for (const eventType of ["pointerdown", "pointerup", "click", "dblclick"]) {
             disposables.add(
                 addDisposableListener(titleToolbarContainer, eventType, e => e.stopPropagation())
@@ -613,6 +1165,9 @@ class SessionItemRenderer {
         const approvalRow = append(mainCol, $(".session-approval-row"));
         const approvalLabel = append(approvalRow, $("span.session-approval-label"));
         const approvalButtonContainer = append(approvalRow, $(".session-approval-button"));
+        const inputNeededRow = append(mainCol, $(".session-input-needed-row.session-approval-row"));
+        inputNeededRow.setAttribute("aria-hidden", "true");
+        const inputNeededLabel = append(inputNeededRow, $("span.session-input-needed-label"));
         const ciRow = append(mainCol, $(".session-ci-row"));
         const ciLabel = append(ciRow, $("span.session-ci-label"));
         const ciButtonContainer = append(ciRow, $(".session-ci-button"));
@@ -624,10 +1179,11 @@ class SessionItemRenderer {
         const statusContext = SessionItemStatusContext.bindTo(contextKeyService);
         const isReadContext = SessionIsReadContext.bindTo(contextKeyService);
         const isArchivedContext = SessionIsArchivedContext.bindTo(contextKeyService);
+        const isQuickChatContext = IsQuickChatSessionContext.bindTo(contextKeyService);
+        const supportsMultipleChatsContext = SessionSupportsMultipleChatsContext.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);
@@ -637,11 +1193,12 @@ class SessionItemRenderer {
                         shouldForwardArgs: true
                     },
                     actionRunner,
+                    telemetrySource: this.options.toolbarTelemetrySource,
                     actionViewItemProvider: (action, options) => {
-                        if (action.id !== ARCHIVE_SESSION_COMMAND_ID || !(action instanceof MenuItemAction) || !this.options.archiveOnboardingSession) {
+                        if (action.id !== ARCHIVE_SESSION_COMMAND_ID || !(action instanceof MenuItemAction) || !this.options.onboardingTarget) {
                             return actionViewItemProvider(action, options);
                         }
-                        return scopedInstantiationService.createInstance(class extends MenuEntryActionViewItem {
+                        return scopedInstantiationService.createInstance(class extends SessionArchiveActionViewItem {
                             render(container) {
                                 super.render(container);
                                 this._register(autorun(reader => {
@@ -662,14 +1219,24 @@ class SessionItemRenderer {
             container,
             statusIcon,
             title,
+            titleRow,
             titleContainer,
+            externalApplicationBadge,
+            externalApplicationBadgeLabel,
+            titleInputContainer,
+            compactHoverDescription,
             titleToolbar,
             renderedSession,
             pendingVoiceIndicator,
+            comparisonAttemptStatus,
+            comparisonAttemptStatusIcon,
+            comparisonAttemptStatusLabel,
             detailsRow,
             approvalRow,
             approvalLabel,
             approvalButtonContainer,
+            inputNeededRow,
+            inputNeededLabel,
             ciRow,
             ciLabel,
             ciButtonContainer,
@@ -677,6 +1244,8 @@ class SessionItemRenderer {
             statusContext,
             isReadContext,
             isArchivedContext,
+            isQuickChatContext,
+            supportsMultipleChatsContext,
             supportsDeleteContext,
             disposables,
             elementDisposables
@@ -691,62 +1260,75 @@ class SessionItemRenderer {
     }
     renderSession(element, template, matches) {
         template.elementDisposables.clear();
+        template.container.closest(".monaco-list-row")?.classList.remove(SESSION_EXTERNAL_APPLICATION_BADGE_HOVERED_CLASS);
         template.renderedSession.set(element, undefined);
         template.elementDisposables.add(toDisposable(() => {
             template.renderedSession.set(undefined, undefined);
-            template.container.classList.remove("archive-onboarding");
+            template.container.classList.remove("archive-onboarding", "renaming");
         }));
-        if (this.options.archiveOnboardingSession) {
+        if (this.options.onboardingTarget) {
             template.elementDisposables.add(autorun(reader => {
-                template.container.classList.toggle(
-                    "archive-onboarding",
-                    this.options.archiveOnboardingSession?.read(reader)?.sessionId === element.sessionId
-                );
+                const target = this.options.onboardingTarget?.read(reader);
+                const isTarget = target?.session.sessionId === element.sessionId;
+                template.container.classList.toggle("archive-onboarding", isTarget && target.archiveAction);
+                if (isTarget && !target.archiveAction) {
+                    reader.store.add(
+                        markOnboardingTarget(template.container, getSessionOnboardingTargetId(element))
+                    );
+                }
             }));
         }
-        if (this.options.onDidRequestRename) {
+        const groupConnectorPosition = this.options.getGroupConnectorPosition?.(element);
+        const comparisonAttemptLabel = this.options.getComparisonAttemptLabel?.(element);
+        template.container.classList.toggle("session-comparison-attempt", comparisonAttemptLabel !== undefined);
+        if (groupConnectorPosition) {
+            template.container.dataset.sessionGroupConnector = groupConnectorPosition;
+        } else {
+            delete template.container.dataset.sessionGroupConnector;
+        }
+        if (this.options.inlineRename) {
             template.elementDisposables.add(
-                addDisposableListener(template.title.element, EventType.DBLCLICK, event => {
+                addDisposableListener(template.titleRow, 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);
+                    if (this.beginRename(element)) {
+                        this.options.onDidDoubleClickRename?.(element);
+                    }
                 })
             );
         }
         this.agentSessionsService.model.observeSession(element.resource);
         if (this.options.showHover) {
-            template.elementDisposables.add(this.hoverService.setupDelayedHover(template.container, () => ({
-                content: ( new SessionSummaryHoverWidget(getSessionSummaryHoverData(
+            template.elementDisposables.add(this.hoverService.setupDelayedHover(
+                template.container,
+                () => withSessionsListHoverPresentation(createSessionSummaryHover(element, 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
+                    getCreatorHoverData(
+                        element,
+                        this.sessionsManagementService,
+                        this.agentHostConnectionsService,
+                        this.openerService
+                    ),
+                    this.options.compact()
+                ), this.preferencesService)),
+                {
+                    groupId: "sessions-list"
                 }
-            }), {
-                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(4902, "Voice response ready"))
+            ( localize(6117, "Voice response ready"))
         ));
         template.elementDisposables.add(autorun(reader => {
             this._voicePlaybackService.pendingResponseVersion.read(reader);
@@ -760,7 +1342,8 @@ class SessionItemRenderer {
         }
         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());
+        SessionItemInExternalSectionContext.bindTo(template.contextKeyService).set(this.options.isRenderedInExternalSection?.(element) ?? false);
+        const canImportContext = SessionItemCanImportContext.bindTo(template.contextKeyService);
         template.elementDisposables.add(autorun(reader => {
             const isArchived = element.isArchived.read(reader);
             template.container.classList.toggle("archived", isArchived);
@@ -777,16 +1360,22 @@ class SessionItemRenderer {
         }));
         let agentMergeConfiguration;
         template.elementDisposables.add(autorun(reader => {
-            const sessionStatus = getSessionRowStatus(element, reader, !!this.options.deriveStatusFromMainChat);
+            const collapsed = this.options.collapsedSessionIds?.read(reader).has(element.sessionId) ?? true;
+            const sessionStatus = getSessionRowStatus(element, reader, !!this.options.deriveStatusFromMainChat, collapsed);
             template.statusContext.set(sessionStatus);
-            const isRead = element.isRead.read(reader);
-            template.isReadContext.set(isRead);
+            const isRead = getSessionRowIsRead(element, reader, !!this.options.deriveStatusFromMainChat);
+            template.isReadContext.set(element.mainChat.read(reader).isRead.read(reader));
             const isArchived = element.isArchived.read(reader);
             template.isArchivedContext.set(isArchived);
+            const isQuickChat = element.isQuickChat?.read(reader) ?? false;
             const capabilities = element.capabilities.read(reader);
+            canImportContext.set(
+                element.isExternal?.read(reader) === true && capabilities.supportsImport === true
+            );
+            template.isQuickChatContext.set(isQuickChat);
+            template.supportsMultipleChatsContext.set(capabilities.supportsMultipleChats);
             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);
@@ -797,32 +1386,126 @@ class SessionItemRenderer {
             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);
+            let showComparisonAttemptStatus = comparisonAttemptLabel !== undefined && (this.options.shouldShowComparisonAttemptStatus?.(element, reader) ?? true);
+            template.comparisonAttemptStatusIcon.className = "session-comparison-attempt-status-icon";
+            switch (sessionStatus) {
+            case SessionStatus.InProgress:
+                template.comparisonAttemptStatusIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.loading), "codicon-modifier-spin");
+                template.comparisonAttemptStatusLabel.textContent = "";
+                break;
+            case SessionStatus.NeedsInput:
+                template.comparisonAttemptStatusLabel.textContent = ( localize(6118, "Attention needed"));
+                break;
+            case SessionStatus.Completed:
+                template.comparisonAttemptStatusLabel.textContent = "";
+                showComparisonAttemptStatus = false;
+                break;
+            case SessionStatus.Error:
+                template.comparisonAttemptStatusLabel.textContent = ( localize(6119, "Failed"));
+                break;
+            default:
+                template.comparisonAttemptStatusLabel.textContent = ( localize(6120, "Pending"));
+            }
+            template.comparisonAttemptStatus.classList.toggle("visible", showComparisonAttemptStatus);
         }));
         template.elementDisposables.add(autorun(reader => {
-            const titleText = element.title.read(reader);
+            const titleText = comparisonAttemptLabel ?? element.title.read(reader);
             template.title.set(titleText, matches);
         }));
+        template.elementDisposables.add(autorun(reader => {
+            const eligible = isExternalApplicationBadgeEligible(element, reader);
+            if (!eligible) {
+                template.externalApplicationBadge.classList.remove("visible");
+                return;
+            }
+            this.options.reportExternalApplicationBadgeModeExperimentTrigger?.();
+            const mode = this.options.externalApplicationBadgeMode?.read(reader) ?? ExternalSessionApplicationBadgeMode.Off;
+            if (eligible && mode !== ExternalSessionApplicationBadgeMode.Off) {
+                this.options.reportExternalApplicationBadgeShowFromExperimentTrigger?.();
+            }
+            template.externalApplicationBadge.classList.toggle("visible", eligible && mode === ExternalSessionApplicationBadgeMode.Title);
+            const badgeLabel = getExternalApplicationBadgeLabel(
+                element.application.read(reader).label,
+                this.options.externalApplicationBadgeShowFrom?.read(reader) ?? true
+            );
+            template.externalApplicationBadgeLabel.textContent = badgeLabel;
+            if (mode === ExternalSessionApplicationBadgeMode.Title) {
+                reader.store.add(this.hoverService.setupDelayedHover(template.externalApplicationBadge, {
+                    content: badgeLabel
+                }, {
+                    groupId: "sessions-list"
+                }));
+            }
+        }));
+        template.elementDisposables.add(autorun(reader => {
+            const editingSession = this.editingSession.read(reader);
+            const editing = !!editingSession && isEqual(editingSession.resource, element.resource);
+            template.container.classList.toggle("renaming", editing);
+            if (editing) {
+                this.renderRenameInput(element, template, reader.store);
+            }
+        }));
         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 sessionStatus = getSessionRowStatus(
+                element,
+                reader,
+                !!this.options.deriveStatusFromMainChat,
+                this.options.collapsedSessionIds?.read(reader).has(element.sessionId) ?? true
+            );
             const workspace = element.workspace.read(reader);
             const description = element.description.read(reader);
             const isQuickChat = element.isQuickChat?.read(reader) ?? false;
+            const eligible = isExternalApplicationBadgeEligible(element, reader);
             clearNode(template.detailsRow);
-            if (isQuickChat && this.options.useCompactQuickChatRows) {
+            clearNode(template.compactHoverDescription);
+            if (comparisonAttemptLabel !== undefined || (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 workspaceBadgeLabel = workspace && (this.options.grouping() !== SessionsGrouping.Workspace || this.options.isPinned(element) || element.isArchived.read(reader) || this.options.isRenderedInCustomGroup?.(element) || this.options.isRenderedInExternalSection?.(element)) ? getWorkspaceBadgeLabel(workspace) : undefined;
+            if (this.options.compact()) {
+                descriptionDisposable.clear();
+                timeDisposable.clear();
+                if (workspaceBadgeLabel) {
+                    append(
+                        template.compactHoverDescription,
+                        $("span.session-badge", undefined, workspaceBadgeLabel)
+                    );
+                }
+                return;
             }
+            const diffStats = this.options.deriveStatusFromMainChat && (workspace?.folders.length ?? 0) > 1 ? getSessionListChatDiffStats(element, element.mainChat.read(reader), this.options.activeSession, reader) : getSessionDiffStats(element, reader);
+            const hideDetails = sessionStatus === SessionStatus.InProgress || sessionStatus === SessionStatus.NeedsInput;
+            const mainChat = element.mainChat.read(reader);
+            const timeDate = mainChat.status.read(reader) === SessionStatus.InProgress ? undefined : mainChat.updatedAt.read(reader);
             const parts = [];
+            if (eligible && this.options.externalApplicationBadgeMode?.read(reader) === ExternalSessionApplicationBadgeMode.Details) {
+                const badgeEl = append(template.detailsRow, $(
+                    "span.session-external-application-badge.session-external-application-badge-details"
+                ));
+                const badgeLabel = getExternalApplicationBadgeLabel(
+                    element.application.read(reader).label,
+                    this.options.externalApplicationBadgeShowFrom?.read(reader) ?? true
+                );
+                append(
+                    badgeEl,
+                    $("span.session-external-application-badge-label", undefined, badgeLabel)
+                );
+                reader.store.add(this.hoverService.setupDelayedHover(badgeEl, {
+                    content: badgeLabel
+                }, {
+                    groupId: "sessions-list"
+                }));
+                parts.push(badgeEl);
+            }
+            const statusMessage = getSessionStatusMessage(sessionStatus, description);
             if (sessionStatus !== SessionStatus.InProgress) {
+                if (parts.length > 0) {
+                    append(template.detailsRow, $("span.session-separator.has-separator"));
+                }
                 let icon;
                 if (isQuickChat) {
                     icon = Codicon.commentDiscussion;
@@ -835,7 +1518,7 @@ class SessionItemRenderer {
                 parts.push(typeIconEl);
             }
             if (!hideDetails) {
-                const badgeLabel = isQuickChat ? ( localize(4903, "No workspace")) : workspace && (this.options.grouping() !== SessionsGrouping.Workspace || this.options.isPinned(element) || element.isArchived.read(reader) || this.options.isRenderedInCustomGroup?.(element)) ? getWorkspaceBadgeLabel(workspace) : undefined;
+                const badgeLabel = isQuickChat ? ( localize(6121, "No workspace")) : workspaceBadgeLabel;
                 if (badgeLabel) {
                     const badgeEl = append(template.detailsRow, $("span.session-badge"));
                     badgeEl.textContent = badgeLabel;
@@ -851,7 +1534,6 @@ class SessionItemRenderer {
                 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"));
@@ -871,16 +1553,13 @@ class SessionItemRenderer {
             } else {
                 descriptionDisposable.clear();
             }
-            if (!hideDetails && timeDate) {
+            if (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(4904, "now")) : fromNow(definiteTimeDate, true);
-                };
+                const formatTime = () => formatSessionListTime(definiteTimeDate);
                 timeEl.textContent = formatTime();
                 const targetWindow = getWindow(timeEl);
                 const interval = targetWindow.setInterval(() => {
@@ -894,10 +1573,47 @@ class SessionItemRenderer {
         if (this.approvalModel) {
             this.renderApprovalRow(element, template);
         }
+        this.renderCompactInputNeededRow(element, template);
         if (this.ciFixModel) {
             this.renderCIRow(element, template);
         }
     }
+    renderCompactInputNeededRow(element, template) {
+        const contentStore = template.elementDisposables.add(( new DisposableStore()));
+        let wasVisible = !!getCompactInputNeededMessage(element, undefined, this.options, this.approvalModel);
+        template.inputNeededRow.classList.toggle("visible", wasVisible);
+        template.elementDisposables.add(autorun(reader => {
+            contentStore.clear();
+            const message = getCompactInputNeededMessage(element, reader, this.options, this.approvalModel);
+            const visible = !!message;
+            template.inputNeededRow.classList.toggle("visible", visible);
+            template.inputNeededLabel.textContent = "";
+            if (message) {
+                if (typeof message === "string") {
+                    template.inputNeededLabel.textContent = message;
+                } else {
+                    contentStore.add(this.markdownRendererService.render(message, {
+                        sanitizerConfig: {
+                            replaceWithPlaintext: true
+                        }
+                    }, template.inputNeededLabel));
+                }
+                if (this.options.showHover) {
+                    contentStore.add(this.hoverService.setupDelayedHover(template.inputNeededLabel, {
+                        content: message,
+                        style: HoverStyle.Pointer,
+                        position: {
+                            hoverPosition: HoverPosition.BELOW
+                        }
+                    }));
+                }
+            }
+            if (wasVisible !== visible) {
+                wasVisible = visible;
+                this._onDidChangeItemHeight.fire(element);
+            }
+        }));
+    }
     renderApprovalRow(element, template) {
         if (!this.approvalModel) {
             return;
@@ -946,16 +1662,16 @@ class SessionItemRenderer {
             const visible = !!state;
             template.ciRow.classList.toggle("visible", visible);
             if (state) {
-                template.ciLabel.textContent = ( localize(4905, "{0} checks failed, {1} pending", state.failed, state.pending));
+                template.ciLabel.textContent = ( localize(6122, "{0} checks failed, {1} pending", state.failed, state.pending));
                 template.ciButtonContainer.textContent = "";
                 const button = buttonStore.add(( new Button(template.ciButtonContainer, {
-                    title: ( localize(4906, "Fix failing CI checks")),
+                    title: ( localize(6123, "Fix failing CI checks")),
                     ...defaultButtonStyles,
                     buttonBackground: asCssVariable(chartsOrange),
                     buttonHoverBackground: `color-mix(in srgb, ${asCssVariable(chartsOrange)} 88%, black)`,
                     buttonBorder: asCssVariable(chartsOrange)
                 })));
-                button.label = ( localize(4907, "Fix CI"));
+                button.label = ( localize(6124, "Fix CI"));
                 buttonStore.add(button.onDidClick(() => ciFixModel.fixCI(element)));
             }
             if (wasVisible !== visible) {
@@ -964,7 +1680,75 @@ class SessionItemRenderer {
             }
         }));
     }
-    disposeElement(_node, _index, template) {
+    beginRename(session) {
+        const target = this.resolveRenameTarget(session);
+        if (!target) {
+            return false;
+        }
+        if (this.activeRenameInput && isEqual(this.activeRenameInput.session.resource, target.resource)) {
+            this.activeRenameInput.input.focus();
+            this.activeRenameInput.input.select();
+            return true;
+        }
+        if (!this.renameState || !isEqual(this.renameState.session.resource, target.resource)) {
+            const initialValue = target.title.get();
+            this.renameState = {
+                session: target,
+                initialValue,
+                value: initialValue
+            };
+        }
+        this.editingSession.set(target, undefined);
+        return true;
+    }
+    renderRenameInput(session, template, disposables) {
+        const renameState = this.renameState;
+        if (!renameState || !isEqual(renameState.session.resource, session.resource)) {
+            return;
+        }
+        if (!this.options.contextViewService) {
+            throw ( new Error("Inline rename requires a context view service"));
+        }
+        const input = renderInlineRenameInput(
+            template.titleInputContainer,
+            this.options.contextViewService,
+            renameState,
+            ( localize(6125, "Rename session. Press Enter to confirm or Escape to cancel.")),
+            disposables,
+            (title, restoreListFocus) => {
+                this.editingSession.set(undefined, undefined);
+                this.renameState = undefined;
+                if (restoreListFocus) {
+                    this.options.onDidFinishRename?.();
+                }
+                const target = this.resolveRenameTarget(session);
+                if (title && target) {
+                    this.sessionsManagementService.renameSession(target, title).catch(onUnexpectedError);
+                }
+            }
+        );
+        this.activeRenameInput = {
+            session,
+            input
+        };
+        disposables.add(toDisposable(() => {
+            if (this.activeRenameInput?.input === input) {
+                this.activeRenameInput = undefined;
+            }
+        }));
+    }
+    resolveRenameTarget(session) {
+        if (!this.options.inlineRename) {
+            return undefined;
+        }
+        const target = this.sessionsManagementService.getSessions().find(candidate => isEqual(candidate.resource, session.resource));
+        return target?.capabilities.get().supportsRename ? target : undefined;
+    }
+    disposeElement(node, _index, template) {
+        if (isSessionItem(node.element) && this.renameState && isEqual(this.renameState.session.resource, node.element.resource) && !this.resolveRenameTarget(node.element)) {
+            this.editingSession.set(undefined, undefined);
+            this.renameState = undefined;
+        }
         template.elementDisposables.clear();
     }
     disposeTemplate(template) {
@@ -974,6 +1758,16 @@ class SessionItemRenderer {
 function getSessionArchiveOnboardingTargetId(session) {
     return `sessions.archiveAction.${session.sessionId}`;
 }
+function getSessionOnboardingTargetId(session) {
+    return `sessions.session.${session.sessionId}`;
+}
+function getChatWorkspaceBadgeLabel(sessionWorkspace, chatWorkspace) {
+    const firstSessionFolder = sessionWorkspace?.folders[0];
+    if (!firstSessionFolder || !( sessionWorkspace.folders.some(folder => !isEqual(folder.root, firstSessionFolder.root))) || chatWorkspace?.folders.length !== 1) {
+        return undefined;
+    }
+    return chatWorkspace.folders[0].name;
+}
 function getWorkspaceBadgeLabel(workspace) {
     const folder = workspace.folders[0];
     if (folder?.root.scheme === GITHUB_REMOTE_FILE_SCHEME) {
@@ -982,7 +1776,98 @@ function getWorkspaceBadgeLabel(workspace) {
             return `${parts[0]}/${parts[1]}`;
         }
     }
-    return workspace.label;
+    return workspace.label;
+}
+function isExternalApplicationBadgeEligible(session, reader) {
+    const application = session.isExternal?.read(reader) === true ? session.application?.read(reader) : undefined;
+    return application !== undefined && application.id !== "vscode";
+}
+function getExternalApplicationBadgeLabel(applicationLabel, showFrom) {
+    return showFrom ? ( localize(6126, "From {0}", applicationLabel)) : applicationLabel;
+}
+function logDefaultSettingExperimentTrigger(configurationService, telemetryService, settingId) {
+    const inspected = configurationService.inspect(settingId);
+    if (!isConfigured(inspected) && inspected.memoryValue === undefined && inspected.policyValue === undefined) {
+        logSettingExperimentTrigger(telemetryService, settingId);
+    }
+}
+var SessionHeaderStatus;
+(function(SessionHeaderStatus) {
+    SessionHeaderStatus[SessionHeaderStatus["NeedsInput"] = 0] = "NeedsInput";
+    SessionHeaderStatus[SessionHeaderStatus["FailingCI"] = 1] = "FailingCI";
+    SessionHeaderStatus[SessionHeaderStatus["Unread"] = 2] = "Unread";
+})(SessionHeaderStatus || (SessionHeaderStatus = {}));
+function hasUnreadSessionListChat(session, reader) {
+    if (!session.mainChat.read(reader).isRead.read(reader)) {
+        return true;
+    }
+    return ( getSessionListChats(session, reader).some(chat => !chat.isRead.read(reader)));
+}
+function getSessionHeaderStatus(sessions, reader, sessionsWithFailingCI) {
+    let hasFailingCI = false;
+    let hasUnread = false;
+    for (const session of sessions) {
+        if (session.isArchived.read(reader)) {
+            continue;
+        }
+        const status = session.status.read(reader);
+        if (status === SessionStatus.NeedsInput) {
+            return SessionHeaderStatus.NeedsInput;
+        }
+        hasFailingCI ||= status !== SessionStatus.InProgress && sessionsWithFailingCI?.has(session.sessionId) === true;
+        hasUnread ||= hasUnreadSessionListChat(session, reader);
+    }
+    return hasFailingCI ? SessionHeaderStatus.FailingCI : hasUnread ? SessionHeaderStatus.Unread : undefined;
+}
+function couldShowSessionHeaderStatus(sessions, reader) {
+    return ( sessions.some(session => {
+        if (session.isArchived.read(reader)) {
+            return false;
+        }
+        const status = session.status.read(reader);
+        return status === SessionStatus.NeedsInput || hasUnreadSessionListChat(session, reader) || (status !== SessionStatus.InProgress && !!session.workspace.read(reader)?.folders[0]?.gitRepository?.gitHubInfo.read(reader)?.pullRequest);
+    }));
+}
+function renderSessionHeaderIcon(
+    template,
+    sessions,
+    icon,
+    showUnreadInCollapsedSections,
+    sessionsWithFailingCI,
+    statusTrigger,
+    instantiationService,
+    iconOverride
+) {
+    template.elementDisposables.add(autorun(reader => {
+        if (statusTrigger.pending.read(reader) && (template.collapsed.read(reader) || statusTrigger.includeExpanded.read(reader)) && couldShowSessionHeaderStatus(sessions, reader)) {
+            statusTrigger.report();
+        }
+    }));
+    const headerStatus = derived(
+        reader => template.collapsed.read(reader) && showUnreadInCollapsedSections.read(reader) ? getSessionHeaderStatus(sessions, reader, sessionsWithFailingCI.read(reader)) : undefined
+    );
+    template.elementDisposables.add(autorun(reader => {
+        const status = headerStatus.read(reader);
+        const renderedIcon = iconOverride?.read(reader) ?? icon;
+        clearNode(template.icon);
+        template.icon.className = "session-section-icon";
+        template.icon.style.color = renderedIcon?.color ? asCssVariable(renderedIcon.color.id) : "";
+        template.icon.style.display = status !== undefined || renderedIcon ? "" : "none";
+        if (status !== undefined) {
+            const statusIcon = reader.store.add(instantiationService.createInstance(SessionStatusIcon, template.icon));
+            statusIcon.setStatus(
+                status === SessionHeaderStatus.NeedsInput ? SessionStatus.NeedsInput : SessionStatus.Completed,
+                status !== SessionHeaderStatus.Unread,
+                false,
+                status === SessionHeaderStatus.FailingCI ? {
+                    ...Codicon.circleFilled,
+                    color: themeColorFromId("list.warningForeground")
+                } : undefined
+            );
+        } else if (renderedIcon) {
+            template.icon.classList.add(...ThemeIcon.asClassNameArray(renderedIcon));
+        }
+    }));
 }
 function renderSessionHeaderToolbar(template, element, select) {
     template.elementDisposables.add(addDisposableListener(
@@ -1000,26 +1885,45 @@ class SessionSectionRenderer {
     constructor(
         hideSectionCount,
         select,
+        showUnreadInCollapsedSections,
+        sessionsWithFailingCI,
+        headerStatusTrigger,
         instantiationService,
+        hoverService,
         contextKeyService,
         automationService,
         automationSessions,
-        automationNewBadgePresentation,
         uriIdentityService,
         customViewService,
-        menuService
+        menuService,
+        keybindingService,
+        customizationsActive = constObservable(false),
+        customizationMigrationsAvailable = constObservable(false),
+        templateId = SessionSectionRenderer.TEMPLATE_ID,
+        rowClassName,
+        onboardingOptions = {
+            onDidActivateNewSession: Event.None
+        }
     ) {
         this.hideSectionCount = hideSectionCount;
         this.select = select;
+        this.showUnreadInCollapsedSections = showUnreadInCollapsedSections;
+        this.sessionsWithFailingCI = sessionsWithFailingCI;
+        this.headerStatusTrigger = headerStatusTrigger;
         this.instantiationService = instantiationService;
+        this.hoverService = hoverService;
         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.keybindingService = keybindingService;
+        this.customizationsActive = customizationsActive;
+        this.customizationMigrationsAvailable = customizationMigrationsAvailable;
+        this.templateId = templateId;
+        this.rowClassName = rowClassName;
+        this.onboardingOptions = onboardingOptions;
         this.templatesByElement = ( new WeakMap());
         this.templatesById = ( new Map());
         this.automationStatus = derived(this, reader => {
@@ -1055,22 +1959,31 @@ class SessionSectionRenderer {
             }
             return undefined;
         });
+        this.customizationsIcon = derived(this, reader => this.customizationMigrationsAvailable.read(reader) ? {
+            ...Codicon.circleFilled,
+            color: themeColorFromId("activityWarningBadge.background")
+        } : 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(4908, "More Actions")))));
+        const dropdownAction = disposables.add(( new Action("sessionsView.sectionNewSession.moreActions", ( localize(6127, "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 labelContainer = append(container, $("span.session-section-label-container"));
+        const label = append(labelContainer, $("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(4909, "New"));
+        const countLabel = append(count, $("span.session-section-count-label"));
+        const keybindingHint = append(container, $("span.session-section-keybinding"));
+        keybindingHint.setAttribute("aria-hidden", "true");
+        const keybindingLabel = disposables.add(( new KeybindingLabel(keybindingHint, OS, {
+            ...defaultKeybindingLabelStyles,
+            disableTitle: true
+        })));
         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]))));
@@ -1079,7 +1992,14 @@ class SessionSectionRenderer {
                 menuOptions: {
                     shouldForwardArgs: true
                 },
+                telemetrySource: "sessionsList.section",
                 actionViewItemProvider: (action, options) => {
+                    if (action instanceof SubmenuItemAction) {
+                        return createActionViewItem(scopedInstantiationService, action, {
+                            ...options,
+                            skipTelemetry: true
+                        });
+                    }
                     if (action.id !== NEW_SESSION_FOR_WORKSPACE_ACTION_ID || !(action instanceof MenuItemAction)) {
                         return undefined;
                     }
@@ -1100,7 +2020,8 @@ class SessionSectionRenderer {
                         "",
                         {
                             hoverDelegate: options.hoverDelegate,
-                            menuAsChild: false
+                            menuAsChild: false,
+                            skipTelemetry: true
                         }
                     );
                     actionViewItemDisposables.add(
@@ -1114,9 +2035,12 @@ class SessionSectionRenderer {
         return {
             container,
             icon,
+            collapsed: observableValue(this, false),
             label,
             count,
-            newBadge,
+            countLabel,
+            keybindingHint,
+            keybindingLabel,
             toolbarContainer,
             toolbar,
             chevron,
@@ -1126,43 +2050,81 @@ class SessionSectionRenderer {
         };
     }
     renderElement(node, _index, template) {
-        template.elementDisposables.clear();
         const element = node.element;
         if (!isSessionSection(element)) {
             return;
         }
-        renderSessionHeaderToolbar(template, element, this.select);
+        this.renderSection(element, node.collapsible, node.collapsed, template);
+    }
+    renderShortcut(element, template) {
+        template.container.closest(".monaco-list-row")?.classList.add("session-list-shortcut-row");
+        this.renderSection(element, false, false, template);
+    }
+    renderSection(element, collapsible, collapsed, template) {
+        template.elementDisposables.clear();
         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.remove("session-section-new-session");
+        template.container.classList.remove("session-section-customizations");
+        template.container.classList.remove("active");
+        template.container.closest(".monaco-list-row")?.removeAttribute("aria-current");
+        template.keybindingHint.classList.remove("visible");
+        template.keybindingLabel.set(undefined);
+        const shortcut = isShortcutSection(element.id);
+        template.toolbarContainer.style.display = shortcut ? "none" : "";
+        if (shortcut) {
             template.container.classList.add("session-section-shortcut");
+            template.toolbar.context = undefined;
+        } else {
+            renderSessionHeaderToolbar(template, element, this.select);
         }
-        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 === NEW_SESSION_SECTION_ID) {
+            template.container.classList.add("session-section-new-session");
+            template.elementDisposables.add(markOnboardingTarget(template.container, "sessions.newSession.button", {
+                onDidActivate: this.onboardingOptions.onDidActivateNewSession,
+                focusTarget: this.onboardingOptions.getNewSessionFocusTarget?.()
+            }));
+            template.keybindingHint.classList.add("visible");
+            const updateKeybinding = () => template.keybindingLabel.set(
+                this.keybindingService.lookupKeybinding(NEW_SESSION_ACTION_ID, this.contextKeyService)
+            );
+            updateKeybinding();
+            template.elementDisposables.add(this.keybindingService.onDidUpdateKeybindings(updateKeybinding));
+        }
+        if (element.id === CUSTOMIZATIONS_SECTION_ID) {
+            template.container.classList.add("session-section-customizations");
+            template.elementDisposables.add(
+                this.hoverService.setupDelayedHover(template.container, () => withSessionsListHoverPresentation({
+                    content: this.customizationMigrationsAvailable.get() ? ( localize(6128, "Some customizations need an update to keep working.")) : element.label
+                }))
+            );
+            template.elementDisposables.add(autorun(reader => {
+                const active = this.customizationsActive.read(reader);
+                template.container.classList.toggle("active", active);
+                const row = template.container.closest(".monaco-list-row");
+                if (active) {
+                    row?.setAttribute("aria-current", "page");
+                } else {
+                    row?.removeAttribute("aria-current");
+                }
+            }));
+        }
+        this.updateChevron(template, collapsible, collapsed);
         if (element.id === AUTOMATIONS_SECTION_ID) {
+            clearNode(template.icon);
+            template.icon.style.display = "";
             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");
+                template.container.classList.toggle(
+                    "active",
+                    activeCustomView?.id === AUTOMATIONS_CUSTOM_VIEW_ID && !this.customizationsActive.read(reader)
+                );
             }));
             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);
@@ -1172,25 +2134,32 @@ class SessionSectionRenderer {
                 } 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)}`;
                 }
             }));
+        } else {
+            renderSessionHeaderIcon(
+                template,
+                element.sessions,
+                getSessionSectionIcon(element.id),
+                this.showUnreadInCollapsedSections,
+                this.sessionsWithFailingCI,
+                this.headerStatusTrigger,
+                this.instantiationService,
+                element.id === CUSTOMIZATIONS_SECTION_ID ? this.customizationsIcon : undefined
+            );
         }
         template.label.textContent = element.label;
-        if (this.hideSectionCount || element.id === AUTOMATIONS_SECTION_ID) {
-            template.count.textContent = "";
+        template.countLabel.style.display = "";
+        if (this.hideSectionCount || shortcut) {
+            template.countLabel.textContent = "";
             template.count.style.display = "none";
         } else {
-            template.count.textContent = String(element.sessions.length);
+            template.countLabel.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);
@@ -1221,6 +2190,7 @@ class SessionSectionRenderer {
         template?.container.classList.toggle(SESSION_HEADER_DROP_TARGET_CLASS, active);
     }
     updateChevron(template, collapsible, collapsed) {
+        template.collapsed.set(collapsible && collapsed, undefined);
         template.chevron.className = "session-section-chevron";
         if (collapsible) {
             template.chevron.classList.add("collapsible");
@@ -1235,19 +2205,61 @@ class SessionSectionRenderer {
             this.templatesById.delete(node.element.id);
         }
     }
+    disposeShortcut(element, template) {
+        template.elementDisposables.clear();
+        this.templatesByElement.delete(element);
+        this.templatesById.delete(element.id);
+    }
     disposeTemplate(template) {
         template.disposables.dispose();
     }
 }
+class SessionShortcutListDelegate {
+    getHeight() {
+        return SESSION_SHORTCUT_ROW_HEIGHT;
+    }
+    getTemplateId() {
+        return SESSION_SHORTCUT_SECTION_TEMPLATE_ID;
+    }
+}
+class SessionShortcutListRenderer {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.templateId = SESSION_SHORTCUT_SECTION_TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        return this.renderer.renderTemplate(container);
+    }
+    renderElement(element, _index, template) {
+        this.renderer.renderShortcut(element, template);
+    }
+    disposeElement(element, _index, template) {
+        this.renderer.disposeShortcut(element, template);
+    }
+    disposeTemplate(template) {
+        this.renderer.disposeTemplate(template);
+    }
+}
 class SessionGroupRenderer {
     static {
         this.TEMPLATE_ID = "session-group";
     }
-    constructor(delegate, instantiationService, contextKeyService) {
+    constructor(
+        delegate,
+        showUnreadInCollapsedSections,
+        sessionsWithFailingCI,
+        headerStatusTrigger,
+        instantiationService,
+        contextKeyService
+    ) {
         this.delegate = delegate;
+        this.showUnreadInCollapsedSections = showUnreadInCollapsedSections;
+        this.sessionsWithFailingCI = sessionsWithFailingCI;
+        this.headerStatusTrigger = headerStatusTrigger;
         this.instantiationService = instantiationService;
         this.contextKeyService = contextKeyService;
         this.templateId = SessionGroupRenderer.TEMPLATE_ID;
+        this.rowClassName = "session-list-section-row";
         this.templatesByElement = ( new WeakMap());
         this.templatesById = ( new Map());
     }
@@ -1257,9 +2269,10 @@ class SessionGroupRenderer {
         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 labelContainer = append(container, $(".session-section-label-container.session-group-labels"));
+        const label = append(labelContainer, $("span.session-section-label"));
+        const description = append(labelContainer, $("span.session-group-description"));
         const inputContainer = append(container, $(".session-group-input"));
         const toolbarContainer = append(container, $(".session-section-toolbar"));
         const contextKeyService = disposables.add(this.contextKeyService.createScoped(container));
@@ -1268,12 +2281,17 @@ class SessionGroupRenderer {
             scopedInstantiationService.createInstance(MenuWorkbenchToolBar, toolbarContainer, SessionGroupToolbarMenuId, {
                 menuOptions: {
                     shouldForwardArgs: true
-                }
+                },
+                telemetrySource: "sessionsList.group"
             })
         );
         return {
             container,
+            icon,
+            collapsed: observableValue(this, false),
+            labelContainer,
             label,
+            description,
             inputContainer,
             toolbarContainer,
             toolbar,
@@ -1293,25 +2311,62 @@ class SessionGroupRenderer {
         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;
+        const isComparison = element.comparison !== undefined;
+        template.container.classList.toggle("session-comparison-group", isComparison);
+        template.icon.className = "session-section-icon";
+        template.icon.classList.add(
+            ...ThemeIcon.asClassNameArray(isComparison ? Codicon.layers : Codicon.folderLibrary)
+        );
+        template.label.textContent = element.comparison?.title ?? element.group.name;
+        const comparison = element.comparison;
+        if (comparison) {
+            template.elementDisposables.add(autorun(reader => {
+                template.description.textContent = comparison.summary(reader);
+            }));
+        } else {
+            template.description.textContent = "";
+        }
+        template.description.classList.toggle("visible", isComparison);
         this.updateChevron(template, node.collapsible, node.collapsed);
-        SessionGroupHasVisibleSessionsContext.bindTo(template.contextKeyService).set(element.sessions.length > 0);
+        renderSessionHeaderIcon(
+            template,
+            element.sessions,
+            isComparison ? Codicon.layers : Codicon.folderLibrary,
+            this.showUnreadInCollapsedSections,
+            this.sessionsWithFailingCI,
+            this.headerStatusTrigger,
+            this.instantiationService
+        );
+        if (isComparison) {
+            for (const eventType of ["pointerdown", "pointerup", "click", "dblclick"]) {
+                template.elementDisposables.add(addDisposableListener(template.chevron, eventType, event => {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    if (eventType === "click") {
+                        this.delegate.toggleCollapsed(element);
+                    }
+                }));
+            }
+            template.elementDisposables.add(Gesture.ignoreTarget(template.chevron));
+        }
+        SessionGroupHasVisibleSessionsContext.bindTo(template.contextKeyService).set(element.sessions.length > 0 && comparison?.launching !== true);
         SessionGroupIsEmptyContext.bindTo(template.contextKeyService).set(element.isEmpty);
+        SessionGroupIsComparisonContext.bindTo(template.contextKeyService).set(isComparison);
         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 = "";
+            template.labelContainer.style.display = "";
         }
     }
     renderInput(element, template) {
-        template.label.style.display = "none";
+        template.labelContainer.style.display = "none";
         template.inputContainer.style.display = "";
         clearNode(template.inputContainer);
         const input = template.elementDisposables.add(( new InputBox(template.inputContainer, undefined, {
             inputBoxStyles: defaultInputBoxStyles,
-            ariaLabel: ( localize(4910, "Group name"))
+            ariaLabel: ( localize(6129, "Group name"))
         })));
         input.value = element.group.name;
         input.focus();
@@ -1359,6 +2414,7 @@ class SessionGroupRenderer {
         template?.container.classList.toggle(SESSION_HEADER_DROP_TARGET_CLASS, active);
     }
     updateChevron(template, collapsible, collapsed) {
+        template.collapsed.set(collapsible && collapsed, undefined);
         template.chevron.className = "session-section-chevron";
         if (collapsible) {
             template.chevron.classList.add("collapsible");
@@ -1397,9 +2453,9 @@ class SessionShowMoreRenderer {
         const container = template.parentElement;
         container?.classList.toggle("session-show-more-folders", element.kind === "folders");
         if (element.mode === "less") {
-            template.textContent = element.kind === "folders" ? ( localize(4911, "Show fewer workspaces")) : ( localize(4912, "Show less"));
+            template.textContent = element.kind === "folders" ? ( localize(6130, "Show fewer workspaces")) : ( localize(6131, "Show less"));
         } else {
-            template.textContent = element.kind === "folders" ? element.remainingCount === 1 ? ( localize(4913, "+{0} more workspace", element.remainingCount)) : ( localize(4914, "+{0} more workspaces", element.remainingCount)) : ( localize(4915, "+{0} more", element.remainingCount));
+            template.textContent = element.kind === "folders" ? element.remainingCount === 1 ? ( localize(6132, "+{0} more workspace", element.remainingCount)) : ( localize(6133, "+{0} more workspaces", element.remainingCount)) : ( localize(6134, "+{0} more", element.remainingCount));
         }
     }
     disposeTemplate(_template) {}
@@ -1438,73 +2494,177 @@ class SessionsAccessibilityProvider {
         this.options = options;
     }
     getWidgetAriaLabel() {
-        return localize(4916, "Sessions");
+        return this.options?.widgetAriaLabel ?? ( localize(6135, "Sessions"));
     }
     getAriaLabel(element) {
         if (isSessionChatItem(element)) {
-            return derived(this, reader => ( localize(
-                4917,
-                "{0}, chat, updated {1}, {2}",
-                getChatTitle(element.chat, reader),
-                fromNow(element.chat.updatedAt.read(reader), true),
-                getSessionConversationStatusAriaLabel(element.chat.status.read(reader))
-            )));
+            return derived(this, reader => {
+                const title = getChatTitle(element.chat, reader);
+                const chatStatus = element.chat.status.read(reader);
+                const updatedAt = chatStatus === SessionStatus.InProgress ? undefined : element.chat.updatedAt.read(reader);
+                const status = getSessionConversationStatusAriaLabel(chatStatus);
+                const chatDescription = element.chat.description.read(reader);
+                const statusMessage = getSessionStatusMessage(chatStatus, chatDescription);
+                const folderLabel = getChatWorkspaceBadgeLabel(
+                    element.session.workspace.read(reader),
+                    element.chat.workspace.read(reader)
+                );
+                let label = updatedAt ? folderLabel ? ( localize(
+                    6136,
+                    "{0}, chat in folder {1}, updated {2}, {3}",
+                    title,
+                    folderLabel,
+                    fromNow(updatedAt, true),
+                    status
+                )) : ( localize(
+                    6137,
+                    "{0}, chat, updated {1}, {2}",
+                    title,
+                    fromNow(updatedAt, true),
+                    status
+                )) : folderLabel ? ( localize(6138, "{0}, chat in folder {1}, {2}", title, folderLabel, status)) : ( localize(6139, "{0}, chat, {1}", title, status));
+                if (statusMessage !== undefined && (chatStatus === SessionStatus.InProgress || chatDescription !== undefined)) {
+                    const statusMessageText = typeof statusMessage === "string" ? statusMessage : renderAsPlaintext(statusMessage, {
+                        omitMarkdownSyntax: true
+                    });
+                    label = ( localize(6140, "{0}, {1}", label, statusMessageText));
+                }
+                const diffStats = chatStatus === SessionStatus.InProgress || chatStatus === SessionStatus.NeedsInput ? undefined : getChatListDiffStats(element.chat, reader);
+                if (diffStats) {
+                    label = ( localize(
+                        6141,
+                        "{0}, {1} lines added, {2} lines removed",
+                        label,
+                        diffStats.insertions,
+                        diffStats.deletions
+                    ));
+                }
+                const isArchived = element.chat.isArchived.read(reader);
+                const readLabel = !isArchived && !element.chat.isRead.read(reader) ? ( localize(6142, "{0}, unread", label)) : label;
+                return isArchived ? ( localize(6143, "{0}, archived", label)) : readLabel;
+            });
         }
         if (isSessionGroupItem(element)) {
-            return `${element.group.name}, ${element.sessions.length}`;
+            return element.comparison ? derived(this, reader => ( localize(
+                6144,
+                "{0}, {1}",
+                element.comparison.title,
+                element.comparison.summary(reader)
+            ))) : this.getSectionAriaLabel(element.group.name, element.sessions);
         }
         if (isSessionSection(element)) {
+            if (element.id === NEW_SESSION_SECTION_ID) {
+                return derived(this, reader => {
+                    const keybindingAriaLabel = this.options?.newSessionKeybindingAriaLabel?.read(reader);
+                    return keybindingAriaLabel ? ( localize(6145, "New Session ({0})", keybindingAriaLabel)) : ( localize(6146, "New Session"));
+                });
+            }
             if (element.id === AUTOMATIONS_SECTION_ID) {
                 return derived(this, reader => {
                     let label = element.label;
                     switch (this.automationStatus?.read(reader)) {
                     case SessionStatus.NeedsInput:
-                        label = ( localize(4918, "{0}, run needs input", element.label));
+                        label = ( localize(6147, "{0}, run needs attention", element.label));
                         break;
                     case SessionStatus.InProgress:
-                        label = ( localize(4919, "{0}, run in progress", element.label));
+                        label = ( localize(6148, "{0}, run in progress", element.label));
                         break;
                     case SessionStatus.Completed:
-                        label = ( localize(4920, "{0}, unread run", element.label));
+                        label = ( localize(6149, "{0}, unread run", element.label));
                         break;
                     }
-                    return this.options?.automationNewBadgeVisible?.read(reader) ? ( localize(4921, "{0}, new feature", label)) : label;
+                    return label;
                 });
             }
-            return `${element.label}, ${element.sessions.length}`;
+            if (element.id === CUSTOMIZATIONS_SECTION_ID) {
+                return derived(this, reader => {
+                    const count = this.options?.customizationsCount?.read(reader) ?? 0;
+                    const countLabel = count === 1 ? ( localize(6150, "1 customization")) : ( localize(6151, "{0} customizations", count));
+                    return this.options?.customizationMigrationsAvailable?.read(reader) ? ( localize(
+                        6152,
+                        "{0}, {1}, customization migrations available",
+                        element.label,
+                        countLabel
+                    )) : ( localize(6153, "{0}, {1}", element.label, countLabel));
+                });
+            }
+            if (isShortcutSection(element.id)) {
+                return element.label;
+            }
+            return this.getSectionAriaLabel(element.label, element.sessions);
         }
         if (isSessionShowMore(element)) {
             if (element.mode === "less") {
-                return element.kind === "folders" ? ( localize(4922, "Show fewer workspaces")) : ( localize(4923, "Show fewer sessions"));
+                return element.kind === "folders" ? ( localize(6154, "Show fewer workspaces")) : ( localize(6155, "Show fewer sessions"));
             }
-            return element.kind === "folders" ? element.remainingCount === 1 ? ( localize(4924, "Show {0} more workspace", element.remainingCount)) : ( localize(4925, "Show {0} more workspaces", element.remainingCount)) : ( localize(4926, "Show {0} more sessions", element.remainingCount));
+            return element.kind === "folders" ? element.remainingCount === 1 ? ( localize(6156, "Show {0} more workspace", element.remainingCount)) : ( localize(6157, "Show {0} more workspaces", element.remainingCount)) : ( localize(6158, "Show {0} more sessions", element.remainingCount));
         }
         if (isSessionPlaceholder(element)) {
-            return element.hover ? ( localize(4927, "{0}. {1}", element.label, element.hover)) : element.label;
+            return element.hover ? ( localize(6159, "{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);
+            const title = this.options?.getComparisonAttemptLabel?.(element) ?? element.title.read(reader);
+            const mainChat = element.mainChat.read(reader);
+            const updatedAt = mainChat.status.read(reader) === SessionStatus.InProgress ? undefined : mainChat.updatedAt.read(reader);
             let label;
             if (this.options?.includeQuickChatInAriaLabel && element.isQuickChat?.read(reader)) {
-                label = ( localize(4928, "{0}, chat, updated {1}", title, updated));
+                label = updatedAt ? ( localize(6160, "{0}, chat, updated {1}", title, fromNow(updatedAt, true))) : ( localize(6161, "{0}, chat", title));
             } else if (element.worktreePending?.read(reader)) {
-                label = ( localize(4929, "{0}, creating worktree, updated {1}", title, updated));
+                label = updatedAt ? ( localize(
+                    6162,
+                    "{0}, creating worktree, updated {1}",
+                    title,
+                    fromNow(updatedAt, true)
+                )) : ( localize(6163, "{0}, creating worktree", title));
             } else {
-                label = ( localize(4930, "{0}, updated {1}", title, updated));
+                label = updatedAt ? ( localize(6164, "{0}, updated {1}", title, fromNow(updatedAt, true))) : title;
             }
-            const status = getSessionRowStatus(element, reader, !!this.options?.deriveStatusFromMainChat);
+            const collapsed = this.options?.collapsedSessionIds?.read(reader).has(element.sessionId) ?? true;
+            const status = getSessionRowStatus(element, reader, !!this.options?.deriveStatusFromMainChat, collapsed);
             if (this.options?.deriveStatusFromMainChat) {
-                label = ( localize(4931, "{0}, {1}", label, getSessionConversationStatusAriaLabel(status)));
+                label = ( localize(6165, "{0}, {1}", label, getSessionConversationStatusAriaLabel(status)));
+            }
+            const eligible = isExternalApplicationBadgeEligible(element, reader);
+            if (eligible) {
+                this.options?.reportExternalApplicationBadgeModeExperimentTrigger?.();
+            }
+            const badgeMode = this.options?.externalApplicationBadgeMode?.read(reader) ?? ExternalSessionApplicationBadgeMode.Off;
+            if (eligible && badgeMode !== ExternalSessionApplicationBadgeMode.Off) {
+                this.options?.reportExternalApplicationBadgeShowFromExperimentTrigger?.();
+                label = ( localize(6166, "{0}, created in {1}", label, element.application.read(reader).label));
+            }
+            if (!element.isArchived.read(reader) && !getSessionRowIsRead(element, reader, !!this.options?.deriveStatusFromMainChat)) {
+                label = ( localize(6167, "{0}, unread", label));
+            }
+            const inputNeededMessage = this.options ? getCompactInputNeededMessage(element, reader, this.options, this.options.approvalModel) : undefined;
+            if (inputNeededMessage) {
+                label = ( localize(6168, "{0}, {1}", label, renderAsPlaintext(inputNeededMessage, {
+                    omitMarkdownSyntax: true
+                })));
             }
             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(4932, "{0}, in {1}", label, workspaceLabel));
+            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) || this.options.isRenderedInExternalSection?.(element))) {
+                label = ( localize(6169, "{0}, in {1}", label, workspaceLabel));
             }
             return label;
         });
     }
+    getSectionAriaLabel(label, sessions) {
+        return derived(this, reader => {
+            const status = this.options?.showUnreadInCollapsedSections?.read(reader) ? getSessionHeaderStatus(sessions, reader, this.options.sessionsWithFailingCI?.read(reader)) : undefined;
+            switch (status) {
+            case SessionHeaderStatus.NeedsInput:
+                return localize(6170, "{0}, {1}, session needs attention", label, sessions.length);
+            case SessionHeaderStatus.FailingCI:
+                return localize(6171, "{0}, {1}, session has failing CI checks", label, sessions.length);
+            case SessionHeaderStatus.Unread:
+                return localize(6172, "{0}, {1}, contains unread sessions", label, sessions.length);
+            default:
+                return localize(6173, "{0}, {1}", label, sessions.length);
+            }
+        });
+    }
 }
 class SessionsListDragAndDrop extends Disposable {
     constructor(delegate) {
@@ -1550,7 +2710,7 @@ class SessionsListDragAndDrop extends Disposable {
         if (sessions.length === 1) {
             return sessions[0].title.get();
         }
-        return localize(4933, "{0} sessions", sessions.length);
+        return localize(6174, "{0} sessions", sessions.length);
     }
     onDragStart(data, originalEvent) {
         const elements = data instanceof ElementsDragAndDropData ? data.elements : [];
@@ -1757,9 +2917,9 @@ class SessionsListDragAndDrop extends Disposable {
         let sectionId;
         let target;
         if (isSessionSection(targetElement)) {
-            sectionId = targetElement.id.startsWith("workspace:") ? targetElement.id : undefined;
+            sectionId = targetElement.id.startsWith("workspace:") || targetElement.id === EXTERNAL_SESSIONS_SECTION_ID ? targetElement.id : undefined;
         } else if (isSessionItem(targetElement) && this.delegate.getGroupIdOfSession(targetElement) === undefined) {
-            sectionId = this.delegate.getWorkspaceSectionIdOfSession(targetElement);
+            sectionId = this.delegate.getUngroupedSectionIdOfSession(targetElement);
             target = sectionId === undefined ? undefined : targetElement;
         }
         if (sectionId === undefined) {
@@ -1767,7 +2927,7 @@ class SessionsListDragAndDrop extends Disposable {
         }
         const dragged = this.draggedSessions(data);
         const canRemove = dragged.every(
-            session => this.delegate.getGroupIdOfSession(session) !== undefined && this.delegate.getWorkspaceSectionIdOfSession(session) === sectionId
+            session => this.delegate.getGroupIdOfSession(session) !== undefined && this.delegate.getUngroupedSectionIdOfSession(session) === sectionId
         );
         if (dragged.length === 0 || !canRemove) {
             return undefined;
@@ -1864,6 +3024,9 @@ let SessionsList = class SessionsList extends Disposable {
     static {
         this.SECTION_COLLAPSE_STATE_KEY = "sessionsListControl.sectionCollapseState";
     }
+    static {
+        this.SESSION_COLLAPSE_STATE_KEY = "sessionsListControl.sessionCollapseState";
+    }
     static {
         this.EXCLUDED_TYPES_KEY = "sessionsListControl.excludedSessionTypes";
     }
@@ -1876,6 +3039,9 @@ let SessionsList = class SessionsList extends Disposable {
     static {
         this.EXCLUDE_READ_KEY = "sessionsListControl.excludeRead";
     }
+    static {
+        this.SHOW_EMPTY_GROUPS_KEY = "sessionsListControl.showEmptyGroups";
+    }
     static {
         this.WORKSPACE_GROUP_CAPPED_KEY = "sessionsListControl.workspaceGroupCapped";
     }
@@ -1888,11 +3054,8 @@ let SessionsList = class SessionsList extends Disposable {
     get element() {
         return this.listContainer;
     }
-    async resetAutomationsNewBadge() {
-        if (this.customViewService.activeCustomView.get()?.id === AUTOMATIONS_CUSTOM_VIEW_ID) {
-            this.customViewService.hideCustomView();
-        }
-        await this.automationsNewBadgeState.reset();
+    isCompact() {
+        return (this.options.compact?.() ?? false) && !IsPhoneLayoutContext.getValue(this.contextKeyService);
     }
     constructor(
         container,
@@ -1902,12 +3065,14 @@ let SessionsList = class SessionsList extends Disposable {
         customViewService,
         _sessionsListModelService,
         _sessionGroupsService,
+        sessionComparisonService,
         _sessionSectionOrderService,
         _agentHostFilterService,
         instantiationService,
         contextKeyService,
         storageService,
         contextMenuService,
+        contextViewService,
         menuService,
         keybindingService,
         commandService,
@@ -1919,7 +3084,10 @@ let SessionsList = class SessionsList extends Disposable {
         agentHostConnectionsService,
         openerService,
         labelService,
-        preferencesService
+        preferencesService,
+        editorService,
+        telemetryService,
+        accessibilityService
     ) {
         super();
         this.options = options;
@@ -1928,11 +3096,13 @@ let SessionsList = class SessionsList extends Disposable {
         this.customViewService = customViewService;
         this._sessionsListModelService = _sessionsListModelService;
         this._sessionGroupsService = _sessionGroupsService;
+        this.sessionComparisonService = sessionComparisonService;
         this._sessionSectionOrderService = _sessionSectionOrderService;
         this._agentHostFilterService = _agentHostFilterService;
         this.contextKeyService = contextKeyService;
         this.storageService = storageService;
         this.contextMenuService = contextMenuService;
+        this.contextViewService = contextViewService;
         this.menuService = menuService;
         this.keybindingService = keybindingService;
         this.commandService = commandService;
@@ -1945,11 +3115,16 @@ let SessionsList = class SessionsList extends Disposable {
         this.openerService = openerService;
         this.labelService = labelService;
         this.preferencesService = preferencesService;
+        this.telemetryService = telemetryService;
+        this.navigationSections = [];
         this.sessions = [];
         this.sessionChatsObserver = this._register(( new MutableDisposable()));
         this.activeSessionUpdate = this._register(( new MutableDisposable()));
-        this.chatApprovalHeightReconcile = this._register(( new MutableDisposable()));
+        this.nestedSessionOrderUpdate = this._register(( new MutableDisposable()));
+        this.nestedSessionResources = ( new Set());
+        this.chatRowHeightReconcile = this._register(( new MutableDisposable()));
         this.automationSessions = observableValue(this, []);
+        this.collapsedSessionIds = observableValue(this, ( new Set()));
         this.hoveredGuideSessionId = observableValue(this, undefined);
         this.selectedGuideSessionIds = observableValue(this, EMPTY_GUIDE_SESSION_IDS);
         this.focusedGuideSessionIds = observableValue(this, EMPTY_GUIDE_SESSION_IDS);
@@ -1970,32 +3145,51 @@ let SessionsList = class SessionsList extends Disposable {
             return ids;
         });
         this.visible = true;
-        this.archiveOnboardingSession = observableValue(this, undefined);
+        this.onboardingTarget = observableValue(this, undefined);
+        this._sessionContextMenuDisposables = this._register(( new MutableDisposable()));
         this.sessionGroupLimit = observableValue(this, SessionsList_1.DEFAULT_SESSION_GROUP_LIMIT);
         this.expandedSessionGroups = ( new Set());
+        this.renderedComparisonAttemptConnectorPositions = ( new Map());
+        this.renderedComparisonAttemptLabels = ( new Map());
         this.expandedMoreFolders = false;
         this.hasFindPattern = false;
         this.suspendCollapseStatePersistence = false;
+        this.findOpen = observableValue(this, false);
         this._topLevelOrder = [];
         this._onDidUpdate = this._register(( new Emitter()));
         this.onDidUpdate = this._onDidUpdate.event;
+        this._onDidOpenSession = this._register(( new Emitter()));
+        this.onDidOpenSession = this._onDidOpenSession.event;
+        this._onDidActivateNewSession = this._register(( new Emitter()));
         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.filters = this._register(instantiationService.createInstance(SessionsListFilters));
+        for (const key of [
+            SessionsList_1.EXCLUDED_TYPES_KEY,
+            SessionsList_1.EXCLUDED_STATUSES_KEY,
+            SessionsList_1.EXCLUDE_READ_KEY,
+            SessionsList_1.SHOW_EMPTY_GROUPS_KEY
+        ]) {
+            this.storageService.remove(key, StorageScope.PROFILE);
+        }
+        const storedExcludeArchived = this.storageService.get(SessionsList_1.EXCLUDE_ARCHIVED_KEY, StorageScope.PROFILE);
+        this._excludeArchivedIsDefault = storedExcludeArchived === undefined;
+        this._excludeArchived = storedExcludeArchived === undefined ? this.configurationService.getValue(SESSIONS_LIST_SHOW_ARCHIVED_BY_DEFAULT_SETTING) !== true : this.storageService.getBoolean(SessionsList_1.EXCLUDE_ARCHIVED_KEY, StorageScope.PROFILE, true);
         this.workspaceGroupCapped = this.storageService.getBoolean(SessionsList_1.WORKSPACE_GROUP_CAPPED_KEY, StorageScope.PROFILE, true);
+        this.collapsedSessionResources = this.loadCollapsedSessionResources();
         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.listContainer.classList.toggle("compact", this.isCompact());
+        const markSectionFocusFromPointer = element => this._register(addDisposableListener(element, EventType.POINTER_DOWN, () => {
+            element.classList.add(SESSION_SECTION_FOCUS_FROM_POINTER_CLASS);
+        }));
+        markSectionFocusFromPointer(this.listContainer);
+        if (this.options.navigationContainer) {
+            markSectionFocusFromPointer(this.options.navigationContainer);
+        }
         this._register(
             addDisposableListener(this.listContainer.ownerDocument, EventType.KEY_DOWN, () => {
                 this.listContainer.classList.remove(SESSION_SECTION_FOCUS_FROM_POINTER_CLASS);
+                this.options.navigationContainer?.classList.remove(SESSION_SECTION_FOCUS_FROM_POINTER_CLASS);
             }, true)
         );
         const approvalModel = this.options.approvalModel ?? this._register(instantiationService.createInstance(AgentSessionApprovalModel));
@@ -2019,78 +3213,234 @@ let SessionsList = class SessionsList extends Disposable {
             this.update();
         }));
         this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(SESSIONS_LIST_SHOW_EMPTY_DEFAULT_GROUPS_SETTING) || e.affectsConfiguration(ChatSessionArchiveActionWordingSettingId)) {
+            if (e.affectsConfiguration(SESSIONS_LIST_SHOW_EMPTY_DEFAULT_GROUPS_SETTING) || e.affectsConfiguration(SESSIONS_LIST_GROUP_EXTERNAL_SESSIONS_SETTING) || e.affectsConfiguration(ChatSessionArchiveActionWordingSettingId)) {
                 this.update();
             }
         }));
         const agentSessionsService = instantiationService.invokeFunction(accessor => accessor.get(IAgentSessionsService));
         const voicePlaybackService = instantiationService.invokeFunction(accessor => accessor.get(IVoicePlaybackService));
+        const externalApplicationBadgeMode = observableConfigValue(
+            SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SETTING,
+            ExternalSessionApplicationBadgeMode.Off,
+            this.configurationService
+        );
+        const externalApplicationBadgeShowFrom = observableConfigValue(
+            SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SHOW_FROM_SETTING,
+            true,
+            this.configurationService
+        );
+        const reportExternalApplicationBadgeModeExperimentTrigger = () => logDefaultSettingExperimentTrigger(
+            this.configurationService,
+            this.telemetryService,
+            SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SETTING
+        );
+        const reportExternalApplicationBadgeShowFromExperimentTrigger = () => logDefaultSettingExperimentTrigger(
+            this.configurationService,
+            this.telemetryService,
+            SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SHOW_FROM_SETTING
+        );
         const sessionRenderer = ( new SessionItemRenderer({
             grouping: this.options.grouping,
             isPinned: s => this.isSessionPinned(s),
             isRenderedInCustomGroup: s => this.isRenderedInCustomGroup(s),
+            getGroupConnectorPosition: s => this.renderedComparisonAttemptConnectorPositions.get(s.sessionId),
+            getComparisonAttemptLabel: s => this.renderedComparisonAttemptLabels.get(s.sessionId),
+            shouldShowComparisonAttemptStatus: (s, reader) => this.shouldShowComparisonAttemptStatus(s, reader),
+            isRenderedInExternalSection: s => this.isRenderedInExternalSection(s),
             visibleSessions: this._sessionsService.visibleSessions,
             getMultiSelectedSessions: s => this.getMultiSelectedSessions(s),
             showHover: true,
             useCompactQuickChatRows: true,
+            compact: () => this.isCompact(),
             approvalRowMaxLines: DEFAULT_APPROVAL_ROW_MAX_LINES,
             aggregateChatApprovals: false,
-            toolbarMenuId: SessionItemToolbarMenuId,
-            onDidRequestRename: session => {
-                this.commandService.executeCommand(RENAME_SESSION_COMMAND_ID, session).catch(onUnexpectedError);
-            },
+            toolbarMenuId: Menus.SessionItemToolbar,
+            toolbarTelemetrySource: "sessionsList.row",
+            inlineRename: true,
+            contextViewService: this.contextViewService,
+            onDidDoubleClickRename: session => this.preservePendingOpenFocus(session),
+            onDidFinishRename: () => this.tree.domFocus(),
             activeGuideSessionIds: this.activeGuideSessionIds,
             deriveStatusFromMainChat: true,
-            archiveOnboardingSession: this.archiveOnboardingSession
+            activeSession: this._sessionsService.activeSession,
+            externalApplicationBadgeMode,
+            externalApplicationBadgeShowFrom,
+            reportExternalApplicationBadgeModeExperimentTrigger,
+            reportExternalApplicationBadgeShowFromExperimentTrigger,
+            collapsedSessionIds: this.collapsedSessionIds,
+            onboardingTarget: this.onboardingTarget
         }, approvalModel, undefined, instantiationService, contextKeyService, this.configurationService, markdownRendererService, hoverService, sessionsProvidersService, this._sessionsManagementService, this.agentHostConnectionsService, this.openerService, this.labelService, this.preferencesService, agentSessionsService, voicePlaybackService));
+        this._sessionRenderer = sessionRenderer;
         const showMoreRenderer = ( new SessionShowMoreRenderer());
         const placeholderRenderer = ( new SessionPlaceholderRenderer(hoverService));
         const chatRenderer = ( new SessionChatItemRenderer(
             hoverService,
             instantiationService,
+            this.contextKeyService,
+            this._sessionsManagementService,
+            this.contextViewService,
             markdownRendererService,
             approvalModel,
             DEFAULT_APPROVAL_ROW_MAX_LINES,
+            item => this.preservePendingOpenFocus(item.session, item.chat),
+            () => this.tree.domFocus(),
+            item => withSessionsListHoverPresentation(createSessionSummaryHover(item.session, getChatSummaryHoverData(
+                item.session,
+                item.chat,
+                sessionsProvidersService,
+                this.openerService,
+                this.labelService,
+                this.preferencesService,
+                getCreatorHoverData(
+                    item.session,
+                    this._sessionsManagementService,
+                    this.agentHostConnectionsService,
+                    this.openerService
+                ),
+                this.isCompact()
+            ), this.preferencesService)),
+            () => this.isCompact(),
+            () => {
+                if (this.options.sorting() === SessionsSorting.Updated) {
+                    this.nestedSessionOrderUpdate.value = scheduleAtNextAnimationFrame(getWindow(this.listContainer), () => {
+                        if (this.visible) {
+                            this.update();
+                        }
+                    });
+                }
+            },
             this.activeGuideSessionIds
         ));
+        this._chatRenderer = chatRenderer;
         const selectHeader = (element, event) => {
             this.tree.setFocus([element], event);
             this.tree.setSelection([element], event);
         };
-        const sectionRenderer = ( new SessionSectionRenderer(
+        const showUnreadInCollapsedSections = observableConfigValue(
+            SESSIONS_LIST_SHOW_UNREAD_IN_COLLAPSED_SECTIONS_SETTING,
+            false,
+            this.configurationService
+        );
+        const headerStatusTriggerPending = observableValue(this, true);
+        const headerStatusTrigger = {
+            pending: headerStatusTriggerPending,
+            includeExpanded: observableFromEvent(
+                this,
+                accessibilityService.onDidChangeScreenReaderOptimized,
+                () => accessibilityService.isScreenReaderOptimized()
+            ),
+            report: () => {
+                logSettingExperimentTrigger(
+                    this.telemetryService,
+                    SESSIONS_LIST_SHOW_UNREAD_IN_COLLAPSED_SECTIONS_SETTING
+                );
+                headerStatusTriggerPending.set(false, undefined);
+            }
+        };
+        const blockedSessions = derived(
+            this,
+            reader => showUnreadInCollapsedSections.read(reader) ? reader.store.add(instantiationService.createInstance(BlockedSessions)) : undefined
+        );
+        const sessionsWithFailingCI = derived(this, reader => ( new Set(
+            blockedSessions.read(reader)?.blockedSessionsWithReasons.read(reader).filter(blocked => blocked.reason === BlockedSessionReason.FailingCI).map(blocked => blocked.session.sessionId)
+        )));
+        const customizationsActive = observableFromEvent(
+            this,
+            editorService.onDidActiveEditorChange,
+            () => editorService.activeEditor instanceof AICustomizationManagementEditorInput
+        );
+        const newSessionKeybindingAriaLabel = observableFromEvent(
+            this,
+            keybindingService.onDidUpdateKeybindings,
+            () => keybindingService.lookupKeybinding(NEW_SESSION_ACTION_ID, this.contextKeyService)?.getAriaLabel() ?? undefined
+        );
+        const customizationsCount = this.options.customizationsCount ?? constObservable(0);
+        const customizationMigrationsAvailable = this.options.customizationMigrationsAvailable ?? constObservable(false);
+        const createSectionRenderer = (templateId, rowClassName) => ( new SessionSectionRenderer(
             true ,
             selectHeader,
+            showUnreadInCollapsedSections,
+            sessionsWithFailingCI,
+            headerStatusTrigger,
             instantiationService,
+            hoverService,
             contextKeyService,
             this.automationService,
             this.automationSessions,
-            this.automationsNewBadgeState.presentation,
             this.uriIdentityService,
             this.customViewService,
-            this.menuService
+            this.menuService,
+            this.keybindingService,
+            customizationsActive,
+            customizationMigrationsAvailable,
+            templateId,
+            rowClassName,
+            {
+                onDidActivateNewSession: this._onDidActivateNewSession.event,
+                getNewSessionFocusTarget: () => this.navigationList ? {
+                    element: this.navigationList.getHTMLElement(),
+                    focus: () => this.focusNavigationSection(NEW_SESSION_SECTION_ID)
+                } : undefined
+            }
         ));
+        const sectionRenderer = createSectionRenderer(undefined, "session-list-section-row");
+        const shortcutSectionRenderer = createSectionRenderer(SESSION_SHORTCUT_SECTION_TEMPLATE_ID, "session-list-shortcut-row");
         this._sectionRenderer = sectionRenderer;
         const groupRenderer = ( new SessionGroupRenderer({
             commitEdit: (group, name) => this.commitGroupEdit(group, name),
             cancelEdit: group => this.cancelGroupEdit(group),
-            select: selectHeader
-        }, instantiationService, contextKeyService));
+            select: selectHeader,
+            toggleCollapsed: element => this.tree.toggleCollapsed(element)
+        }, showUnreadInCollapsedSections, sessionsWithFailingCI, headerStatusTrigger, instantiationService, contextKeyService));
         this._groupRenderer = groupRenderer;
         const delegate = ( new SessionsTreeDelegate(
             approvalModel,
             () => !!IsPhoneLayoutContext.getValue(contextKeyService),
+            () => this.isCompact(),
+            session => getSessionRowStatus(session, undefined, true, ( this.collapsedSessionIds.get().has(session.sessionId))),
             DEFAULT_APPROVAL_ROW_MAX_LINES,
             undefined,
             true ,
             false ,
-            true
+            true ,
+            session => ( this.renderedComparisonAttemptLabels.has(session.sessionId))
         ));
         this._delegate = delegate;
+        this.options.navigationContainer?.classList.add("empty");
+        this.navigationList = this.options.navigationContainer ? this._register(instantiationService.createInstance(
+            WorkbenchList,
+            "SessionsNavigationList",
+            this.options.navigationContainer,
+            ( new SessionShortcutListDelegate()),
+            [( new SessionShortcutListRenderer(shortcutSectionRenderer))],
+            {
+                accessibilityProvider: ( new SessionsAccessibilityProvider(shortcutSectionRenderer.automationStatus, {
+                    grouping: this.options.grouping,
+                    isPinned: session => this.isSessionPinned(session),
+                    widgetAriaLabel: ( localize(6175, "Sessions Navigation")),
+                    customizationsCount,
+                    customizationMigrationsAvailable,
+                    newSessionKeybindingAriaLabel
+                })),
+                keyboardNavigationLabelProvider: {
+                    getKeyboardNavigationLabel: section => section.label
+                },
+                multipleSelectionSupport: false,
+                openOnSingleClick: true,
+                overrideStyles: this.options.overrideStyles
+            }
+        )) : undefined;
+        if (this.navigationList) {
+            this._register(
+                this.navigationList.onDidOpen(e => this.openNavigationSection(e.element, e.sideBySide))
+            );
+        }
         this.tree = this._register(
             instantiationService.createInstance(WorkbenchObjectTree, "SessionsListTree", this.listContainer, delegate, [
                 sessionRenderer,
                 chatRenderer,
                 sectionRenderer,
+                shortcutSectionRenderer,
                 groupRenderer,
                 showMoreRenderer,
                 placeholderRenderer
@@ -2099,8 +3449,18 @@ let SessionsList = class SessionsList extends Disposable {
                     grouping: this.options.grouping,
                     isPinned: session => this.isSessionPinned(session),
                     isRenderedInCustomGroup: session => this.isRenderedInCustomGroup(session),
+                    getComparisonAttemptLabel: session => this.renderedComparisonAttemptLabels.get(session.sessionId),
+                    isRenderedInExternalSection: session => this.isRenderedInExternalSection(session),
+                    compact: () => this.isCompact(),
+                    approvalModel,
+                    aggregateChatApprovals: false,
                     deriveStatusFromMainChat: true,
-                    automationNewBadgeVisible: this.automationsNewBadgeState.showNewBadge
+                    collapsedSessionIds: this.collapsedSessionIds,
+                    showUnreadInCollapsedSections,
+                    sessionsWithFailingCI,
+                    externalApplicationBadgeMode,
+                    reportExternalApplicationBadgeModeExperimentTrigger,
+                    reportExternalApplicationBadgeShowFromExperimentTrigger
                 })),
                 dnd: this._register(( new SessionsListDragAndDrop({
                     isReorderable: session => this.isReorderable(session),
@@ -2108,7 +3468,7 @@ let SessionsList = class SessionsList extends Disposable {
                     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),
+                    getUngroupedSectionIdOfSession: session => this.getUngroupedSectionIdOfSession(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),
@@ -2154,8 +3514,11 @@ let SessionsList = class SessionsList extends Disposable {
                     }
                 },
                 horizontalScrolling: false,
+                transformOptimization: false,
                 multipleSelectionSupport: true,
-                expandOnlyOnTwistieClick: element => isSessionItem(element),
+                allowNonCollapsibleParents: true,
+                enableStickyScroll: true,
+                expandOnlyOnTwistieClick: element => isSessionItem(element) || (isSessionGroupItem(element) && element.comparison !== undefined),
                 findWidgetEnabled: true,
                 defaultFindMode: TreeFindMode.Filter,
                 findWidgetContainer: this.options.findWidgetContainer,
@@ -2169,7 +3532,7 @@ let SessionsList = class SessionsList extends Disposable {
                 keyboardNavigationLabelProvider: {
                     getKeyboardNavigationLabel: element => {
                         if (isSessionGroupItem(element)) {
-                            return element.group.name;
+                            return element.comparison?.title ?? element.group.name;
                         }
                         if (isSessionSection(element)) {
                             return element.label;
@@ -2188,7 +3551,7 @@ let SessionsList = class SessionsList extends Disposable {
                 },
                 overrideStyles: this.options.overrideStyles,
                 renderIndentGuides: RenderIndentGuides.None,
-                twistieAdditionalCssClass: element => isSessionItem(element) && getSessionListChats(element).length > 0 ? "session-chat-twistie" : "force-no-twistie"
+                twistieAdditionalCssClass: element => isSessionItem(element) && getSessionListChats(element, undefined, !this._excludeArchived).length > 0 ? "session-chat-twistie" : "force-no-twistie"
             })
         );
         const focusedChatItemContext = SessionsListFocusedChatItemContext.bindTo(this.tree.contextKeyService);
@@ -2197,6 +3560,9 @@ let SessionsList = class SessionsList extends Disposable {
             defaultIndent: 0,
             expandOnDoubleClick: false
         });
+        if (this.options.onDidScroll) {
+            this._register(this.tree.onDidScroll(() => this.options.onDidScroll?.()));
+        }
         const guideOwnerSessionId = element => {
             if (element && isSessionItem(element)) {
                 return element.sessionId;
@@ -2224,6 +3590,11 @@ let SessionsList = class SessionsList extends Disposable {
                 this.hoveredGuideSessionId.set(undefined, undefined);
             }
         }));
+        this._register(this.tree.onMouseClick(e => {
+            if (e.element && isSessionGroupItem(e.element) && e.element.comparison && e.browserEvent.button === 0) {
+                this.commandService.executeCommand(OPEN_SESSION_COMPARISON_COMMAND_ID, e.element.comparison.id);
+            }
+        }));
         this._register(this.tree.onDidChangeSelection(() => {
             this.selectedGuideSessionIds.set(guideOwnerSessionIds(this.tree.getSelection()), undefined);
         }));
@@ -2242,6 +3613,10 @@ let SessionsList = class SessionsList extends Disposable {
             if (!element) {
                 return;
             }
+            if (isSessionSection(element) && element.id === AUTOMATIONS_SECTION_ID) {
+                await this.commandService.executeCommand("sessionsView.manageAutomations");
+                return;
+            }
             if (isSessionShowMore(element)) {
                 if (element.kind === "folders") {
                     this.expandedMoreFolders = element.mode === "more";
@@ -2259,34 +3634,23 @@ let SessionsList = class SessionsList extends Disposable {
                 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);
-                }
+                await this.beginOpenRequest(element.session, element.chat, preserveFocus, e.sideBySide);
                 return;
             }
-            if (isSessionSection(element) && element.id === AUTOMATIONS_SECTION_ID) {
-                this.tree.setSelection([]);
-                this.commandService.executeCommand("sessionsView.manageAutomations");
+            if (isSessionGroupItem(element) && element.comparison) {
+                if (!isMouseEvent(e.browserEvent) || e.browserEvent.button !== 0) {
+                    this.commandService.executeCommand(OPEN_SESSION_COMPARISON_COMMAND_ID, element.comparison.id);
+                }
                 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 (!(await this.beginOpenRequest(element, undefined, preserveFocus, e.sideBySide))) {
+                    return;
+                }
                 if (this._listVoicePlaybackService.hasPendingResponse(element.resource)) {
                     this.commandService.executeCommand("_chat.voice.activateSession", ( element.resource.toString()));
                 }
@@ -2311,15 +3675,7 @@ let SessionsList = class SessionsList extends Disposable {
             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.setCompact();
         }));
         this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
         this._register(this.tree.onDidChangeCollapseState(e => {
@@ -2332,7 +3688,12 @@ let SessionsList = class SessionsList extends Disposable {
             } else if (element && isSessionSection(element)) {
                 sectionRenderer.updateCollapseState(element, e.node.collapsed);
                 if (!this.suspendCollapseStatePersistence) {
-                    this.saveSectionCollapseState(element.id, e.node.collapsed);
+                    this.saveSectionCollapseState(element.collapseStateId ?? element.id, e.node.collapsed);
+                }
+            } else if (element && isSessionItem(element)) {
+                this.syncCollapsedSessionIds();
+                if (!this.suspendCollapseStatePersistence) {
+                    this.saveSessionCollapseState(element, e.node.collapsed);
                 }
             }
         }));
@@ -2347,6 +3708,7 @@ let SessionsList = class SessionsList extends Disposable {
         };
         this._register(this.tree.onDidChangeFindOpenState(open => {
             isFindOpen = open;
+            this.findOpen.set(open, undefined);
             this._onDidChangeFindOpenState.fire(open);
             updateFindPatternState();
         }));
@@ -2385,6 +3747,7 @@ let SessionsList = class SessionsList extends Disposable {
                 this.update();
             }
         }));
+        this._register(this.filters.onDidChange(() => this.update()));
         this._register(autorun(reader => {
             const activeSession = this._sessionsService.activeSession.read(reader);
             activeSession?.activeChat.read(reader);
@@ -2419,7 +3782,9 @@ let SessionsList = class SessionsList extends Disposable {
         let initialized = false;
         this.sessionChatsObserver.value = autorun(reader => {
             for (const session of this.sessions) {
-                getSessionListChats(session, reader);
+                getSessionListChats(session, reader, !this._excludeArchived);
+                session.isExternal?.read(reader);
+                session.application.read(reader);
             }
             if (initialized && this.visible) {
                 this.update();
@@ -2434,26 +3799,24 @@ let SessionsList = class SessionsList extends Disposable {
     }
     update(expandAll) {
         const activeSession = this._sessionsService.activeSession.get();
-        const archiveOnboardingSession = this.archiveOnboardingSession.get();
+        const onboardingSession = this.onboardingTarget.get()?.session;
+        const nextNestedSessionResources = ( new Set(
+            this.sessions.filter(session => getSessionListChats(session).length > 0).map(session => ( session.resource.toString()))
+        ));
         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())));
+        filtered = filtered.filter(session => this.filters.matches(session));
+        if (this._excludeArchivedIsDefault && ( filtered.some(session => hasArchivedListContent(session)))) {
+            logSettingExperimentTrigger(this.telemetryService, SESSIONS_LIST_SHOW_ARCHIVED_BY_DEFAULT_SETTING);
         }
         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]) {
+        for (const revealedSession of [activeSession, onboardingSession]) {
             if (revealedSession && !( filtered.some(s => s.sessionId === revealedSession.sessionId))) {
                 const match = this.sessions.find(s => s.sessionId === revealedSession.sessionId && !isAutomationSession(s));
                 if (match) {
@@ -2461,6 +3824,10 @@ let SessionsList = class SessionsList extends Disposable {
                 }
             }
         }
+        filtered = filtered.filter(session => {
+            const comparison = this.sessionComparisonService.getComparisonForSession(session.resource);
+            return !comparison || !isComparisonLaunchPending(comparison);
+        });
         const grouping = this.options.grouping();
         const sorting = this.options.sorting();
         const sortKeyForGrouping = (s, srt) => this._sessionsListModelService.getSortKey(s, sortingToMode(srt));
@@ -2479,15 +3846,43 @@ let SessionsList = class SessionsList extends Disposable {
             }
         }
         const forSections = groupedRegularIds.size > 0 ? filtered.filter(s => !( groupedRegularIds.has(s.sessionId))) : filtered;
+        if (( forSections.some(
+            session => session.isExternal?.get() && !session.isArchived.get() && !this.isSessionPinned(session)
+        ))) {
+            logSettingExperimentTrigger(this.telemetryService, SESSIONS_LIST_GROUP_EXTERNAL_SESSIONS_SETTING);
+        }
         const groupItemsById = ( new Map());
+        const comparisonsByGroupId = ( new Map(
+            this.sessionComparisonService.comparisons.get().map(comparison => [comparison.groupId, comparison])
+        ));
+        this.renderedComparisonAttemptConnectorPositions.clear();
+        this.renderedComparisonAttemptLabels.clear();
         for (const group of this._sessionGroupsService.getGroups()) {
             const members = groupedMembers.get(group.id) ?? [];
-            const sortedMembers = sortSessions(members, sorting, sortKeyForGrouping);
+            const comparison = comparisonsByGroupId.get(group.id);
+            const sortedMembers = comparison ? sortComparisonGroupMembers(comparison, members, sorting, sortKeyForGrouping) : sortSessions(members, sorting, sortKeyForGrouping);
+            if (comparison) {
+                const attempts = comparison.participants.filter(
+                    participant => participant.role === SessionComparisonParticipantRole.Attempt
+                );
+                for (const participant of attempts) {
+                    const session = participant.sessionResource ? members.find(member => isEqual(member.resource, participant.sessionResource)) : undefined;
+                    if (session) {
+                        this.renderedComparisonAttemptLabels.set(session.sessionId, getSessionComparisonHarnessLabel(participant));
+                    }
+                }
+            }
             groupItemsById.set(group.id, {
                 group,
                 sessions: sortedMembers,
                 isEmpty: this._sessionGroupsService.getSessionIdsInGroup(group.id).length === 0,
-                editing: group.id === this._editingGroupId
+                editing: group.id === this._editingGroupId,
+                comparison: comparison ? {
+                    id: comparison.id,
+                    title: comparison.title,
+                    launching: comparison.launching === true,
+                    summary: reader => getComparisonGroupSummary(comparison, this.sessions, reader)
+                } : undefined
             });
         }
         const defaultGroupIds = [...( groupItemsById.values())].sort((a, b) => b.group.createdAt - a.group.createdAt).map(item => `group:${item.group.id}`);
@@ -2497,14 +3892,15 @@ let SessionsList = class SessionsList extends Disposable {
             sorting,
             session => this.isSessionPinned(session),
             (s, srt) => this._sessionsListModelService.getSortKey(s, sortingToMode(srt)),
-            getChatSessionArchivedSectionLabel(getChatSessionArchiveActionWording(this.configurationService))
+            getChatSessionArchivedSectionLabel(getChatSessionArchiveActionWording(this.configurationService)),
+            this.groupExternalSessions
         );
         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(4934, "Chats")),
+                label: ( localize(6176, "Chats")),
                 sessions: []
             });
         }
@@ -2538,7 +3934,7 @@ let SessionsList = class SessionsList extends Disposable {
                     }
                 }
                 for (const section of workspaceSections) {
-                    if (!meetsCriteria(section) && section.id !== fallbackId && !this._sessionSectionOrderService.isPromoted(section.id) && !( section.sessions.some(session => session.sessionId === archiveOnboardingSession?.sessionId))) {
+                    if (!meetsCriteria(section) && section.id !== fallbackId && !this._sessionSectionOrderService.isPromoted(section.id) && !( section.sessions.some(session => session.sessionId === onboardingSession?.sessionId))) {
                         moreFolderSectionIds.add(section.id);
                     }
                 }
@@ -2547,13 +3943,16 @@ let SessionsList = class SessionsList extends Disposable {
         const children = [];
         const sessionGroupLimit = this.sessionGroupLimit.get();
         const toSessionChildren = sessions => sessions.map(session => {
-            const chats = getSessionListChats(session);
+            const chats = sortSessionListChats(getSessionListChats(session, undefined, !this._excludeArchived), sorting);
+            const resource = ( session.resource.toString());
+            const wasNested = ( this.nestedSessionResources.has(resource));
+            const persistedCollapsed = ( this.collapsedSessionResources.has(resource));
             return {
                 element: session,
                 collapsible: chats.length > 0,
-                collapsed: ObjectTreeElementCollapseState.PreserveOrExpanded,
-                children: chats.length > 0 ? chats.map(chat => ({
-                    element: ( new SessionChatItem(session, chat))
+                collapsed: wasNested ? persistedCollapsed ? ObjectTreeElementCollapseState.PreserveOrCollapsed : ObjectTreeElementCollapseState.PreserveOrExpanded : persistedCollapsed ? ObjectTreeElementCollapseState.Collapsed : ObjectTreeElementCollapseState.Expanded,
+                children: chats.length > 0 ? chats.map((chat, index) => ({
+                    element: ( new SessionChatItem(session, chat, index === chats.length - 1))
                 })) : undefined
             };
         });
@@ -2563,7 +3962,7 @@ let SessionsList = class SessionsList extends Disposable {
                 expanded: ( this.expandedSessionGroups.has(sectionId)),
                 sectionId,
                 sectionLabel,
-                revealSessionId: archiveOnboardingSession?.sessionId
+                revealSessionId: onboardingSession?.sessionId
             });
             const children = toSessionChildren(limited.sessions);
             if (limited.showMore) {
@@ -2574,7 +3973,7 @@ let SessionsList = class SessionsList extends Disposable {
             return children;
         };
         const renderSection = section => {
-            if (section.id === AUTOMATIONS_SECTION_ID) {
+            if (isShortcutSection(section.id)) {
                 return {
                     element: section,
                     children: [],
@@ -2589,7 +3988,7 @@ let SessionsList = class SessionsList extends Disposable {
                     element: {
                         placeholder: true,
                         sectionId: section.id,
-                        label: ( localize(4935, "No chats"))
+                        label: ( localize(6177, "No chats"))
                     }
                 }];
             }
@@ -2609,7 +4008,10 @@ let SessionsList = class SessionsList extends Disposable {
             return {
                 element: section,
                 collapsible: true,
-                collapsed: this.getSavedCollapseState(section.id) ?? defaultCollapsed,
+                collapsed: this.getSavedCollapseState(
+                    section.collapseStateId ?? section.id,
+                    section.collapseStateId ? section.id : undefined
+                ) ?? defaultCollapsed,
                 children: sectionChildren
             };
         };
@@ -2619,9 +4021,9 @@ let SessionsList = class SessionsList extends Disposable {
                 element: {
                     placeholder: true,
                     sectionId,
-                    label: ( localize(4936, "No session")),
+                    label: ( localize(6178, "No session")),
                     hover: ( localize(
-                        4937,
+                        6179,
                         "Use Add to Group from a session's context menu, or drag it into this group."
                     ))
                 }
@@ -2631,6 +4033,16 @@ let SessionsList = class SessionsList extends Disposable {
                 groupItem.group.name,
                 !this.hasFindPattern && this.workspaceGroupCapped
             );
+            const visibleGroupSessions = groupChildren.map(child => child.element).filter(isSessionItem);
+            const connectorSessions = groupItem.comparison ? visibleGroupSessions.filter(session => ( this.renderedComparisonAttemptLabels.has(session.sessionId))) : [];
+            if (connectorSessions.length > 1) {
+                for (let index = 0; index < connectorSessions.length; index++) {
+                    this.renderedComparisonAttemptConnectorPositions.set(
+                        connectorSessions[index].sessionId,
+                        index === 0 ? "first" : index === connectorSessions.length - 1 ? "last" : "middle"
+                    );
+                }
+            }
             return {
                 element: groupItem,
                 collapsible: true,
@@ -2638,14 +4050,35 @@ let SessionsList = class SessionsList extends Disposable {
                 children: groupChildren
             };
         };
+        const navigationSections = [];
+        const showNavigationShortcuts = this.options.showNavigationShortcuts?.() === true;
+        if (showNavigationShortcuts) {
+            navigationSections.push({
+                id: NEW_SESSION_SECTION_ID,
+                label: ( localize(6180, "New Session")),
+                sessions: []
+            });
+        }
         if (this.contextKeyService.getContextKeyValue(ChatAutomationsEnabledContext.key)) {
-            void this.automationsNewBadgeState.initialize().catch(onUnexpectedError);
-            children.push(renderSection({
+            const automationsSection = {
                 id: AUTOMATIONS_SECTION_ID,
-                label: ( localize(4938, "Automations")),
+                label: ( localize(6181, "Automations")),
                 sessions: []
-            }));
+            };
+            if (showNavigationShortcuts) {
+                navigationSections.push(automationsSection);
+            } else {
+                children.push(renderSection(automationsSection));
+            }
+        }
+        if (showNavigationShortcuts) {
+            navigationSections.push({
+                id: CUSTOMIZATIONS_SECTION_ID,
+                label: ( localize(6182, "Customizations")),
+                sessions: []
+            });
         }
+        this.setNavigationSections(navigationSections);
         const pinnedSection = sections.find(s => s.id === "pinned");
         if (pinnedSection) {
             children.push(renderSection(pinnedSection));
@@ -2667,15 +4100,11 @@ let SessionsList = class SessionsList extends Disposable {
                 renderGroupById(id);
             }
             for (const section of sections) {
-                if (section.id === "pinned" || section.id === "archived" || section.id === QUICK_CHATS_SECTION_ID) {
+                if (section.id === "pinned" || section.id === "archived" || section.id === QUICK_CHATS_SECTION_ID || section.id === EXTERNAL_SESSIONS_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])));
@@ -2722,16 +4151,87 @@ let SessionsList = class SessionsList extends Disposable {
                     });
                 }
             }
-            const archivedSection = sections.find(s => s.id === "archived");
-            if (archivedSection) {
-                children.push(renderSection(archivedSection));
-            }
+        }
+        const externalSection = sections.find(s => s.id === EXTERNAL_SESSIONS_SECTION_ID);
+        if (externalSection) {
+            children.push(renderSection(externalSection));
+        }
+        const archivedSection = sections.find(s => s.id === "archived");
+        if (archivedSection) {
+            children.push(renderSection(archivedSection));
         }
         this.tree.setChildren(null, children);
-        this.reconcileChatApprovalHeights();
+        this.nestedSessionResources = nextNestedSessionResources;
+        this.syncCollapsedSessionIds();
+        this.reconcileChatRowHeights();
         this._onDidUpdate.fire();
     }
-    reconcileChatApprovalHeights() {
+    setNavigationSections(sections) {
+        if (!this.navigationList || !this.options.navigationContainer) {
+            return;
+        }
+        if (sections.length === this.navigationSections.length && sections.every((section, index) => section.id === this.navigationSections[index].id)) {
+            return;
+        }
+        const focusedSectionId = this.navigationList.getFocusedElements()[0]?.id;
+        const hadDomFocus = isAncestorOfActiveElement(this.options.navigationContainer);
+        this.navigationSections = sections;
+        this.navigationList.splice(0, this.navigationList.length, sections);
+        this.options.navigationContainer.classList.toggle("empty", sections.length === 0);
+        this.layoutNavigation(this.options.navigationContainer.clientWidth);
+        this.options.onDidChangeNavigationHeight?.();
+        if (hadDomFocus && focusedSectionId) {
+            const focusedIndex = sections.findIndex(section => section.id === focusedSectionId);
+            if (focusedIndex >= 0) {
+                this.navigationList.setFocus([focusedIndex]);
+                this.navigationList.domFocus();
+            }
+        }
+    }
+    layoutNavigation(width) {
+        this.navigationList?.layout(this.navigationSections.length * SESSION_SHORTCUT_ROW_HEIGHT, width);
+    }
+    async openNavigationSection(section, sideBySide) {
+        if (!section || !this.navigationList) {
+            return;
+        }
+        this.navigationList.setSelection([]);
+        switch (section.id) {
+        case NEW_SESSION_SECTION_ID:
+            this._onDidActivateNewSession.fire();
+            logSessionsInteraction(this.telemetryService, "newSession", "sidebar");
+            await this.commandService.executeCommand(NEW_SESSION_ACTION_ID, sideBySide ? {
+                toSide: true
+            } : undefined);
+            if (this.options.navigationContainer && isAncestorOfActiveElement(this.options.navigationContainer)) {
+                this.options.focusNewSessionInput?.();
+            }
+            break;
+        case AUTOMATIONS_SECTION_ID:
+            await this.commandService.executeCommand("sessionsView.manageAutomations");
+            break;
+        case CUSTOMIZATIONS_SECTION_ID:
+            await this.commandService.executeCommand(OPEN_AI_CUSTOMIZATIONS_COMMAND_ID);
+            break;
+        }
+    }
+    syncCollapsedSessionIds() {
+        const collapsedSessionIds = ( new Set());
+        const collect = node => {
+            if (node.element && isSessionItem(node.element) && node.collapsed) {
+                collapsedSessionIds.add(node.element.sessionId);
+            }
+            for (const child of node.children) {
+                collect(child);
+            }
+        };
+        collect(this.tree.getNode(null));
+        const current = this.collapsedSessionIds.get();
+        if (current.size !== collapsedSessionIds.size || ( [...current].some(sessionId => !( collapsedSessionIds.has(sessionId))))) {
+            this.collapsedSessionIds.set(collapsedSessionIds, undefined);
+        }
+    }
+    reconcileChatRowHeights() {
         const chatItems = [];
         const collect = node => {
             if (node.element && isSessionChatItem(node.element)) {
@@ -2743,14 +4243,19 @@ let SessionsList = class SessionsList extends Disposable {
         };
         collect(this.tree.getNode());
         if (chatItems.length === 0) {
-            this.chatApprovalHeightReconcile.clear();
+            this.chatRowHeightReconcile.clear();
             return;
         }
-        this.chatApprovalHeightReconcile.value = autorun(reader => {
+        this.chatRowHeightReconcile.value = autorun(reader => {
             for (const chatItem of chatItems) {
                 this._approvalModel.getApproval(chatItem.chat.resource).read(reader);
-                if (this.tree.hasElement(chatItem)) {
+                if (this.tree.hasElement(chatItem) && this.tree.getRelativeTop(chatItem) !== null) {
+                    chatItem.session.workspace.read(reader);
+                    chatItem.chat.workspace.read(reader);
+                    chatItem.chat.updatedAt.read(reader);
                     this.tree.updateElementHeight(chatItem, this._delegate.getHeight(chatItem));
+                } else if (this.tree.hasElement(chatItem)) {
+                    this.tree.updateElementHeight(chatItem, this._delegate.getHeightWithoutChatWorkspace(chatItem));
                 }
             }
         });
@@ -2772,8 +4277,16 @@ let SessionsList = class SessionsList extends Disposable {
             this.tree.setSelection([session]);
             return;
         }
-        this.tree.expand(session);
-        this.tree.reveal(chatItem, 0.5);
+        const previousSuspendCollapseStatePersistence = this.suspendCollapseStatePersistence;
+        this.suspendCollapseStatePersistence = true;
+        try {
+            this.tree.expand(session);
+        } finally {
+            this.suspendCollapseStatePersistence = previousSuspendCollapseStatePersistence;
+        }
+        if (this.tree.getRelativeTop(chatItem) === null) {
+            this.tree.reveal(chatItem, 0.5);
+        }
         this.tree.setFocus([chatItem]);
         this.tree.setSelection([chatItem]);
     }
@@ -2817,11 +4330,24 @@ let SessionsList = class SessionsList extends Disposable {
         return false;
     }
     revealArchiveAction(session) {
+        return this.revealOnboardingTarget(session, true);
+    }
+    revealSessionForOnboarding(session) {
+        return this.revealOnboardingTarget(session, false);
+    }
+    revealOnboardingTarget(session, archiveAction) {
         this.customViewService.hideCustomView();
         this.closeFind();
-        this.archiveOnboardingSession.set(session, undefined);
+        const target = {
+            session,
+            archiveAction
+        };
+        this.onboardingTarget.set(target, undefined);
         const release = toDisposable(() => {
-            this.archiveOnboardingSession.set(undefined, undefined);
+            if (this.onboardingTarget.get() !== target) {
+                return;
+            }
+            this.onboardingTarget.set(undefined, undefined);
             if (!this._store.isDisposed) {
                 this.update();
             }
@@ -2829,14 +4355,14 @@ let SessionsList = class SessionsList extends Disposable {
         try {
             this.update();
             if (!this.reveal(session.resource)) {
-                throw ( new Error(( localize(4939, "The session could not be revealed in the sessions list. Try again."))));
+                throw ( new Error(( localize(6183, "The session could not be revealed in the sessions list. Try again."))));
             }
         } catch (error) {
             release.dispose();
             throw error;
         }
         return {
-            targetId: getSessionArchiveOnboardingTargetId(session),
+            targetId: archiveAction ? getSessionArchiveOnboardingTargetId(session) : getSessionOnboardingTargetId(session),
             dispose: () => release.dispose()
         };
     }
@@ -2844,6 +4370,31 @@ let SessionsList = class SessionsList extends Disposable {
         this.tree.setFocus([]);
         this.tree.setSelection([]);
     }
+    findItem(item) {
+        const extUri = this.uriIdentityService.extUri;
+        if (hasKey(item, {
+            group: true
+        })) {
+            return this.findTreeElement(element => isSessionGroupItem(element) && element.group.id === item.group);
+        }
+        if (hasKey(item, {
+            section: true
+        })) {
+            return this.findTreeElement(element => isSessionSection(element) && element.id === item.section);
+        }
+        const {
+            session,
+            chat
+        } = item;
+        if (chat) {
+            return this.findTreeElement(
+                element => isSessionChatItem(element) && extUri.isEqual(element.session.resource, session) && extUri.isEqual(element.chat.resource, chat)
+            );
+        }
+        return this.findTreeElement(
+            element => isSessionItem(element) && extUri.isEqual(element.resource, session)
+        );
+    }
     hasFocusOrSelection() {
         return this.tree.getFocus().length > 0 || this.tree.getSelection().length > 0;
     }
@@ -2869,14 +4420,62 @@ let SessionsList = class SessionsList extends Disposable {
             this.refresh();
         }
     }
-    layout(height, width) {
-        this.tree.layout(height, width);
+    layout(height, width) {
+        this.layoutNavigation(width);
+        this.tree.layout(height, width);
+    }
+    setCompact() {
+        this.listContainer.classList.toggle("compact", this.isCompact());
+        this.update();
+    }
+    focus() {
+        this.tree.domFocus();
+        if (this.tree.getFocus().length === 0) {
+            this.tree.focusFirst();
+        }
+    }
+    isAutomationsFocused() {
+        return this.isNavigationSectionFocused(AUTOMATIONS_SECTION_ID) || (isAncestorOfActiveElement(this.listContainer) && ( this.tree.getFocus().some(
+            element => !!element && isSessionSection(element) && element.id === AUTOMATIONS_SECTION_ID
+        )));
+    }
+    focusAutomations() {
+        if (( this.navigationSections.some(section => section.id === AUTOMATIONS_SECTION_ID))) {
+            this.focusNavigationSection(AUTOMATIONS_SECTION_ID);
+        } else {
+            this.closeFind();
+            const section = this.tree.getNode().children.find(
+                node => node.element && isSessionSection(node.element) && node.element.id === AUTOMATIONS_SECTION_ID
+            )?.element;
+            if (section) {
+                this.tree.setFocus([section]);
+                this.tree.setSelection([]);
+                this.tree.reveal(section);
+                this.tree.domFocus();
+            }
+        }
+    }
+    isCustomizationsFocused() {
+        return this.isNavigationSectionFocused(CUSTOMIZATIONS_SECTION_ID);
+    }
+    focusCustomizations() {
+        this.focusNavigationSection(CUSTOMIZATIONS_SECTION_ID);
     }
-    focus() {
-        this.tree.domFocus();
-        if (this.tree.getFocus().length === 0) {
-            this.tree.focusFirst();
+    isNavigationSectionFocused(sectionId) {
+        return !!this.options.navigationContainer && isAncestorOfActiveElement(this.options.navigationContainer) && this.navigationList?.getFocusedElements().some(section => section.id === sectionId) === true;
+    }
+    focusNavigationSection(sectionId) {
+        this.closeFind();
+        const index = this.navigationSections.findIndex(section => section.id === sectionId);
+        if (!this.navigationList || index < 0) {
+            return;
         }
+        this.navigationList.setFocus([index]);
+        this.navigationList.setSelection([]);
+        this.navigationList.domFocus();
+    }
+    updateNavigationVisibility() {
+        this.update();
     }
     openFind() {
         this.tree.openFind();
@@ -2901,6 +4500,13 @@ let SessionsList = class SessionsList extends Disposable {
         ))) {
             return false;
         }
+        const targetExternal = this.isRenderedInExternalSection(target);
+        if (( dragged.some(s => this.isRenderedInExternalSection(s) !== targetExternal))) {
+            return false;
+        }
+        if (targetExternal) {
+            return true;
+        }
         if (targetGroup === undefined && this.options.grouping() === SessionsGrouping.Workspace) {
             const targetLabel = sessionWorkspaceLabel(target);
             return dragged.every(s => sessionWorkspaceLabel(s) === targetLabel);
@@ -2919,7 +4525,9 @@ let SessionsList = class SessionsList extends Disposable {
             scope = scope.filter(
                 s => this._sessionGroupsService.getGroupOfSession(s.sessionId) === targetGroup
             );
-            if (targetGroup === undefined && grouping === SessionsGrouping.Workspace) {
+            const targetExternal = this.isRenderedInExternalSection(target);
+            scope = scope.filter(s => this.isRenderedInExternalSection(s) === targetExternal);
+            if (!targetExternal && targetGroup === undefined && grouping === SessionsGrouping.Workspace) {
                 const targetLabel = sessionWorkspaceLabel(target);
                 scope = scope.filter(s => sessionWorkspaceLabel(s) === targetLabel);
             }
@@ -2951,6 +4559,9 @@ let SessionsList = class SessionsList extends Disposable {
         this._sessionsListModelService.applySortChanges(mode, set, clear);
     }
     createGroupFromSessions(sessions) {
+        if (( sessions.some(session => this.isActiveComparisonSession(session)))) {
+            return;
+        }
         const groupSessions = sessions.filter(session => !session.isArchived.get());
         if (groupSessions.length === 0) {
             return;
@@ -2959,31 +4570,149 @@ let SessionsList = class SessionsList extends Disposable {
     }
     createGroup(groupSessions) {
         this._sessionsListModelService.unpinSessions(groupSessions);
-        const group = this._sessionGroupsService.createGroup(( localize(4940, "New Group")), groupSessions.map(s => s.sessionId));
+        const group = this._sessionGroupsService.createGroup(( localize(6184, "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;
-            }
+        const group = this.findTreeElement(element => isSessionGroupItem(element) && element.group.id === groupId);
+        if (group && this.tree.getRelativeTop(group) === null) {
+            this.tree.reveal(group, 0.5);
         }
     }
     beginRenameGroup(groupId) {
-        if (!this._sessionGroupsService.getGroup(groupId)) {
+        if (!this._sessionGroupsService.getGroup(groupId) || this.isComparisonGroup(groupId)) {
             return;
         }
         this._editingGroupId = groupId;
         this.update();
     }
+    async beginOpenRequest(session, chat, preserveFocus, sideBySide) {
+        const request = {
+            session,
+            chat,
+            preserveFocus,
+            sideBySide,
+            started: false,
+            invocation: 0
+        };
+        this.pendingOpenRequest = request;
+        try {
+            if (this.options.canOpenSession && !(await this.options.canOpenSession(session))) {
+                if (this.pendingOpenRequest === request) {
+                    this.pendingOpenRequest = undefined;
+                }
+                return false;
+            }
+        } catch (error) {
+            if (this.pendingOpenRequest === request) {
+                this.pendingOpenRequest = undefined;
+            }
+            throw error;
+        }
+        if (this.pendingOpenRequest !== request) {
+            return false;
+        }
+        const sessionRowRepresentsSession = getSessionListChats(session).length === 0 || ( this.collapsedSessionIds.get().has(session.sessionId));
+        if (!request.chat && sessionRowRepresentsSession && this._sessionsService.activeSession.get()?.sessionId !== session.sessionId) {
+            this.markRead(session);
+        }
+        this.invokeOpenRequest(request);
+        return true;
+    }
+    invokeOpenRequest(request) {
+        request.started = true;
+        const invocation = ++request.invocation;
+        const finish = opened => {
+            if (this.pendingOpenRequest === request && request.invocation === invocation) {
+                this.pendingOpenRequest = undefined;
+                if (opened) {
+                    this._onDidOpenSession.fire(request.chat?.resource ?? request.session.resource);
+                }
+            }
+        };
+        let open;
+        try {
+            if (request.chat) {
+                open = this.options.onChatOpen ? this.options.onChatOpen(request.session, request.chat, request.preserveFocus, request.sideBySide) : this._sessionsService.openChat(request.session, request.chat.resource, {
+                    preserveFocus: request.preserveFocus
+                }).catch(onUnexpectedError);
+            } else {
+                open = this.options.onSessionOpen(request.session.resource, request.preserveFocus, request.sideBySide);
+            }
+        } catch (error) {
+            finish(false);
+            throw error;
+        }
+        if (!open) {
+            finish(true);
+            return;
+        }
+        open.then(() => finish(true), error => {
+            finish(false);
+            onUnexpectedError(error);
+        });
+    }
+    preservePendingOpenFocus(session, chat) {
+        const request = this.pendingOpenRequest;
+        if (!request || !this.uriIdentityService.extUri.isEqual(request.session.resource, session.resource) || (!!request.chat !== !!chat) || (request.chat && chat && !this.uriIdentityService.extUri.isEqual(request.chat.resource, chat.resource))) {
+            return;
+        }
+        request.preserveFocus = true;
+        if (request.started) {
+            this.invokeOpenRequest(request);
+        }
+    }
+    beginRenameSession(session) {
+        const target = this.findTreeElement(
+            element => isSessionItem(element) && this.uriIdentityService.extUri.isEqual(element.resource, session.resource)
+        );
+        if (!target) {
+            return false;
+        }
+        if (this.tree.getRelativeTop(target) === null) {
+            this.tree.reveal(target, 0.5);
+        }
+        if (!this._sessionRenderer.beginRename(target)) {
+            return false;
+        }
+        return true;
+    }
+    beginRenameChat(item) {
+        const target = this.findTreeElement(
+            element => isSessionChatItem(element) && this.uriIdentityService.extUri.isEqual(element.session.resource, item.session.resource) && this.uriIdentityService.extUri.isEqual(element.chat.resource, item.chat.resource)
+        );
+        if (!target) {
+            return false;
+        }
+        if (this.tree.getRelativeTop(target) === null) {
+            this.tree.reveal(target, 0.5);
+        }
+        if (!this._chatRenderer.beginRename(target)) {
+            return false;
+        }
+        return true;
+    }
+    findTreeElement(predicate) {
+        const visit = nodes => {
+            for (const node of nodes) {
+                if (node.element && predicate(node.element)) {
+                    return node.element;
+                }
+                const match = visit(node.children);
+                if (match) {
+                    return match;
+                }
+            }
+            return undefined;
+        };
+        return visit(this.tree.getNode().children);
+    }
     addSessionsToGroup(sessions, groupId, target, position) {
+        if (this.isComparisonGroup(groupId) || ( sessions.some(session => this.isActiveComparisonSession(session)))) {
+            return;
+        }
         const groupSessions = sessions.filter(session => !session.isArchived.get());
         this._sessionsListModelService.unpinSessions(groupSessions);
         this._sessionGroupsService.addToGroup(groupSessions.map(s => s.sessionId), groupId);
@@ -2992,6 +4721,9 @@ let SessionsList = class SessionsList extends Disposable {
         }
     }
     removeSessionsFromGroup(sessions, target, position) {
+        if (( sessions.some(session => this.isActiveComparisonSession(session)))) {
+            return;
+        }
         const groupedSessions = sessions.filter(
             session => this._sessionGroupsService.getGroupOfSession(session.sessionId) !== undefined
         );
@@ -3005,8 +4737,14 @@ let SessionsList = class SessionsList extends Disposable {
             this.reorderSessions(groupedSessions, target, position);
         }
     }
-    getWorkspaceSectionIdOfSession(session) {
-        if (this.options.grouping() !== SessionsGrouping.Workspace || session.isArchived.get() || this.isSessionPinned(session) || isQuickChatSession(session)) {
+    getUngroupedSectionIdOfSession(session) {
+        if (session.isArchived.get() || this.isSessionPinned(session)) {
+            return undefined;
+        }
+        if (this.groupExternalSessions && session.isExternal?.get()) {
+            return EXTERNAL_SESSIONS_SECTION_ID;
+        }
+        if (this.options.grouping() !== SessionsGrouping.Workspace || isQuickChatSession(session)) {
             return undefined;
         }
         return `workspace:${sessionWorkspaceLabel(session)}`;
@@ -3078,10 +4816,17 @@ let SessionsList = class SessionsList extends Disposable {
             this.showChatContextMenu(element, e.anchor);
             return;
         }
-        if (!element || isSessionSection(element) || isSessionShowMore(element) || isSessionPlaceholder(element)) {
+        if (!element || isSessionShowMore(element) || isSessionPlaceholder(element)) {
             this.showCreateGroupContextMenu(e.anchor);
             return;
         }
+        if (isSessionSection(element)) {
+            if (isShortcutSection(element.id)) {
+                return;
+            }
+            this.showSectionContextMenu(element, e.anchor);
+            return;
+        }
         if (isSessionGroupItem(element)) {
             this.showGroupContextMenu(element, e.anchor);
             return;
@@ -3090,15 +4835,24 @@ let SessionsList = class SessionsList extends Disposable {
         const inGroup = this._sessionGroupsService.getGroupOfSession(element.sessionId) !== undefined;
         const contextOverlay = [
             [IsSessionPinnedContext.key, this.isSessionPinned(element)],
+            [SessionItemIsMultiSelectionContext.key, selectedSessions.length > 1],
             [SessionIsArchivedContext.key, element.isArchived.get()],
-            [SessionIsReadContext.key, element.isRead.get()],
+            [SessionIsReadContext.key, element.mainChat.get().isRead.get()],
+            [SessionItemInGroupContext.key, inGroup],
             [
-                SessionItemHasBranchNameContext.key,
-                !!element.workspace.get()?.folders[0]?.gitRepository?.branchName?.trim()
+                SessionItemInExternalSectionContext.key,
+                this.isRenderedInExternalSection(element)
+            ],
+            [
+                SessionItemCanImportContext.key,
+                element.isExternal?.get() === true && element.capabilities.get().supportsImport === true
             ],
-            [SessionItemInGroupContext.key, inGroup],
             [SessionTypeContext.key, element.sessionType],
             [SessionProviderIdContext.key, element.providerId],
+            [
+                SessionSupportsMultipleChatsContext.key,
+                element.capabilities.get().supportsMultipleChats
+            ],
             [
                 SessionSupportsRenameContext.key,
                 element.capabilities.get().supportsRename ?? false
@@ -3107,12 +4861,14 @@ let SessionsList = class SessionsList extends Disposable {
                 SessionSupportsDeleteContext.key,
                 element.capabilities.get().supportsDelete ?? false
             ],
+            [IsQuickChatSessionContext.key, element.isQuickChat?.get() ?? false],
             [
                 SessionHasPullRequestContext.key,
                 !!element.workspace.get()?.folders[0]?.gitRepository?.gitHubInfo.get()?.pullRequest
             ]
         ];
         const disposables = ( new DisposableStore());
+        this._sessionContextMenuDisposables.value = disposables;
         const menu = disposables.add(this.menuService.createMenu(
             SessionItemContextMenuId,
             this.contextKeyService.createOverlay(contextOverlay)
@@ -3126,7 +4882,18 @@ let SessionsList = class SessionsList extends Disposable {
                 resource: s.resource
             }))
         };
-        const wrapForExtensions = action => {
+        const wrapAction = action => {
+            if (action.id === RENAME_SESSION_COMMAND_ID) {
+                return toAction({
+                    id: action.id,
+                    label: action.label,
+                    class: action.class,
+                    enabled: action.enabled,
+                    tooltip: action.tooltip,
+                    checked: action.checked,
+                    run: () => this.beginRenameSession(element)
+                });
+            }
             if (!(action instanceof MenuItemAction) || !action.item.source) {
                 return action;
             }
@@ -3143,25 +4910,33 @@ let SessionsList = class SessionsList extends Disposable {
         const baseActions = Separator.join(...menu.getActions({
             arg: selectedSessions,
             shouldForwardArgs: true
-        }).map(([, actions]) => actions.map(wrapForExtensions)));
+        }).map(([, actions]) => actions.map(wrapAction)));
         const groupActions = this.getGroupSessionActions(selectedSessions);
         const actions = groupActions.length > 0 ? [...baseActions, ( new Separator()), ...groupActions] : baseActions;
         if (actions.length === 0) {
-            disposables.dispose();
+            this._sessionContextMenuDisposables.clear();
             return;
         }
         this.contextMenuService.showContextMenu({
             getActions: () => actions,
             getAnchor: () => e.anchor,
             getKeyBinding: action => this.keybindingService.lookupKeybinding(action.id) ?? undefined,
-            onHide: () => disposables.dispose()
+            onHide: () => {
+                if (this._sessionContextMenuDisposables.value === disposables) {
+                    this._sessionContextMenuDisposables.clear();
+                } else {
+                    disposables.dispose();
+                }
+            }
         });
     }
     showChatContextMenu(element, anchor) {
         const capabilities = getChatCapabilities(element.chat, element.session, undefined);
         const contextKeyService = this.contextKeyService.createOverlay([
             [SessionChatItemCanRenameContext.key, capabilities.canRename],
+            [SessionChatItemCanArchiveContext.key, capabilities.canArchive],
             [SessionChatItemCanDeleteContext.key, capabilities.canDelete],
+            [SessionChatItemIsArchivedContext.key, element.chat.isArchived.get()],
             [
                 SessionChatItemIsUntitledContext.key,
                 element.chat.status.get() === SessionStatus.Untitled
@@ -3169,10 +4944,19 @@ let SessionsList = class SessionsList extends Disposable {
             [SessionProviderIdContext.key, element.session.providerId]
         ]);
         const menu = this.menuService.createMenu(Menus.SessionChatItemContext, contextKeyService);
+        const wrapAction = action => action.id === RENAME_CHAT_COMMAND_ID ? toAction({
+            id: action.id,
+            label: action.label,
+            class: action.class,
+            enabled: action.enabled,
+            tooltip: action.tooltip,
+            checked: action.checked,
+            run: () => this.beginRenameChat(element)
+        }) : action;
         const actions = Separator.join(...menu.getActions({
             arg: element,
             shouldForwardArgs: true
-        }).map(([, groupActions]) => groupActions));
+        }).map(([, groupActions]) => groupActions.map(wrapAction)));
         if (actions.length === 0) {
             menu.dispose();
             return;
@@ -3186,7 +4970,9 @@ let SessionsList = class SessionsList extends Disposable {
     }
     getGroupSessionActions(selected) {
         const actions = [];
-        if (( selected.some(session => session.isArchived.get()))) {
+        if (( selected.some(
+            session => session.isArchived.get() || this.isActiveComparisonSession(session)
+        ))) {
             return actions;
         }
         actions.push(this.getCreateGroupAction(selected));
@@ -3201,13 +4987,13 @@ let SessionsList = class SessionsList extends Disposable {
                 label: g.name,
                 run: () => this.addSessionsToGroup(selected, g.id)
             }));
-            const label = currentGroupId !== undefined ? ( localize(4941, "Move to Group")) : ( localize(4942, "Add to Group"));
+            const label = currentGroupId !== undefined ? ( localize(6185, "Move to Group")) : ( localize(6186, "Add to Group"));
             actions.push(( new SubmenuAction("sessions.addToGroupSubmenu", label, subActions)));
         }
         if (currentGroupId !== undefined) {
             actions.push(toAction({
                 id: "sessions.removeFromGroup",
-                label: ( localize(4943, "Remove from Group")),
+                label: ( localize(6187, "Remove from Group")),
                 run: () => {
                     for (const session of selected) {
                         this._sessionGroupsService.removeFromGroup(session.sessionId);
@@ -3217,10 +5003,14 @@ let SessionsList = class SessionsList extends Disposable {
         }
         return actions;
     }
+    isActiveComparisonSession(session) {
+        const comparison = this.sessionComparisonService.getComparisonForSession(session.resource);
+        return comparison !== undefined && comparison.archivedAt === undefined;
+    }
     getCreateGroupAction(sessions) {
         return toAction({
             id: "sessions.createGroup",
-            label: ( localize(4944, "Create Group")),
+            label: ( localize(6188, "Create Group")),
             run: () => {
                 if (sessions) {
                     this.createGroupFromSessions(sessions);
@@ -3236,16 +5026,77 @@ let SessionsList = class SessionsList extends Disposable {
             getAnchor: () => anchor
         });
     }
-    showGroupContextMenu(groupItem, anchor) {
-        const actions = [this.getCreateGroupAction(), ( new Separator()), toAction({
-            id: "sessions.renameGroupAction",
-            label: ( localize(4945, "Rename...")),
-            run: () => this.beginRenameGroup(groupItem.group.id)
-        }), toAction({
+    getMarkAllSessionsReadAction(getSessions) {
+        return toAction({
+            id: "sessionsViewPane.markAllInSectionRead",
+            label: ( localize(6189, "Mark All as Read")),
+            run: () => {
+                const sessions = getSessions().filter(
+                    session => !isAutomationSession(session) && !session.isArchived.get() && !session.isRead.get()
+                );
+                return this._sessionsManagementService.markAllRead(sessions);
+            }
+        });
+    }
+    showSectionContextMenu(section, anchor) {
+        const actions = [];
+        if (section.id === EXTERNAL_SESSIONS_SECTION_ID) {
+            const contextKeyService = this.contextKeyService.createOverlay([[SessionSectionTypeContext.key, EXTERNAL_SESSIONS_SECTION_ID]]);
+            actions.push(...getFlatContextMenuActions(
+                this.menuService.getMenuActions(SessionSectionToolbarMenuId, contextKeyService, {
+                    arg: section,
+                    shouldForwardArgs: true
+                })
+            ), ( new Separator()));
+        }
+        if (this.options.grouping() === SessionsGrouping.Workspace && section.id.startsWith("workspace:")) {
+            actions.push(this.getMarkAllSessionsReadAction(
+                () => this.sessions.filter(session => sessionWorkspaceLabel(session) === section.label)
+            ), ( new Separator()));
+        }
+        actions.push(this.getCreateGroupAction());
+        this.contextMenuService.showContextMenu({
+            getActions: () => actions,
+            getAnchor: () => anchor
+        });
+    }
+    getDeleteGroupAction(groupItem) {
+        return toAction({
             id: "sessions.deleteGroupAction",
-            label: ( localize(4946, "Delete Group")),
+            label: ( localize(6190, "Delete Group")),
             run: () => this._sessionGroupsService.deleteGroup(groupItem.group.id)
-        })];
+        });
+    }
+    showGroupContextMenu(groupItem, anchor) {
+        const actions = [];
+        const comparison = groupItem.comparison;
+        if (this.options.grouping() === SessionsGrouping.Workspace && !groupItem.isEmpty) {
+            actions.push(this.getMarkAllSessionsReadAction(() => {
+                const sessionIds = ( new Set(this._sessionGroupsService.getSessionIdsInGroup(groupItem.group.id)));
+                return this.sessions.filter(session => ( sessionIds.has(session.sessionId)));
+            }), ( new Separator()));
+        }
+        actions.push(this.getCreateGroupAction());
+        if (!comparison) {
+            actions.push(( new Separator()), toAction({
+                id: "sessions.renameGroupAction",
+                label: ( localize(6191, "Rename...")),
+                run: () => this.beginRenameGroup(groupItem.group.id)
+            }), this.getDeleteGroupAction(groupItem));
+        } else {
+            if (this.sessionComparisonService.canRetryJudge(comparison.id)) {
+                actions.push(( new Separator()), toAction({
+                    id: "sessions.retryComparisonJudge",
+                    label: ( localize(6192, "Retry Judge")),
+                    run: () => this.sessionComparisonService.retryJudge(comparison.id)
+                }));
+            }
+            const comparisonRecord = this.sessionComparisonService.getComparison(comparison.id);
+            const comparisonSessions = comparisonRecord ? getComparisonSessions(comparisonRecord, this._sessionsManagementService) : [];
+            if (comparisonRecord?.launching !== true && !( comparisonSessions.some(session => isSessionActive(session, undefined)))) {
+                actions.push(( new Separator()), this.getDeleteGroupAction(groupItem));
+            }
+        }
         this.contextMenuService.showContextMenu({
             getActions: () => actions,
             getAnchor: () => anchor
@@ -3282,89 +5133,46 @@ let SessionsList = class SessionsList extends Disposable {
     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);
+    isComparisonGroup(groupId) {
+        return ( this.sessionComparisonService.comparisons.get().some(comparison => comparison.groupId === groupId));
     }
-    setSessionTypeExcluded(sessionTypeId, excluded) {
-        if (excluded) {
-            this.excludedSessionTypes.add(sessionTypeId);
-        } else {
-            this.excludedSessionTypes.delete(sessionTypeId);
+    shouldShowComparisonAttemptStatus(session, reader) {
+        const comparison = this.sessionComparisonService.getComparisonForSession(session.resource);
+        if (!comparison) {
+            return false;
         }
-        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 {}
+        if (getSessionRowStatus(session, reader, false) === SessionStatus.InProgress) {
+            return true;
         }
-        return ( new Set());
+        const statuses = comparison.participants.filter(
+            participant => participant.role === SessionComparisonParticipantRole.Attempt
+        ).map(participant => {
+            if (participant.launchError) {
+                return SessionStatus.Error;
+            }
+            const attemptSession = participant.sessionResource ? this.sessions.find(candidate => isEqual(candidate.resource, participant.sessionResource)) : undefined;
+            return attemptSession?.status.read(reader);
+        });
+        return statuses.includes(SessionStatus.Error) || ( new Set(statuses)).size > 1;
     }
-    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
-            );
-        }
+    get groupExternalSessions() {
+        return this.configurationService.getValue(SESSIONS_LIST_GROUP_EXTERNAL_SESSIONS_SETTING) === true;
     }
-    setStatusExcluded(status, excluded) {
-        if (excluded) {
-            this.excludedStatuses.add(status);
-        } else {
-            this.excludedStatuses.delete(status);
-        }
-        this.saveExcludedStatuses();
-        this.update();
+    isRenderedInExternalSection(session) {
+        return this.groupExternalSessions && session.isExternal?.get() === true && !session.isArchived.get() && !this.isSessionPinned(session) && !this.isRenderedInCustomGroup(session);
     }
-    isStatusExcluded(status) {
-        return ( this.excludedStatuses.has(status));
+    _someProviderSupportsQuickChats() {
+        return ( this._sessionsProvidersService.getProviders().some(p => !!p.supportsQuickChats));
     }
-    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());
+    markRead(session) {
+        this._sessionsManagementService.markRead(session);
     }
-    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
-            );
-        }
+    markUnread(session) {
+        this._sessionsManagementService.markUnread(session);
     }
     setExcludeArchived(exclude) {
         this._excludeArchived = exclude;
+        this._excludeArchivedIsDefault = false;
         this.storageService.store(
             SessionsList_1.EXCLUDE_ARCHIVED_KEY,
             exclude,
@@ -3376,38 +5184,20 @@ let SessionsList = class SessionsList extends Disposable {
     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;
+    reportArchivedFilterShown() {
+        if (this._excludeArchivedIsDefault) {
+            logSettingExperimentTrigger(this.telemetryService, SESSIONS_LIST_SHOW_ARCHIVED_BY_DEFAULT_SETTING);
+        }
     }
     resetFilters() {
-        this.excludedSessionTypes.clear();
-        this.saveExcludedSessionTypes();
-        this.excludedStatuses.clear();
-        this.saveExcludedStatuses();
         this._excludeArchived = true;
+        this._excludeArchivedIsDefault = false;
         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,
@@ -3417,7 +5207,7 @@ let SessionsList = class SessionsList extends Disposable {
         );
         this.expandedSessionGroups.clear();
         this.expandedMoreFolders = false;
-        this.update();
+        this.filters.reset();
     }
     setWorkspaceGroupCapped(capped) {
         this.workspaceGroupCapped = capped;
@@ -3453,7 +5243,7 @@ let SessionsList = class SessionsList extends Disposable {
         }
         this.saveBulkCollapseState(true);
     }
-    getSavedCollapseState(sectionId) {
+    getSavedCollapseState(sectionId, legacySectionId) {
         const raw = this.storageService.get(SessionsList_1.SECTION_COLLAPSE_STATE_KEY, StorageScope.PROFILE);
         if (raw) {
             try {
@@ -3461,6 +5251,18 @@ let SessionsList = class SessionsList extends Disposable {
                 if (typeof state[sectionId] === "boolean") {
                     return state[sectionId];
                 }
+                if (legacySectionId && typeof state[legacySectionId] === "boolean") {
+                    const collapsed = state[legacySectionId];
+                    delete state[legacySectionId];
+                    state[sectionId] = collapsed;
+                    this.storageService.store(
+                        SessionsList_1.SECTION_COLLAPSE_STATE_KEY,
+                        JSON.stringify(state),
+                        StorageScope.PROFILE,
+                        StorageTarget.USER
+                    );
+                    return collapsed;
+                }
             } catch {}
         }
         return undefined;
@@ -3486,11 +5288,15 @@ let SessionsList = class SessionsList extends Disposable {
     }
     saveBulkCollapseState(collapsed) {
         const state = {};
-        for (const child of this.tree.getNode(null).children) {
-            if (child.element && isSessionSection(child.element)) {
-                state[child.element.id] = collapsed;
+        const collectSections = node => {
+            if (node.element && isSessionSection(node.element) && !isShortcutSection(node.element.id)) {
+                state[node.element.collapseStateId ?? node.element.id] = collapsed;
             }
-        }
+            for (const child of node.children) {
+                collectSections(child);
+            }
+        };
+        collectSections(this.tree.getNode(null));
         this.storageService.store(
             SessionsList_1.SECTION_COLLAPSE_STATE_KEY,
             JSON.stringify(state),
@@ -3498,8 +5304,40 @@ let SessionsList = class SessionsList extends Disposable {
             StorageTarget.USER
         );
     }
+    loadCollapsedSessionResources() {
+        const raw = this.storageService.get(SessionsList_1.SESSION_COLLAPSE_STATE_KEY, StorageScope.PROFILE);
+        if (raw) {
+            try {
+                const resources = JSON.parse(raw);
+                if (Array.isArray(resources)) {
+                    return ( new Set(resources.filter(resource => typeof resource === "string")));
+                }
+            } catch {}
+        }
+        return ( new Set());
+    }
+    saveSessionCollapseState(session, collapsed) {
+        const resource = ( session.resource.toString());
+        const changed = collapsed ? !( this.collapsedSessionResources.has(resource)) : this.collapsedSessionResources.delete(resource);
+        if (!changed) {
+            return;
+        }
+        if (collapsed) {
+            this.collapsedSessionResources.add(resource);
+        }
+        if (this.collapsedSessionResources.size === 0) {
+            this.storageService.remove(SessionsList_1.SESSION_COLLAPSE_STATE_KEY, StorageScope.PROFILE);
+        } else {
+            this.storageService.store(
+                SessionsList_1.SESSION_COLLAPSE_STATE_KEY,
+                JSON.stringify([...this.collapsedSessionResources]),
+                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));
+SessionsList = SessionsList_1 = ( __decorate([( __param(2, ISessionsManagementService)), ( __param(3, ISessionsService)), ( __param(4, ICustomViewService)), ( __param(5, ISessionsListModelService)), ( __param(6, ISessionGroupsService)), ( __param(7, ISessionComparisonService)), ( __param(8, ISessionSectionOrderService)), ( __param(9, IAgentHostFilterService)), ( __param(10, IInstantiationService)), ( __param(11, IContextKeyService)), ( __param(12, IStorageService)), ( __param(13, IContextMenuService)), ( __param(14, IContextViewService)), ( __param(15, IMenuService)), ( __param(16, IKeybindingService)), ( __param(17, ICommandService)), ( __param(18, IAutomationService)), ( __param(19, IVoicePlaybackService)), ( __param(20, IWorkbenchAssignmentService)), ( __param(21, IConfigurationService)), ( __param(22, IUriIdentityService)), ( __param(23, IAgentHostConnectionsService)), ( __param(24, IOpenerService)), ( __param(25, ILabelService)), ( __param(26, IPreferencesService)), ( __param(27, IEditorService)), ( __param(28, ITelemetryService)), ( __param(29, IAccessibilityService))], SessionsList));
 function getFirstApprovalAcrossChats(approvalModel, session, reader) {
     let oldest;
     for (const chat of session.chats.read(reader)) {
@@ -3537,6 +5375,94 @@ function sortSessions(sessions, sorting, getSortKey) {
     const key = getSortKey ?? defaultSortKey;
     return [...sessions].sort((a, b) => key(b, sorting) - key(a, sorting));
 }
+function sortSessionListChats(chats, sorting) {
+    if (sorting === SessionsSorting.Created) {
+        return chats;
+    }
+    return [...chats].sort(
+        (a, b) => (b.updatedAt.get()?.getTime() ?? b.createdAt.getTime()) - (a.updatedAt.get()?.getTime() ?? a.createdAt.getTime())
+    );
+}
+function sortComparisonGroupMembers(comparison, sessions, sorting, getSortKey) {
+    const participants = getSessionComparisonParticipantsInDisplayOrder(comparison.participants);
+    const participantOrder = session => participants.findIndex(
+        participant => participant.sessionResource && isEqual(participant.sessionResource, session.resource)
+    );
+    return sortSessions(sessions, sorting, getSortKey).sort((a, b) => {
+        const aIndex = participantOrder(a);
+        const bIndex = participantOrder(b);
+        if (aIndex < 0) {
+            return bIndex < 0 ? 0 : 1;
+        }
+        if (bIndex < 0) {
+            return -1;
+        }
+        return aIndex - bIndex;
+    });
+}
+function isComparisonLaunchPending(comparison) {
+    return comparison.launching === true;
+}
+function getComparisonGroupSummary(comparison, sessions, reader) {
+    if (comparison.launching) {
+        const attempts = comparison.participants.filter(
+            participant => participant.role === SessionComparisonParticipantRole.Attempt
+        );
+        const readyAttemptCount = attempts.filter(participant => participant.sessionResource && ( sessions.some(session => isEqual(session.resource, participant.sessionResource)))).length;
+        return readyAttemptCount === 0 ? ( localize(6193, "Comparison · Starting {0} attempts", attempts.length)) : ( localize(
+            6194,
+            "Comparison · Starting attempts · {0} of {1} ready",
+            readyAttemptCount,
+            attempts.length
+        ));
+    }
+    if (comparison.verdict) {
+        return localize(6195, "Comparison · Review ready");
+    }
+    const judge = comparison.participants.find(participant => participant.role === SessionComparisonParticipantRole.Judge);
+    const attempts = comparison.participants.filter(
+        participant => participant.role === SessionComparisonParticipantRole.Attempt
+    );
+    const statuses = attempts.map(participant => {
+        if (participant.launchError) {
+            return SessionStatus.Error;
+        }
+        return participant.sessionResource ? reader ? sessions.find(session => isEqual(session.resource, participant.sessionResource))?.status.read(reader) : sessions.find(session => isEqual(session.resource, participant.sessionResource))?.status.get() : undefined;
+    });
+    const needsInput = statuses.filter(status => status === SessionStatus.NeedsInput).length;
+    const working = statuses.filter(status => status === SessionStatus.InProgress).length;
+    const finished = statuses.filter(
+        status => status === SessionStatus.Completed || status === SessionStatus.Error
+    ).length;
+    if (needsInput > 0) {
+        return needsInput === 1 ? ( localize(6196, "Comparison · 1 attempt needs attention")) : ( localize(6197, "Comparison · {0} attempts need attention", needsInput));
+    }
+    if (working > 0) {
+        return working === 1 ? ( localize(6198, "Comparison · 1 attempt working")) : ( localize(6199, "Comparison · {0} attempts working", working));
+    }
+    if (judge?.launchError) {
+        return localize(6200, "Comparison · Review failed");
+    }
+    if (judge?.sessionResource) {
+        const judgeStatus = reader ? sessions.find(session => isEqual(session.resource, judge.sessionResource))?.status.read(reader) : sessions.find(session => isEqual(session.resource, judge.sessionResource))?.status.get();
+        if (judgeStatus === SessionStatus.NeedsInput) {
+            return localize(6201, "Comparison · Judge needs attention");
+        }
+        if (judgeStatus === SessionStatus.Untitled || judgeStatus === SessionStatus.InProgress) {
+            return localize(6202, "Comparison · Reviewing attempts");
+        }
+        if (judgeStatus === SessionStatus.Error) {
+            return localize(6200, "Comparison · Review failed");
+        }
+        if (judgeStatus === SessionStatus.Completed) {
+            return localize(6203, "Comparison · Review incomplete");
+        }
+    }
+    if (finished === attempts.length) {
+        return localize(6204, "Comparison · {0} attempts finished", attempts.length);
+    }
+    return localize(6205, "Comparison · {0} attempts", attempts.length);
+}
 function limitSessionsForList(sessions, limit, options) {
     if (!options.enabled || sessions.length <= limit) {
         return {
@@ -3638,7 +5564,8 @@ function groupSessionsForList(
     sorting,
     isSessionPinned,
     getSortKey,
-    archivedSectionLabel = getChatSessionArchivedSectionLabel(ChatSessionArchiveActionWording.MarkAsDone)
+    archivedSectionLabel = getChatSessionArchivedSectionLabel(ChatSessionArchiveActionWording.MarkAsDone),
+    groupExternalSessions = false
 ) {
     const sorted = sortSessions(
         sessions.filter(session => !isAutomationSession(session)),
@@ -3647,6 +5574,7 @@ function groupSessionsForList(
     );
     const pinned = [];
     const archived = [];
+    const external = [];
     const quickChats = [];
     const regular = [];
     for (const session of sorted) {
@@ -3654,6 +5582,8 @@ function groupSessionsForList(
             archived.push(session);
         } else if (isSessionPinned(session)) {
             pinned.push(session);
+        } else if (groupExternalSessions && session.isExternal?.get()) {
+            external.push(session);
         } else if (isQuickChatSession(session)) {
             quickChats.push(session);
         } else {
@@ -3664,20 +5594,27 @@ function groupSessionsForList(
     if (pinned.length > 0) {
         sections.push({
             id: "pinned",
-            label: ( localize(4947, "Pinned")),
+            label: ( localize(6206, "Pinned")),
             sessions: pinned
         });
     }
     if (quickChats.length > 0) {
         sections.push({
             id: QUICK_CHATS_SECTION_ID,
-            label: ( localize(4934, "Chats")),
+            label: ( localize(6176, "Chats")),
             sessions: quickChats
         });
     }
     sections.push(
         ...(grouping === SessionsGrouping.Workspace ? groupByWorkspace(regular) : groupByDate(regular, sorting, getSortKey))
     );
+    if (external.length > 0) {
+        sections.push({
+            id: EXTERNAL_SESSIONS_SECTION_ID,
+            label: ( localize(6207, "External")),
+            sessions: external
+        });
+    }
     if (archived.length > 0) {
         sections.push({
             id: "archived",
@@ -3688,7 +5625,7 @@ function groupSessionsForList(
     return sections;
 }
 function sessionWorkspaceLabel(session) {
-    return session.workspace.get()?.label || ( localize(4948, "Unknown"));
+    return session.workspace.get()?.label || ( localize(6208, "Unknown"));
 }
 function groupByWorkspace(sessions) {
     const groups = ( new Map());
@@ -3701,10 +5638,11 @@ function groupByWorkspace(sessions) {
         }
         group.push(session);
     }
-    const unknownWorkspaceLabel = ( localize(4948, "Unknown"));
+    const unknownWorkspaceLabel = ( localize(6208, "Unknown"));
     const order = [...( groups.keys())].filter(k => k !== unknownWorkspaceLabel).sort((a, b) => a.localeCompare(b));
     const result = order.map(label => ({
         id: `workspace:${label}`,
+        collapseStateId: workspaceCollapseStateId(groups.get(label)),
         label,
         sessions: groups.get(label)
     }));
@@ -3718,6 +5656,10 @@ function groupByWorkspace(sessions) {
     }
     return result;
 }
+function workspaceCollapseStateId(sessions) {
+    const resource = sessions[0]?.workspace.get()?.uri.toString();
+    return resource && sessions.every(session => session.workspace.get()?.uri.toString() === resource) ? `workspace:${resource}` : undefined;
+}
 const RECENT_SESSIONS_LIMIT = 10;
 const RECENT_SESSIONS_LIMIT_WITH_UPDATES = 15;
 const RECENTLY_UPDATED_SESSION_THRESHOLD_MS = 24 * 60 * 60 * 1000;
@@ -3750,8 +5692,8 @@ function groupByDate(sessions, sorting, getSortKey) {
             });
         }
     };
-    addGroup("recent", ( localize(4949, "Recent")), recent);
-    addGroup("older", ( localize(4950, "Older")), older);
+    addGroup("recent", ( localize(6209, "Recent")), recent);
+    addGroup("older", ( localize(6210, "Older")), older);
     return sections;
 }
 let SessionsFlatList = class SessionsFlatList extends Disposable {
@@ -3780,7 +5722,8 @@ let SessionsFlatList = class SessionsFlatList extends Disposable {
         agentHostConnectionsService,
         openerService,
         labelService,
-        preferencesService
+        preferencesService,
+        telemetryService
     ) {
         super();
         this.options = options;
@@ -3800,6 +5743,26 @@ let SessionsFlatList = class SessionsFlatList extends Disposable {
         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 externalApplicationBadgeMode = observableConfigValue(
+            SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SETTING,
+            ExternalSessionApplicationBadgeMode.Off,
+            configurationService
+        );
+        const externalApplicationBadgeShowFrom = observableConfigValue(
+            SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SHOW_FROM_SETTING,
+            true,
+            configurationService
+        );
+        const reportExternalApplicationBadgeModeExperimentTrigger = () => logDefaultSettingExperimentTrigger(
+            configurationService,
+            telemetryService,
+            SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SETTING
+        );
+        const reportExternalApplicationBadgeShowFromExperimentTrigger = () => logDefaultSettingExperimentTrigger(
+            configurationService,
+            telemetryService,
+            SESSIONS_LIST_EXTERNAL_APPLICATION_BADGE_SHOW_FROM_SETTING
+        );
         const sessionRenderer = ( new SessionItemRenderer({
             grouping: () => SessionsGrouping.Date,
             isPinned: s => this._sessionsListModelService.isSessionPinned(s),
@@ -3807,14 +5770,23 @@ let SessionsFlatList = class SessionsFlatList extends Disposable {
             getMultiSelectedSessions: s => [s],
             showHover: this.options.showSessionHover ?? true,
             useCompactQuickChatRows,
+            compact: () => false,
             approvalRowMaxLines: this.options.approvalRowMaxLines ?? DEFAULT_APPROVAL_ROW_MAX_LINES,
             aggregateChatApprovals: true,
-            toolbarMenuId: this.options.toolbarMenuId ?? SessionItemToolbarMenuId,
-            handleToolbarAction: this.options.onToolbarAction
+            toolbarMenuId: this.options.toolbarMenuId ?? Menus.SessionItemToolbar,
+            toolbarTelemetrySource: this.options.toolbarTelemetrySource ?? "sessionsFlatList.row",
+            inlineRename: false,
+            handleToolbarAction: this.options.onToolbarAction,
+            externalApplicationBadgeMode,
+            externalApplicationBadgeShowFrom,
+            reportExternalApplicationBadgeModeExperimentTrigger,
+            reportExternalApplicationBadgeShowFromExperimentTrigger
         }, approvalModel, this.options.ciFixModel, instantiationService, contextKeyService, configurationService, markdownRendererService, hoverService, sessionsProvidersService, this._sessionsManagementService, agentHostConnectionsService, openerService, labelService, preferencesService, agentSessionsService, voicePlaybackService));
         this._delegate = ( new SessionsTreeDelegate(
             approvalModel,
             () => false,
+            () => false,
+            session => session.status.get(),
             this.options.approvalRowMaxLines ?? DEFAULT_APPROVAL_ROW_MAX_LINES,
             this.options.ciFixModel,
             useCompactQuickChatRows,
@@ -3830,7 +5802,10 @@ let SessionsFlatList = class SessionsFlatList extends Disposable {
                 accessibilityProvider: ( new SessionsAccessibilityProvider(undefined, {
                     grouping: () => SessionsGrouping.Date,
                     isPinned: session => this._sessionsListModelService.isSessionPinned(session),
-                    includeQuickChatInAriaLabel: !useCompactQuickChatRows
+                    includeQuickChatInAriaLabel: !useCompactQuickChatRows,
+                    externalApplicationBadgeMode,
+                    reportExternalApplicationBadgeModeExperimentTrigger,
+                    reportExternalApplicationBadgeShowFromExperimentTrigger
                 })),
                 identityProvider: {
                     getId: element => ( element.resource.toString())
@@ -3849,7 +5824,7 @@ let SessionsFlatList = class SessionsFlatList extends Disposable {
             if (!element || !isSessionItem(element)) {
                 return;
             }
-            if (this.options.markSessionReadOnOpen !== false) {
+            if (this.options.markSessionReadOnOpen !== false && this._sessionsService.activeSession.get()?.sessionId !== element.sessionId) {
                 this._sessionsManagementService.markRead(element);
             }
             const isLeftClick = isMouseEvent(e.browserEvent) && e.browserEvent.button === 0;
@@ -3877,9 +5852,13 @@ let SessionsFlatList = class SessionsFlatList extends Disposable {
         const disposables = ( new DisposableStore());
         const contextKeyService = this.contextKeyService.createOverlay([
             [SessionIsArchivedContext.key, session.isArchived.get()],
-            [SessionIsReadContext.key, session.isRead.get()],
+            [SessionIsReadContext.key, session.mainChat.get().isRead.get()],
             [SessionTypeContext.key, session.sessionType],
             [SessionProviderIdContext.key, session.providerId],
+            [
+                SessionSupportsMultipleChatsContext.key,
+                session.capabilities.get().supportsMultipleChats
+            ],
             [
                 SessionSupportsRenameContext.key,
                 session.capabilities.get().supportsRename ?? false
@@ -3888,6 +5867,7 @@ let SessionsFlatList = class SessionsFlatList extends Disposable {
                 SessionSupportsDeleteContext.key,
                 session.capabilities.get().supportsDelete ?? false
             ],
+            [IsQuickChatSessionContext.key, session.isQuickChat?.get() ?? false],
             [SessionItemStatusContext.key, session.status.get()]
         ]);
         const menu = disposables.add(this.menuService.createMenu(this.options.contextMenuId, contextKeyService));
@@ -3933,7 +5913,11 @@ let SessionsFlatList = class SessionsFlatList extends Disposable {
         this.tree.setFocus([session]);
         this.tree.domFocus();
     }
+    getFocusedSession() {
+        const focused = this.tree.getFocus()[0];
+        return focused && isSessionItem(focused) ? focused : undefined;
+    }
 };
-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));
+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)), ( __param(19, ITelemetryService))], 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 };
+export { IsSessionPinnedContext, NEW_SESSION_FOR_WORKSPACE_ACTION_ID, QUICK_CHATS_SECTION_ID, SESSIONS_LIST_SHOW_ARCHIVED_BY_DEFAULT_SETTING, SESSIONS_LIST_SHOW_EMPTY_DEFAULT_GROUPS_SETTING, SESSIONS_LIST_SHOW_UNREAD_IN_COLLAPSED_SECTIONS_SETTING, SessionChatItem, SessionChatItemCanArchiveContext, SessionChatItemCanDeleteContext, SessionChatItemCanRenameContext, SessionChatItemIsArchivedContext, SessionChatItemIsUntitledContext, SessionGroupHasVisibleSessionsContext, SessionGroupIsComparisonContext, SessionGroupIsEmptyContext, SessionGroupToolbarMenuId, SessionItemCanImportContext, SessionItemContextMenuId, SessionItemInExternalSectionContext, SessionItemInGroupContext, SessionItemStatusContext, SessionSectionHasGitHubRepositoryContext, SessionSectionHasNonCloudRepositoryContext, SessionSectionRenderer, SessionSectionToolbarMenuId, SessionSectionTypeContext, SessionsFlatList, SessionsGrouping, SessionsList, SessionsListFocusedChatItemContext, SessionsSorting, computeReorderSortChanges, formatSessionListTime, getFirstApprovalAcrossChats, getSessionArchiveOnboardingTargetId, getSessionOnboardingTargetId, groupByDate, groupByWorkspace, groupSessionsForList, isAutomationSession, isQuickChatSession, limitSessionsForList, sortSessions };