@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.1

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

@@ -0,0 +1,1270 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { KeyMod, KeyCode, KeyChord } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isWeb, isMobile } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
+import { registerAction2, Action2, MenuRegistry, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IsDevelopmentContext } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkeys';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { KeybindingsRegistry, KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { WorkbenchListFocusContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { CLOSE_MOBILE_SIDEBAR_DRAWER_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/workbench';
+import { EditorsVisibleContext, IsSessionsWindowContext, EditorAreaFocusContext, FocusedViewContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { SessionsCategories } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/categories';
+import { ARCHIVE_SESSION_COMMAND_ID, UNARCHIVE_SESSION_COMMAND_ID, RENAME_SESSION_COMMAND_ID, MARK_SESSION_READ_COMMAND_ID, MARK_SESSION_UNREAD_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionCommands';
+import { IsNewChatSessionContext, SessionIsArchivedContext, SessionIsCreatedContext, SessionSupportsRenameContext, SessionSupportsDeleteContext, SessionIsReadContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { SessionsSorting, SessionsGrouping, SessionSectionToolbarMenuId, SessionSectionHasNonCloudRepositoryContext, SessionSectionTypeContext, NEW_SESSION_FOR_WORKSPACE_ACTION_ID, SessionGroupHasVisibleSessionsContext, SessionGroupToolbarMenuId, SessionGroupIsEmptyContext, SessionItemToolbarMenuId, SessionItemContextMenuId, IsSessionPinnedContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionGroupsService.service';
+import { SessionsViewId, SessionsViewFilterSubMenu, SessionsViewFilterOptionsSubMenu, SessionsViewSortingContext, SessionsViewGroupingContext, IsWorkspaceGroupCappedContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsView';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ChatSessionArchiveActionWording, getChatSessionArchiveActionPresentation, ChatSessionArchiveActionWordingSettingId, getChatSessionArchiveActionWording } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/sessionArchiveActions';
+import { AGENT_HOST_ENABLED_CONTEXT_KEY } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService';
+import { ISessionsPartService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { registerExternalSessionsFilterMenu } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/externalSessionsFilterMenu';
+import { ICustomViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/customView/browser/customViewService.service';
+import { IAutomationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService.service';
+import { ChatAutomationsEnabledContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationsEnabled';
+import { AUTOMATIONS_CUSTOM_VIEW_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/automationsConstants';
+import { UNIFIED_WORKSPACE_PICKER_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/common/constants';
+import { INewSessionComposerService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newSessionComposerService.service';
+import { WorkspaceSelectionOrigin } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/workspaceSelection';
+
+const CLOSE_SESSION_COMMAND_ID = "sessionsViewPane.closeSession";
+registerAction2(class CloseSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: CLOSE_SESSION_COMMAND_ID,
+            title: ( localize2(4847, "Close Session")),
+            f1: true,
+            precondition: ( ContextKeyExpr.and(( IsNewChatSessionContext.negate()), ( EditorsVisibleContext.negate()))),
+            category: SessionsCategories.Sessions
+        });
+    }
+    async run(accessor) {
+        accessor.get(INewSessionComposerService).notifyUserNavigation();
+        const sessionsService = accessor.get(ISessionsService);
+        sessionsService.openNewSession();
+    }
+});
+KeybindingsRegistry.registerKeybindingRule({
+    id: CLOSE_SESSION_COMMAND_ID,
+    weight: KeybindingWeight.SessionsContrib,
+    when: ( ContextKeyExpr.and(( IsNewChatSessionContext.negate()), ( EditorsVisibleContext.negate()))),
+    primary: KeyMod.CtrlCmd | KeyCode.KeyW,
+    win: {
+        primary: KeyMod.CtrlCmd | KeyCode.F4,
+        secondary: [KeyMod.CtrlCmd | KeyCode.KeyW]
+    }
+});
+const OPEN_SESSION_AT_INDEX_COMMAND_ID = "sessionsViewPane.openSessionAtIndex";
+function digitToKeyCode(digit) {
+    switch (digit) {
+    case 1:
+        return KeyCode.Digit1;
+    case 2:
+        return KeyCode.Digit2;
+    case 3:
+        return KeyCode.Digit3;
+    case 4:
+        return KeyCode.Digit4;
+    case 5:
+        return KeyCode.Digit5;
+    case 6:
+        return KeyCode.Digit6;
+    case 7:
+        return KeyCode.Digit7;
+    case 8:
+        return KeyCode.Digit8;
+    case 9:
+        return KeyCode.Digit9;
+    default:
+        return KeyCode.Unknown;
+    }
+}
+const openSessionAtIndex = async (accessor, sessionIndex) => {
+    if (typeof sessionIndex !== "number") {
+        return;
+    }
+    const viewsService = accessor.get(IViewsService);
+    const sessionsService = accessor.get(ISessionsService);
+    const view = viewsService.getViewWithId(SessionsViewId);
+    const visible = view?.sessionsControl?.getVisibleSessions() ?? [];
+    if (visible.length === 0) {
+        return;
+    }
+    const target = sessionIndex === -1 ? visible[visible.length - 1] : visible[sessionIndex];
+    if (!target) {
+        return;
+    }
+    if (await sessionsService.canOpenSession(target)) {
+        await sessionsService.openChat(target, target.mainChat.get().resource, {
+            source: "sessionsList"
+        });
+    }
+};
+CommandsRegistry.registerCommand({
+    id: OPEN_SESSION_AT_INDEX_COMMAND_ID,
+    handler: openSessionAtIndex
+});
+for (let visibleIndex = 1; visibleIndex <= 9; visibleIndex++) {
+    const sessionIndex = visibleIndex === 9 ? -1 : visibleIndex - 1;
+    KeybindingsRegistry.registerCommandAndKeybindingRule({
+        id: OPEN_SESSION_AT_INDEX_COMMAND_ID + visibleIndex,
+        weight: KeybindingWeight.SessionsContrib,
+        when: IsSessionsWindowContext,
+        primary: KeyMod.Alt | digitToKeyCode(visibleIndex),
+        mac: {
+            primary: KeyMod.WinCtrl | digitToKeyCode(visibleIndex)
+        },
+        handler: accessor => openSessionAtIndex(accessor, sessionIndex)
+    });
+}
+const navigateSessionInList = async (accessor, direction) => {
+    const viewsService = accessor.get(IViewsService);
+    const sessionsService = accessor.get(ISessionsService);
+    const view = viewsService.getViewWithId(SessionsViewId);
+    const visible = view?.sessionsControl?.getVisibleSessions() ?? [];
+    if (visible.length === 0) {
+        return;
+    }
+    const activeResource = sessionsService.activeSession.get()?.resource.toString();
+    const currentIndex = activeResource === undefined ? -1 : visible.findIndex(session => ( session.resource.toString()) === activeResource);
+    let targetIndex;
+    if (currentIndex === -1) {
+        targetIndex = direction === "next" ? 0 : visible.length - 1;
+    } else {
+        targetIndex = direction === "next" ? Math.min(currentIndex + 1, visible.length - 1) : Math.max(currentIndex - 1, 0);
+    }
+    if (targetIndex === currentIndex) {
+        return;
+    }
+    const target = visible[targetIndex];
+    if (target) {
+        if (await sessionsService.canOpenSession(target)) {
+            await sessionsService.openChat(target, target.mainChat.get().resource, {
+                source: "navigation"
+            });
+        }
+    }
+};
+registerAction2(class NavigatePreviousSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.navigatePreviousSession",
+            title: {
+                value: ( localize(4848, "Go to Previous Session")),
+                original: "Go to Previous Session",
+                mnemonicTitle: ( localize(4849, "&&Previous Session"))
+            },
+            f1: true,
+            category: SessionsCategories.Sessions,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated()))),
+                primary: KeyMod.CtrlCmd | KeyCode.PageUp,
+                secondary: [KeyMod.Alt | KeyCode.UpArrow],
+                mac: {
+                    primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.LeftArrow,
+                    secondary: [KeyMod.Alt | KeyCode.UpArrow]
+                }
+            },
+            menu: [{
+                id: Menus.GoMenu,
+                group: "2_list_nav",
+                order: 1
+            }]
+        });
+    }
+    run(accessor) {
+        return navigateSessionInList(accessor, "previous");
+    }
+});
+registerAction2(class NavigateNextSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.navigateNextSession",
+            title: {
+                value: ( localize(4850, "Go to Next Session")),
+                original: "Go to Next Session",
+                mnemonicTitle: ( localize(4851, "&&Next Session"))
+            },
+            f1: true,
+            category: SessionsCategories.Sessions,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated()))),
+                primary: KeyMod.CtrlCmd | KeyCode.PageDown,
+                secondary: [KeyMod.Alt | KeyCode.DownArrow],
+                mac: {
+                    primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.RightArrow,
+                    secondary: [KeyMod.Alt | KeyCode.DownArrow]
+                }
+            },
+            menu: [{
+                id: Menus.GoMenu,
+                group: "2_list_nav",
+                order: 2
+            }]
+        });
+    }
+    run(accessor) {
+        return navigateSessionInList(accessor, "next");
+    }
+});
+MenuRegistry.appendMenuItem(Menus.SidebarSessionsHeader, {
+    submenu: SessionsViewFilterSubMenu,
+    title: ( localize2(4852, "Filter Sessions")),
+    icon: Codicon.settings,
+    group: "navigation",
+    order: 10
+});
+MenuRegistry.appendMenuItem(Menus.SidebarSessionsHeader, {
+    command: {
+        id: "sessionsViewPane.find",
+        title: ( localize2(4853, "Find Session")),
+        icon: Codicon.search
+    },
+    group: "navigation",
+    order: 20
+});
+MenuRegistry.appendMenuItem(SessionsViewFilterSubMenu, {
+    submenu: SessionsViewFilterOptionsSubMenu,
+    title: ( localize2(4854, "Filter")),
+    group: "0_filter",
+    order: 0
+});
+registerExternalSessionsFilterMenu(
+    SessionsViewFilterOptionsSubMenu,
+    Menus.SessionsViewExternalFilter,
+    "2_external"
+);
+registerAction2(class SortByCreatedAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.sortByCreated",
+            title: ( localize2(4855, "Sort by Created")),
+            category: SessionsCategories.Sessions,
+            toggled: ( ContextKeyExpr.equals(SessionsViewSortingContext.key, SessionsSorting.Created)),
+            menu: [{
+                id: SessionsViewFilterSubMenu,
+                group: "1_sort",
+                order: 0
+            }]
+        });
+    }
+    run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = viewsService.getViewWithId(SessionsViewId);
+        view?.setSorting(SessionsSorting.Created);
+    }
+});
+registerAction2(class SortByUpdatedAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.sortByUpdated",
+            title: ( localize2(4856, "Sort by Updated")),
+            category: SessionsCategories.Sessions,
+            toggled: ( ContextKeyExpr.equals(SessionsViewSortingContext.key, SessionsSorting.Updated)),
+            menu: [{
+                id: SessionsViewFilterSubMenu,
+                group: "1_sort",
+                order: 1
+            }]
+        });
+    }
+    run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = viewsService.getViewWithId(SessionsViewId);
+        view?.setSorting(SessionsSorting.Updated);
+    }
+});
+registerAction2(class GroupByWorkspaceAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.groupByWorkspace",
+            title: ( localize2(4857, "Group by Workspace")),
+            category: SessionsCategories.Sessions,
+            toggled: ( ContextKeyExpr.equals(SessionsViewGroupingContext.key, SessionsGrouping.Workspace)),
+            menu: [{
+                id: SessionsViewFilterSubMenu,
+                group: "2_group",
+                order: 0
+            }]
+        });
+    }
+    run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = viewsService.getViewWithId(SessionsViewId);
+        view?.setGrouping(SessionsGrouping.Workspace);
+    }
+});
+registerAction2(class GroupByTimeAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.groupByTime",
+            title: ( localize2(4858, "Group by Time")),
+            category: SessionsCategories.Sessions,
+            toggled: ( ContextKeyExpr.equals(SessionsViewGroupingContext.key, SessionsGrouping.Date)),
+            menu: [{
+                id: SessionsViewFilterSubMenu,
+                group: "2_group",
+                order: 1
+            }]
+        });
+    }
+    run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = viewsService.getViewWithId(SessionsViewId);
+        view?.setGrouping(SessionsGrouping.Date);
+    }
+});
+registerAction2(class ShowRecentWorkspaceSessionsAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.showRecentSessions",
+            title: ( localize2(4859, "Show Recent Sessions")),
+            category: SessionsCategories.Sessions,
+            toggled: IsWorkspaceGroupCappedContext,
+            menu: [{
+                id: SessionsViewFilterSubMenu,
+                group: "3_cap",
+                order: 0,
+                when: ( ContextKeyExpr.equals(SessionsViewGroupingContext.key, SessionsGrouping.Workspace))
+            }]
+        });
+    }
+    run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = viewsService.getViewWithId(SessionsViewId);
+        view?.sessionsControl?.setWorkspaceGroupCapped(true);
+        IsWorkspaceGroupCappedContext.bindTo(accessor.get(IContextKeyService)).set(true);
+    }
+});
+registerAction2(class ShowAllWorkspaceSessionsAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.showAllSessions",
+            title: ( localize2(4860, "Show All Sessions")),
+            category: SessionsCategories.Sessions,
+            toggled: ( IsWorkspaceGroupCappedContext.negate()),
+            menu: [{
+                id: SessionsViewFilterSubMenu,
+                group: "3_cap",
+                order: 1,
+                when: ( ContextKeyExpr.equals(SessionsViewGroupingContext.key, SessionsGrouping.Workspace))
+            }]
+        });
+    }
+    run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = viewsService.getViewWithId(SessionsViewId);
+        view?.sessionsControl?.setWorkspaceGroupCapped(false);
+        IsWorkspaceGroupCappedContext.bindTo(accessor.get(IContextKeyService)).set(false);
+    }
+});
+registerAction2(class CollapseAllGroupsAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.collapseAllGroups",
+            title: ( localize2(4861, "Collapse All Groups")),
+            category: SessionsCategories.Sessions,
+            menu: [{
+                id: SessionsViewFilterSubMenu,
+                group: "4_collapse",
+                order: 0
+            }]
+        });
+    }
+    run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = viewsService.getViewWithId(SessionsViewId);
+        view?.sessionsControl?.collapseAllSections();
+    }
+});
+registerAction2(class RefreshSessionsAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.refresh",
+            title: ( localize2(4862, "Refresh Sessions")),
+            icon: Codicon.refresh,
+            f1: true,
+            category: SessionsCategories.Sessions
+        });
+    }
+    run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = viewsService.getViewWithId(SessionsViewId);
+        return view?.sessionsControl?.refresh();
+    }
+});
+registerAction2(class FindSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.find",
+            title: ( localize2(4853, "Find Session")),
+            icon: Codicon.search,
+            category: SessionsCategories.Sessions
+        });
+    }
+    run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = viewsService.getViewWithId(SessionsViewId);
+        return view?.openFind();
+    }
+});
+registerAction2(class NewSessionForWorkspaceAction extends Action2 {
+    constructor() {
+        super({
+            id: NEW_SESSION_FOR_WORKSPACE_ACTION_ID,
+            title: ( localize2(4863, "New Session")),
+            icon: Codicon.plus,
+            menu: [{
+                id: SessionSectionToolbarMenuId,
+                group: "navigation",
+                order: 0,
+                when: ( ContextKeyExpr.and(
+                    ChatContextKeys.enabled,
+                    SessionSectionHasNonCloudRepositoryContext,
+                    ( ContextKeyExpr.equals(SessionSectionTypeContext.key, "workspace"))
+                ))
+            }, {
+                id: SessionSectionToolbarMenuId,
+                group: "navigation",
+                order: 0,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals(SessionSectionTypeContext.key, "workspace")), ( ContextKeyExpr.or(( ChatContextKeys.enabled.negate()), ( SessionSectionHasNonCloudRepositoryContext.negate())))))
+            }]
+        });
+    }
+    async run(accessor, context) {
+        if (!context || !context.sessions || context.sessions.length === 0) {
+            return;
+        }
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsPartService = accessor.get(ISessionsPartService);
+        const commandService = accessor.get(ICommandService);
+        accessor.get(INewSessionComposerService).notifyUserWorkspaceSelection();
+        await sessionsService.openNewSession();
+        const session = context.sessions[0];
+        const workspace = session.workspace.get();
+        const folderUri = workspace?.folders[0]?.root;
+        const providerId = session.providerId;
+        const newSession = sessionsService.activeSession.get();
+        if (folderUri) {
+            sessionsPartService.getSessionView(newSession?.sessionId)?.selectWorkspace(folderUri, {
+                providerId,
+                selectionOrigin: WorkspaceSelectionOrigin.User
+            });
+        }
+        if (isWeb && isMobile) {
+            commandService.executeCommand(CLOSE_MOBILE_SIDEBAR_DRAWER_COMMAND_ID);
+        }
+        sessionsPartService.focusSession(newSession);
+    }
+});
+const NEW_QUICK_CHAT_COMMAND_ID = "sessionsView.newQuickChat";
+const QuickChatEnabledContext = ( ContextKeyExpr.and(ChatContextKeys.enabled, AGENT_HOST_ENABLED_CONTEXT_KEY));
+registerAction2(class NewQuickChatAction extends Action2 {
+    constructor() {
+        super({
+            id: NEW_QUICK_CHAT_COMMAND_ID,
+            title: ( localize2(4864, "New Quick Chat")),
+            icon: Codicon.add,
+            category: SessionsCategories.Sessions,
+            f1: true,
+            precondition: QuickChatEnabledContext,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.KeyN),
+                when: ( ContextKeyExpr.and(QuickChatEnabledContext, IsSessionsWindowContext, ( EditorAreaFocusContext.negate())))
+            },
+            menu: [{
+                id: SessionSectionToolbarMenuId,
+                group: "navigation",
+                order: 0,
+                when: ( ContextKeyExpr.and(QuickChatEnabledContext, ( ContextKeyExpr.equals(SessionSectionTypeContext.key, "quickchats"))))
+            }]
+        });
+    }
+    run(accessor) {
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsPartService = accessor.get(ISessionsPartService);
+        const composerService = accessor.get(INewSessionComposerService);
+        composerService.notifyUserNavigation();
+        let activeSession;
+        if (accessor.get(IConfigurationService).getValue(UNIFIED_WORKSPACE_PICKER_SETTING)) {
+            if (accessor.get(ISessionsManagementService).isQuickChatTargetAvailable()) {
+                sessionsService.unsetNewSession();
+                sessionsPartService.getSessionView(undefined)?.selectNoWorkspace();
+            }
+            activeSession = sessionsService.activeSession.get();
+        } else {
+            composerService.notifyUserWorkspaceSelection();
+            activeSession = sessionsService.openQuickChat();
+        }
+        if (isWeb && isMobile) {
+            accessor.get(ICommandService).executeCommand(CLOSE_MOBILE_SIDEBAR_DRAWER_COMMAND_ID);
+        }
+        sessionsPartService.focusSession(activeSession);
+    }
+});
+const ConfirmArchiveStorageKey = "sessions.confirmArchive";
+function getArchiveSectionConfirmationMessage(context, wording) {
+    if (context.id === "pinned") {
+        if (context.sessions.length === 1) {
+            return wording === ChatSessionArchiveActionWording.MarkAsDone ? ( localize(4865, "Are you sure you want to mark 1 pinned session as done?")) : ( localize(4866, "Are you sure you want to archive 1 pinned session?"));
+        }
+        return wording === ChatSessionArchiveActionWording.MarkAsDone ? ( localize(
+            4867,
+            "Are you sure you want to mark {0} pinned sessions as done?",
+            context.sessions.length
+        )) : ( localize(
+            4868,
+            "Are you sure you want to archive {0} pinned sessions?",
+            context.sessions.length
+        ));
+    }
+    if (context.sessions.length === 1) {
+        return wording === ChatSessionArchiveActionWording.MarkAsDone ? ( localize(
+            4869,
+            "Are you sure you want to mark 1 session from '{0}' as done?",
+            context.label
+        )) : ( localize(
+            4870,
+            "Are you sure you want to archive 1 session from '{0}'?",
+            context.label
+        ));
+    }
+    return wording === ChatSessionArchiveActionWording.MarkAsDone ? ( localize(
+        4871,
+        "Are you sure you want to mark {0} sessions from '{1}' as done?",
+        context.sessions.length,
+        context.label
+    )) : ( localize(
+        4872,
+        "Are you sure you want to archive {0} sessions from '{1}'?",
+        context.sessions.length,
+        context.label
+    ));
+}
+class BaseArchiveSectionAction extends Action2 {
+    constructor(wording) {
+        const action = getChatSessionArchiveActionPresentation(wording).archiveAll;
+        super({
+            id: "sessionsView.sectionArchive",
+            title: action.title,
+            icon: action.icon,
+            menu: [{
+                id: SessionSectionToolbarMenuId,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.notEquals(SessionSectionTypeContext.key, "archived")), ( ContextKeyExpr.notEquals(SessionSectionTypeContext.key, "quickchats")), ( ContextKeyExpr.notEquals(SessionSectionTypeContext.key, "automations"))))
+            }]
+        });
+        this.wording = wording;
+    }
+    async run(accessor, context) {
+        if (!context || !context.sessions || context.sessions.length === 0) {
+            return;
+        }
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const dialogService = accessor.get(IDialogService);
+        const storageService = accessor.get(IStorageService);
+        const skipConfirmation = storageService.getBoolean(ConfirmArchiveStorageKey, StorageScope.PROFILE, false);
+        if (!skipConfirmation) {
+            const confirmed = await dialogService.confirm({
+                message: getArchiveSectionConfirmationMessage(context, this.wording),
+                detail: this.wording === ChatSessionArchiveActionWording.MarkAsDone ? ( localize(4873, "You can restore sessions later if needed from the sessions view.")) : ( localize(4874, "You can unarchive sessions later if needed from the sessions view.")),
+                primaryButton: getChatSessionArchiveActionPresentation(this.wording).archiveAll.title.value,
+                checkbox: {
+                    label: ( localize(4875, "Do not ask me again"))
+                }
+            });
+            if (!confirmed.confirmed) {
+                return;
+            }
+            if (confirmed.checkboxChecked) {
+                storageService.store(ConfirmArchiveStorageKey, true, StorageScope.PROFILE, StorageTarget.USER);
+            }
+        }
+        for (const session of context.sessions) {
+            await sessionsManagementService.archiveSession(session);
+        }
+    }
+}
+class ArchiveSectionAction extends BaseArchiveSectionAction {
+    constructor() {
+        super(ChatSessionArchiveActionWording.Archive);
+    }
+}
+class MarkSectionSessionsDoneAction extends BaseArchiveSectionAction {
+    constructor() {
+        super(ChatSessionArchiveActionWording.MarkAsDone);
+    }
+}
+function getArchiveGroupConfirmationMessage(context, wording) {
+    if (context.sessions.length === 1) {
+        return wording === ChatSessionArchiveActionWording.MarkAsDone ? ( localize(
+            4876,
+            "Are you sure you want to mark 1 session from '{0}' as done?",
+            context.group.name
+        )) : ( localize(
+            4877,
+            "Are you sure you want to archive 1 session from '{0}'?",
+            context.group.name
+        ));
+    }
+    return wording === ChatSessionArchiveActionWording.MarkAsDone ? ( localize(
+        4878,
+        "Are you sure you want to mark {0} sessions from '{1}' as done?",
+        context.sessions.length,
+        context.group.name
+    )) : ( localize(
+        4879,
+        "Are you sure you want to archive {0} sessions from '{1}'?",
+        context.sessions.length,
+        context.group.name
+    ));
+}
+class BaseArchiveSessionsInGroupAction extends Action2 {
+    constructor(wording) {
+        const action = getChatSessionArchiveActionPresentation(wording).archiveAll;
+        super({
+            id: "sessionsView.markAllInGroupAsDone",
+            title: action.title,
+            icon: action.icon,
+            menu: [{
+                id: SessionGroupToolbarMenuId,
+                group: "navigation",
+                order: 2,
+                when: SessionGroupHasVisibleSessionsContext
+            }]
+        });
+        this.wording = wording;
+    }
+    async run(accessor, context) {
+        if (!context || !context.sessions || context.sessions.length === 0) {
+            return;
+        }
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const dialogService = accessor.get(IDialogService);
+        const storageService = accessor.get(IStorageService);
+        const skipConfirmation = storageService.getBoolean(ConfirmArchiveStorageKey, StorageScope.PROFILE, false);
+        if (!skipConfirmation) {
+            const confirmed = await dialogService.confirm({
+                message: getArchiveGroupConfirmationMessage(context, this.wording),
+                detail: this.wording === ChatSessionArchiveActionWording.MarkAsDone ? ( localize(4880, "You can restore sessions later if needed from the sessions view.")) : ( localize(4881, "You can unarchive sessions later if needed from the sessions view.")),
+                primaryButton: getChatSessionArchiveActionPresentation(this.wording).archiveAll.title.value,
+                checkbox: {
+                    label: ( localize(4875, "Do not ask me again"))
+                }
+            });
+            if (!confirmed.confirmed) {
+                return;
+            }
+            if (confirmed.checkboxChecked) {
+                storageService.store(ConfirmArchiveStorageKey, true, StorageScope.PROFILE, StorageTarget.USER);
+            }
+        }
+        for (const session of context.sessions) {
+            await sessionsManagementService.archiveSession(session);
+        }
+    }
+}
+class ArchiveSessionsInGroupAction extends BaseArchiveSessionsInGroupAction {
+    constructor() {
+        super(ChatSessionArchiveActionWording.Archive);
+    }
+}
+class MarkAllSessionsInGroupAsDoneAction extends BaseArchiveSessionsInGroupAction {
+    constructor() {
+        super(ChatSessionArchiveActionWording.MarkAsDone);
+    }
+}
+registerAction2(class DeleteEmptySessionGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsView.deleteEmptyGroup",
+            title: ( localize2(4882, "Delete Group")),
+            icon: Codicon.trash,
+            menu: [{
+                id: SessionGroupToolbarMenuId,
+                group: "navigation",
+                order: 2,
+                when: SessionGroupIsEmptyContext
+            }]
+        });
+    }
+    run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        const sessionGroupsService = accessor.get(ISessionGroupsService);
+        if (sessionGroupsService.getSessionIdsInGroup(context.group.id).length === 0) {
+            sessionGroupsService.deleteGroup(context.group.id);
+        }
+    }
+});
+registerAction2(class NewSessionInGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsView.newSessionInGroup",
+            title: ( localize2(4883, "New Session")),
+            icon: Codicon.plus,
+            menu: [{
+                id: SessionGroupToolbarMenuId,
+                group: "navigation",
+                order: 1
+            }]
+        });
+    }
+    run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsPartService = accessor.get(ISessionsPartService);
+        const sessionGroupsService = accessor.get(ISessionGroupsService);
+        const commandService = accessor.get(ICommandService);
+        accessor.get(INewSessionComposerService).notifyUserNavigation();
+        sessionsService.openNewSession();
+        sessionGroupsService.setPendingNewSessionGroup(context.group.id);
+        if (isWeb && isMobile) {
+            commandService.executeCommand(CLOSE_MOBILE_SIDEBAR_DRAWER_COMMAND_ID);
+        }
+        sessionsPartService.focusSession(sessionsService.activeSession.get());
+    }
+});
+registerAction2(class PinSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.pinSession",
+            title: ( localize2(4884, "Pin")),
+            icon: Codicon.pin,
+            menu: [{
+                id: SessionItemToolbarMenuId,
+                group: "navigation",
+                order: 2,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals(IsSessionPinnedContext.key, false)), ( ContextKeyExpr.equals(SessionIsArchivedContext.key, false))))
+            }, {
+                id: SessionItemContextMenuId,
+                group: "0_pin",
+                order: 0,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals(IsSessionPinnedContext.key, false)), ( ContextKeyExpr.equals(SessionIsArchivedContext.key, false))))
+            }]
+        });
+    }
+    run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        const sessions = Array.isArray(context) ? context : [context];
+        const viewsService = accessor.get(IViewsService);
+        const view = viewsService.getViewWithId(SessionsViewId);
+        for (const session of sessions) {
+            view?.sessionsControl?.pinSession(session);
+        }
+    }
+});
+registerAction2(class UnpinSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.unpinSession",
+            title: ( localize2(4885, "Unpin")),
+            icon: Codicon.pinned,
+            menu: [{
+                id: SessionItemToolbarMenuId,
+                group: "navigation",
+                order: 2,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals(IsSessionPinnedContext.key, true)), ( ContextKeyExpr.equals(SessionIsArchivedContext.key, false))))
+            }, {
+                id: SessionItemContextMenuId,
+                group: "0_pin",
+                order: 0,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals(IsSessionPinnedContext.key, true)), ( ContextKeyExpr.equals(SessionIsArchivedContext.key, false))))
+            }]
+        });
+    }
+    run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        const sessions = Array.isArray(context) ? context : [context];
+        const viewsService = accessor.get(IViewsService);
+        const view = viewsService.getViewWithId(SessionsViewId);
+        for (const session of sessions) {
+            view?.sessionsControl?.unpinSession(session);
+        }
+    }
+});
+function getSessionActionTargets(accessor, context) {
+    if (context) {
+        return Array.isArray(context) ? context : [context];
+    }
+    const focusedSessions = getFocusedSessionListTargets(accessor);
+    if (focusedSessions) {
+        return focusedSessions;
+    }
+    const activeSession = accessor.get(ISessionsService).activeSession.get();
+    return activeSession ? [activeSession] : [];
+}
+function getFocusedSessionListTargets(accessor) {
+    return accessor.get(IViewsService).getViewWithId(SessionsViewId)?.sessionsControl?.getFocusedSessions();
+}
+KeybindingsRegistry.registerKeybindingRule({
+    id: ARCHIVE_SESSION_COMMAND_ID,
+    weight: KeybindingWeight.SessionsContrib,
+    when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( FocusedViewContext.isEqualTo(SessionsViewId)), WorkbenchListFocusContextKey)),
+    primary: KeyCode.Delete,
+    mac: {
+        primary: KeyMod.CtrlCmd | KeyCode.Backspace
+    }
+});
+class BaseArchiveSessionAction extends Action2 {
+    constructor(wording) {
+        const action = getChatSessionArchiveActionPresentation(wording).archive;
+        super({
+            id: ARCHIVE_SESSION_COMMAND_ID,
+            title: action.title,
+            icon: action.icon,
+            menu: [{
+                id: SessionItemToolbarMenuId,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.equals(SessionIsArchivedContext.key, false))
+            }, {
+                id: Menus.AutomationsHistoryItem,
+                group: "navigation",
+                order: 2,
+                when: ( ContextKeyExpr.equals(SessionIsArchivedContext.key, false))
+            }, {
+                id: SessionItemContextMenuId,
+                group: "1_edit",
+                order: 2,
+                when: ( ContextKeyExpr.equals(SessionIsArchivedContext.key, false))
+            }, {
+                id: Menus.SessionBarToolbar,
+                group: "secondary/1_session",
+                order: 30,
+                when: ( ContextKeyExpr.and(SessionIsCreatedContext, ( ContextKeyExpr.equals(SessionIsArchivedContext.key, false))))
+            }]
+        });
+    }
+    async run(accessor, context) {
+        const targets = context ? (Array.isArray(context) ? context : [context]) : getFocusedSessionListTargets(accessor) ?? [];
+        const sessions = targets.filter(session => !session.isArchived.get());
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        for (const session of sessions) {
+            await sessionsManagementService.archiveSession(session);
+        }
+    }
+}
+class ArchiveSessionAction extends BaseArchiveSessionAction {
+    constructor() {
+        super(ChatSessionArchiveActionWording.Archive);
+    }
+}
+class MarkSessionAsDoneAction extends BaseArchiveSessionAction {
+    constructor() {
+        super(ChatSessionArchiveActionWording.MarkAsDone);
+    }
+}
+class BaseUnarchiveSessionAction extends Action2 {
+    constructor(wording) {
+        const action = getChatSessionArchiveActionPresentation(wording).unarchive;
+        super({
+            id: UNARCHIVE_SESSION_COMMAND_ID,
+            title: action.title,
+            icon: action.icon,
+            menu: [{
+                id: SessionItemToolbarMenuId,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.equals(SessionIsArchivedContext.key, true))
+            }, {
+                id: SessionItemContextMenuId,
+                group: "1_edit",
+                order: 2,
+                when: ( ContextKeyExpr.equals(SessionIsArchivedContext.key, true))
+            }, {
+                id: Menus.SessionBarToolbar,
+                group: "secondary/1_session",
+                order: 5,
+                when: ( ContextKeyExpr.equals(SessionIsArchivedContext.key, true))
+            }]
+        });
+    }
+    async run(accessor, context) {
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const sessionsService = accessor.get(ISessionsService);
+        if (!context) {
+            const activeSession = sessionsService.activeSession.get();
+            if (activeSession) {
+                await sessionsManagementService.unarchiveSession(activeSession);
+            }
+            return;
+        }
+        const sessions = Array.isArray(context) ? context : [context];
+        for (const session of sessions) {
+            await sessionsManagementService.unarchiveSession(session);
+        }
+    }
+}
+class UnarchiveSessionAction extends BaseUnarchiveSessionAction {
+    constructor() {
+        super(ChatSessionArchiveActionWording.Archive);
+    }
+}
+class RestoreArchivedSessionAction extends BaseUnarchiveSessionAction {
+    constructor() {
+        super(ChatSessionArchiveActionWording.MarkAsDone);
+    }
+}
+registerAction2(class RenameSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: RENAME_SESSION_COMMAND_ID,
+            title: ( localize2(4886, "Rename...")),
+            icon: Codicon.edit,
+            keybinding: {
+                primary: KeyCode.F2,
+                weight: KeybindingWeight.SessionsContrib,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( ContextKeyExpr.or(( ContextKeyExpr.and(( FocusedViewContext.isEqualTo(SessionsViewId)), WorkbenchListFocusContextKey)), ( ContextKeyExpr.and(ChatContextKeys.inChatSession, SessionSupportsRenameContext))))))
+            },
+            menu: [{
+                id: SessionItemContextMenuId,
+                group: "1_edit",
+                order: 1,
+                when: SessionSupportsRenameContext
+            }]
+        });
+    }
+    async run(accessor, context) {
+        const session = getSessionActionTargets(accessor, context)[0];
+        if (!session || !session.capabilities.get().supportsRename) {
+            return;
+        }
+        const quickInputService = accessor.get(IQuickInputService);
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const newTitle = await quickInputService.input({
+            value: session.title.get(),
+            prompt: ( localize(4887, "New agent session title")),
+            validateInput: async value => {
+                if (!value.trim()) {
+                    return localize(4888, "Title cannot be empty");
+                }
+                return undefined;
+            }
+        });
+        if (newTitle) {
+            const trimmedTitle = newTitle.trim();
+            if (trimmedTitle && trimmedTitle !== session.title.get().trim()) {
+                await sessionsManagementService.renameSession(session, trimmedTitle);
+            }
+        }
+    }
+});
+registerAction2(class DeleteSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.deleteSession",
+            title: ( localize2(4889, "Delete...")),
+            menu: [{
+                id: SessionItemContextMenuId,
+                group: "1_edit",
+                order: 4,
+                when: SessionSupportsDeleteContext
+            }]
+        });
+    }
+    async run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        const sessions = (Array.isArray(context) ? context : [context]).filter(session => session.capabilities.get().supportsDelete);
+        if (sessions.length === 0) {
+            return;
+        }
+        const dialogService = accessor.get(IDialogService);
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const confirmed = await dialogService.confirm({
+            message: sessions.length === 1 ? ( localize(4890, "Are you sure you want to delete this session?")) : ( localize(4891, "Are you sure you want to delete {0} sessions?", sessions.length)),
+            detail: ( localize(4892, "This action cannot be undone.")),
+            primaryButton: ( localize(4893, "Delete"))
+        });
+        if (!confirmed.confirmed) {
+            return;
+        }
+        try {
+            await sessionsManagementService.deleteSessions(sessions);
+        } catch (err) {
+            dialogService.error(sessions.length === 1 ? ( localize(4894, "Failed to delete the session: {0}", toErrorMessage(err))) : ( localize(4895, "Failed to delete the sessions: {0}", toErrorMessage(err))));
+        }
+    }
+});
+registerAction2(class MarkSessionReadAction extends Action2 {
+    constructor() {
+        super({
+            id: MARK_SESSION_READ_COMMAND_ID,
+            title: ( localize2(4896, "Mark as Read")),
+            menu: [{
+                id: SessionItemContextMenuId,
+                group: "0_read",
+                order: 0,
+                when: ( ContextKeyExpr.and(( SessionIsReadContext.negate()), ( SessionIsArchivedContext.negate())))
+            }, {
+                id: Menus.SessionHeaderContext,
+                group: "3_read",
+                order: 0,
+                when: ( ContextKeyExpr.and(( SessionIsReadContext.negate()), ( SessionIsArchivedContext.negate())))
+            }]
+        });
+    }
+    run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        const sessions = Array.isArray(context) ? context : [context];
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        sessionsManagementService.markAllRead(sessions);
+    }
+});
+registerAction2(class MarkSessionUnreadAction extends Action2 {
+    constructor() {
+        super({
+            id: MARK_SESSION_UNREAD_COMMAND_ID,
+            title: ( localize2(4897, "Mark as Unread")),
+            menu: [{
+                id: SessionItemContextMenuId,
+                group: "0_read",
+                order: 0,
+                when: ( ContextKeyExpr.and(SessionIsReadContext, ( SessionIsArchivedContext.negate())))
+            }, {
+                id: Menus.SessionHeaderContext,
+                group: "3_read",
+                order: 0,
+                when: ( ContextKeyExpr.and(SessionIsReadContext, ( SessionIsArchivedContext.negate())))
+            }]
+        });
+    }
+    run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        const sessions = Array.isArray(context) ? context : [context];
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        for (const session of sessions) {
+            sessionsManagementService.markUnread(session);
+        }
+    }
+});
+registerAction2(class OpenSessionToTheSideAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.openToTheSide",
+            title: ( localize2(4898, "Open to the Side")),
+            menu: [{
+                id: SessionItemContextMenuId,
+                group: "navigation",
+                order: -1,
+                when: IsSessionsWindowContext
+            }]
+        });
+    }
+    async run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        const sessions = Array.isArray(context) ? context : [context];
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsPartService = accessor.get(ISessionsPartService);
+        for (let i = 0; i < sessions.length - 1; i++) {
+            const session = sessions[i];
+            const visible = sessionsService.visibleSessions.get();
+            const lastVisible = visible[visible.length - 1];
+            if (lastVisible && lastVisible.sessionId !== session.sessionId) {
+                sessionsService.insertAt(session, lastVisible.sessionId, "right");
+            }
+        }
+        const lastRequested = sessions[sessions.length - 1];
+        await sessionsService.openSessionToSide(lastRequested, {
+            source: "sessionsList"
+        });
+        const visibleAfterOpen = sessionsService.visibleSessions.get();
+        const opened = visibleAfterOpen.find(s => s?.sessionId === lastRequested.sessionId);
+        if (opened) {
+            sessionsPartService.focusSession(opened);
+        }
+    }
+});
+registerAction2(class MarkAllSessionsReadAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.markAllRead",
+            title: ( localize2(4899, "Mark All as Read")),
+            menu: [{
+                id: SessionItemContextMenuId,
+                group: "0_read",
+                order: 1
+            }]
+        });
+    }
+    run(accessor) {
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const sessions = sessionsManagementService.getSessions().filter(s => !s.isArchived.get() && !s.isRead.get());
+        sessionsManagementService.markAllRead(sessions);
+    }
+});
+class BaseUnarchiveActiveSessionAction extends Action2 {
+    constructor(wording) {
+        const action = getChatSessionArchiveActionPresentation(wording).unarchive;
+        super({
+            id: "agentSession.restore",
+            title: action.title,
+            icon: action.icon,
+            menu: [{
+                id: MenuId.AgentsChangesToolbar,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, SessionIsArchivedContext))
+            }]
+        });
+    }
+    async run(accessor) {
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const sessionsService = accessor.get(ISessionsService);
+        const activeSession = sessionsService.activeSession.get();
+        if (!activeSession || activeSession.status.get() === SessionStatus.Untitled) {
+            return;
+        }
+        await sessionsManagementService.unarchiveSession(activeSession);
+    }
+}
+class UnarchiveActiveSessionAction extends BaseUnarchiveActiveSessionAction {
+    constructor() {
+        super(ChatSessionArchiveActionWording.Archive);
+    }
+}
+class RestoreActiveSessionAction extends BaseUnarchiveActiveSessionAction {
+    constructor() {
+        super(ChatSessionArchiveActionWording.MarkAsDone);
+    }
+}
+function getSessionsArchiveActionConstructors(wording) {
+    return wording === ChatSessionArchiveActionWording.MarkAsDone ? [
+        MarkSectionSessionsDoneAction,
+        MarkAllSessionsInGroupAsDoneAction,
+        MarkSessionAsDoneAction,
+        RestoreArchivedSessionAction,
+        RestoreActiveSessionAction
+    ] : [
+        ArchiveSectionAction,
+        ArchiveSessionsInGroupAction,
+        ArchiveSessionAction,
+        UnarchiveSessionAction,
+        UnarchiveActiveSessionAction
+    ];
+}
+let SessionsArchiveActionsContribution = class SessionsArchiveActionsContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessionsArchiveActions";
+    }
+    constructor(configurationService) {
+        super();
+        this.configurationService = configurationService;
+        this.actionRegistrations = this._register(( new DisposableStore()));
+        this.registerActions();
+        this._register(this.configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(ChatSessionArchiveActionWordingSettingId)) {
+                this.registerActions();
+            }
+        }));
+    }
+    registerActions() {
+        this.actionRegistrations.clear();
+        const wording = getChatSessionArchiveActionWording(this.configurationService);
+        for (const action of getSessionsArchiveActionConstructors(wording)) {
+            this.actionRegistrations.add(registerAction2(action));
+        }
+    }
+};
+SessionsArchiveActionsContribution = ( __decorate([( __param(0, IConfigurationService))], SessionsArchiveActionsContribution));
+registerWorkbenchContribution2(
+    SessionsArchiveActionsContribution.ID,
+    SessionsArchiveActionsContribution,
+    WorkbenchPhase.BlockStartup
+);
+registerAction2(class ManageAutomationsAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsView.manageAutomations",
+            title: ( localize2(4900, "Manage Automations")),
+            menu: []
+        });
+    }
+    run(accessor) {
+        accessor.get(ICustomViewService).showCustomView(AUTOMATIONS_CUSTOM_VIEW_ID);
+    }
+});
+registerAction2(class ResetAutomationsNewBadgeAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.developer.resetAutomationsNewBadge",
+            title: ( localize2(4901, "Reset Automations New Badge")),
+            category: Categories.Developer,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(
+                IsDevelopmentContext,
+                IsSessionsWindowContext,
+                ChatAutomationsEnabledContext
+            ))
+        });
+    }
+    async run(accessor) {
+        const view = await accessor.get(IViewsService).openView(SessionsViewId, false);
+        await view?.sessionsControl?.resetAutomationsNewBadge();
+    }
+});
+const MARK_ALL_AUTOMATION_RUNS_READ_COMMAND_ID = "sessionsView.markAllAutomationRunsRead";
+registerAction2(class MarkAllAutomationRunsReadAction extends Action2 {
+    constructor() {
+        super({
+            id: MARK_ALL_AUTOMATION_RUNS_READ_COMMAND_ID,
+            title: ( localize2(4902, "Mark All as Read"))
+        });
+    }
+    async run(accessor) {
+        const automationService = accessor.get(IAutomationService);
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const runs = automationService.runs.get();
+        const sessions = ( new Map());
+        for (const run of runs) {
+            if ((run.status === "completed" || run.status === "failed") && run.sessionResource) {
+                const session = sessionsManagementService.getSession(run.sessionResource);
+                if (session && !session.isRead.get()) {
+                    sessions.set(( session.resource.toString()), session);
+                }
+            }
+        }
+        await sessionsManagementService.markAllRead([...( sessions.values())]);
+    }
+});
+
+export { ArchiveSessionAction };