sessions: hide subagent chats by default, persist closed chats, add chat capabilities (#324021)

sessions: hide subagent chats by default, persist closed chats, and add chat capabilities

Improves chat management in the Agents window session view:

- Subagent (tool-origin) worker chats are hidden from the chat tab strip by
  default and surface as a tab only when explicitly opened (e.g. from the
  Subagents dropdown); closing one hides it again without adding it to the
  reopenable closed set. Reverts on reload.
- Closing a chat is remembered across reload/restart (closed-chat set is
  persisted per session and restored on startup); subagents are excluded from
  the persisted set.
- Adds "Close All Chats" command (Ctrl/Cmd+K W, mirroring "Close All Editors in
  Group"), gated on SessionHasMultipleOpenChats so it targets the focused
  session and does not collide with "Close All Sessions" (Ctrl/Cmd+K Ctrl/Cmd+W).
- Introduces per-chat IChatCapabilities (canRename/canDelete) with a central
  getChatCapabilities resolver that folds in the main-chat invariant (never
  deletable). Subagent chats report neither rename nor delete; the tab context
  menu, delete keybinding, and context keys now go through capabilities instead
  of ad-hoc origin/main-chat checks.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: sandy081

src/vs/sessions/browser/parts/chatCompositeBar.ts

@@ -26,7 +26,7 @@ import { IKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
 import { KeyCode } from '../../../base/common/keyCodes.js';
 import { onUnexpectedError } from '../../../base/common/errors.js';
 import { localize } from '../../../nls.js';
-import { ChatInteractivity, IChat, SessionStatus } from '../../services/sessions/common/session.js';
+import { ChatInteractivity, getChatCapabilities, IChat, SessionStatus } from '../../services/sessions/common/session.js';
 import { IActiveSession, ISessionsManagementService } from '../../services/sessions/common/sessionsManagement.js';
 import { ISessionsService } from '../../services/sessions/browser/sessionsService.js';
 import { ISessionsPartService } from '../../services/sessions/browser/sessionsPartService.js';
@@ -368,7 +368,7 @@ export class ChatCompositeBar extends Disposable {
 
 		// Double-click the tab to start an inline rename, mirroring the session title.
 		this._tabDisposables.add(addDisposableListener(tab, EventType.DBLCLICK, (e: MouseEvent) => {
-			if (chat.status.get() === SessionStatus.Untitled) {
+			if (chat.status.get() === SessionStatus.Untitled || !getChatCapabilities(chat, session, undefined).canRename) {
 				return;
 			}
 			e.preventDefault();
@@ -387,9 +387,17 @@ export class ChatCompositeBar extends Disposable {
 			const event = new StandardMouseEvent(getWindow(tab), e);
 			this._contextMenuService.showContextMenu({
 				getAnchor: () => event,
-				getActions: () => isMainChat
-					? [renameAction]
-					: [renameAction, deleteAction]
+				getActions: () => {
+					const capabilities = getChatCapabilities(chat, session, undefined);
+					const actions = [];
+					if (capabilities.canRename) {
+						actions.push(renameAction);
+					}
+					if (capabilities.canDelete) {
+						actions.push(deleteAction);
+					}
+					return actions;
+				}
 			});
 		}));
 

src/vs/sessions/contrib/providers/agentHost/browser/baseAgentHostSessionsProvider.ts

@@ -44,7 +44,7 @@ import { ILanguageModelChatMetadataAndIdentifier, ILanguageModelsService } from
 import { buildMutableConfigSchema, IAgentHostMcpServer, IAgentHostSessionsProvider, resolvedConfigsEqual } from '../../../../common/agentHostSessionsProvider.js';
 import { agentHostSessionWorkspaceKey } from '../../../../common/agentHostSessionWorkspace.js';
 import { isSessionConfigComplete } from '../../../../common/sessionConfig.js';
-import { ChatInteractivity, ChatOriginKind, IChat, IGitHubInfo, ISession, ISessionAgentRef, ISessionCapabilities, ISessionChangeset, ISessionChangesSummary, ISessionFile, ISessionFileChange, ISessionType, ISessionWorkspace, ISessionWorkspaceBrowseAction, sessionFileChangesEqual, SessionStatus, toSessionId } from '../../../../services/sessions/common/session.js';
+import { ChatInteractivity, ChatOriginKind, DEFAULT_CHAT_CAPABILITIES, IChat, IChatCapabilities, IGitHubInfo, ISession, ISessionAgentRef, ISessionCapabilities, ISessionChangeset, ISessionChangesSummary, ISessionFile, ISessionFileChange, ISessionType, ISessionWorkspace, ISessionWorkspaceBrowseAction, sessionFileChangesEqual, SessionStatus, toSessionId } from '../../../../services/sessions/common/session.js';
 import { ISessionsService } from '../../../../services/sessions/browser/sessionsService.js';
 import { IDeleteChatOptions, ISendRequestOptions, ISessionChangeEvent, ISessionModelPickerOptions } from '../../../../services/sessions/common/sessionsProvider.js';
 import { IGitHubService } from '../../../github/browser/githubService.js';
@@ -264,6 +264,12 @@ class AdditionalChat extends Disposable {
 			description: this._description,
 			lastTurnEnd: this._lastTurnEnd,
 			origin: summary.origin ? { kind: toSessionChatOriginKind(summary.origin.kind), parentChat } : undefined,
+			// Subagent (tool-origin) worker chats are transient children and can be
+			// neither renamed nor deleted; other peer chats are fully manageable.
+			capabilities: constObservable<IChatCapabilities>(
+				summary.origin?.kind === ProtocolChatOriginKind.Tool
+					? { canRename: false, canDelete: false }
+					: DEFAULT_CHAT_CAPABILITIES),
 		};
 	}
 

src/vs/sessions/contrib/providers/agentHost/test/browser/localAgentHostSessionsProvider.test.ts

@@ -35,7 +35,7 @@ import { ChatModeKind } from '../../../../../../workbench/contrib/chat/common/co
 import { ILanguageModelsService, type ILanguageModelChatMetadata } from '../../../../../../workbench/contrib/chat/common/languageModels.js';
 import type { IChatModel, IChatModelInputState, IInputModel } from '../../../../../../workbench/contrib/chat/common/model/chatModel.js';
 import { ISessionChangeEvent } from '../../../../../services/sessions/common/sessionsProvider.js';
-import { ChatInteractivity, ChatOriginKind, ISession, SessionStatus } from '../../../../../services/sessions/common/session.js';
+import { ChatInteractivity, ChatOriginKind, getChatCapabilities, ISession, SessionStatus } from '../../../../../services/sessions/common/session.js';
 import { IActiveSession } from '../../../../../services/sessions/common/sessionsManagement.js';
 import { ISessionsService } from '../../../../../services/sessions/browser/sessionsService.js';
 import { IAgentHostActiveClientService } from '../../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.js';
@@ -2169,11 +2169,38 @@ suite('LocalAgentHostSessionsProvider', () => {
 				// The subagent records its parent chat (the default chat) so the
 				// "Agents" row can list it under the chat that spawned it.
 				subagentParentIsMain: !!chats[1]?.origin?.parentChat && isEqual(chats[1].origin.parentChat, chats[0].resource),
+				// A subagent worker chat is neither renameable nor deletable.
+				subagentCapabilities: getChatCapabilities(chats[1], session, undefined),
 			}, {
 				titles: ['Session', 'Code Reviewer'],
 				interactivity: [ChatInteractivity.Full, ChatInteractivity.ReadOnly],
 				subagentOrigin: ChatOriginKind.Tool,
 				subagentParentIsMain: true,
+				subagentCapabilities: { canRename: false, canDelete: false },
+			});
+		});
+
+		test('the main chat is renameable but never deletable via capabilities', () => {
+			const provider = createProvider(disposables, agentHost);
+			const session = setupMultiChatSession(provider, 'main-caps');
+			const sessionUri = AgentSession.uri('copilotcli', 'main-caps').toString();
+			const defaultChat = buildDefaultChatUri(sessionUri);
+			const peerChat = buildChatUri(sessionUri, 'peer-1');
+
+			agentHost.setSessionState('main-caps', 'copilotcli', makeState([
+				makeChatSummary(defaultChat, ''),
+				{ ...makeChatSummary(peerChat, 'Peer'), origin: { kind: ProtocolChatOriginKind.User } },
+			], { defaultChat }));
+
+			const chats = session.chats.get();
+			assert.deepStrictEqual({
+				// The main (default) chat: renameable, never deletable.
+				main: getChatCapabilities(chats[0], session, undefined),
+				// A regular user peer chat: fully manageable.
+				peer: getChatCapabilities(chats[1], session, undefined),
+			}, {
+				main: { canRename: true, canDelete: false },
+				peer: { canRename: true, canDelete: true },
 			});
 		});
 

src/vs/sessions/contrib/sessions/browser/sessionsActions.ts

@@ -31,7 +31,7 @@ import { CanGoBackContext, CanGoForwardContext, SessionProviderIdContext, Multip
 import { ANY_AGENT_HOST_PROVIDER_RE } from '../../../common/agentHostSessionsProvider.js';
 import { IActiveSession, ISessionsManagementService } from '../../../services/sessions/common/sessionsManagement.js';
 import { ISessionsService } from '../../../services/sessions/browser/sessionsService.js';
-import { ChatOriginKind, getUntitledSessionTitle, IChat, ISession, SessionStatus } from '../../../services/sessions/common/session.js';
+import { ChatOriginKind, getChatCapabilities, getUntitledSessionTitle, IChat, ISession, SessionStatus } from '../../../services/sessions/common/session.js';
 import { ISessionsPartService } from '../../../services/sessions/browser/sessionsPartService.js';
 import { ISessionsListModelService } from '../../../services/sessions/browser/sessionsListModelService.js';
 import { SessionHeaderMetaActionViewItem } from '../../../browser/parts/sessionHeaderMetaActionViewItem.js';
@@ -567,6 +567,55 @@ registerAction2(class CloseChatAction extends Action2 {
 	}
 });
 
+registerAction2(class CloseAllChatsAction extends Action2 {
+	constructor() {
+		super({
+			id: 'sessions.chatCompositeBar.closeAllChats',
+			title: localize2('closeAllChats', "Close All Chats"),
+			f1: true,
+			category: SessionsCategories.Sessions,
+			// Enabled (palette + keybinding) only while the active session has more
+			// than one open chat, so the chord targets the focused session and
+			// stays inert for single-chat sessions.
+			precondition: SessionHasMultipleOpenChatsContext,
+			keybinding: {
+				weight: CHAT_TAB_KEYBINDING_WEIGHT,
+				when: ContextKeyExpr.and(
+					IsSessionsWindowContext,
+					// While a modal editor has focus, let VS Code's own
+					// closeEditorsInGroup (same chord) act on the editor group.
+					EditorAreaFocusContext.toNegated(),
+					SessionHasMultipleOpenChatsContext
+				),
+				// Mirror VS Code's "Close All Editors in Group" chord (Ctrl/Cmd+K W):
+				// a session is the Agents-window analogue of an editor group. Note
+				// "Close All Sessions" already owns Ctrl/Cmd+K Ctrl/Cmd+W.
+				primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyCode.KeyW),
+			},
+		});
+	}
+
+	override async run(accessor: ServicesAccessor): Promise<void> {
+		const sessionsService = accessor.get(ISessionsService);
+		const sessionsManagementService = accessor.get(ISessionsManagementService);
+		const extUri = accessor.get(IUriIdentityService).extUri;
+		const session = sessionsService.activeSession.get();
+		if (!session) {
+			return;
+		}
+
+		const mainResource = session.mainChat.get().resource;
+		const chatsToClose = session.openChats.get().filter(chat => !extUri.isEqual(chat.resource, mainResource));
+		for (const chat of chatsToClose) {
+			if (chat.status.get() === SessionStatus.Untitled) {
+				await sessionsManagementService.deleteChat(session, chat.resource, { skipConfirmation: true });
+			} else {
+				await sessionsService.closeChat(session, chat);
+			}
+		}
+	}
+});
+
 registerAction2(class DeleteChatAction extends Action2 {
 	constructor() {
 		super({
@@ -592,18 +641,13 @@ registerAction2(class DeleteChatAction extends Action2 {
 	override async run(accessor: ServicesAccessor): Promise<void> {
 		const sessionsService = accessor.get(ISessionsService);
 		const sessionsManagementService = accessor.get(ISessionsManagementService);
-		const extUri = accessor.get(IUriIdentityService).extUri;
 		const session = sessionsService.activeSession.get();
 		if (!session) {
 			return;
 		}
 		const chat = session.activeChat.get();
-		if (!chat || extUri.isEqual(chat.resource, session.mainChat.get().resource)) {
-			return;
-		}
-		// Tool-spawned subagent chats are transient children (re-derived from the
-		// parent's tool call), so they are closeable but must not be deleted.
-		if (chat.origin?.kind === ChatOriginKind.Tool) {
+		// The main chat and worker (subagent) chats report `canDelete: false`.
+		if (!chat || !getChatCapabilities(chat, session, undefined).canDelete) {
 			return;
 		}
 		await sessionsManagementService.deleteChat(session, chat.resource);
@@ -950,6 +994,11 @@ export class SessionConversationsMenuContribution extends Disposable implements
 			if (chat.status.read(reader) === SessionStatus.Untitled) {
 				return;
 			}
+			// Subagent (tool-origin) chats are surfaced via the Subagents dropdown,
+			// not the Conversations submenu.
+			if (chat.origin?.kind === ChatOriginKind.Tool) {
+				return;
+			}
 			const chatResource = chat.resource;
 			const isOpen = openChats.some(c => extUri.isEqual(c.resource, chatResource));
 			const isMain = extUri.isEqual(chatResource, mainResource);

src/vs/sessions/services/sessions/browser/sessionsService.ts

@@ -15,7 +15,7 @@ import { InstantiationType, registerSingleton } from '../../../../platform/insta
 import { ILogService } from '../../../../platform/log/common/log.js';
 import { IStorageService, StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
 import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
-import { ChatInteractivity, IChat, ISession, SessionStatus } from '../common/session.js';
+import { ChatInteractivity, ChatOriginKind, IChat, ISession, SessionStatus } from '../common/session.js';
 import { IActiveSession, ICreateNewChatInSessionOptions, ICreateNewSessionOptions, IRecentlyOpenedSessions, ISessionsChangeEvent, ISessionsManagementService, IToggleSessionStickinessEvent } from '../common/sessionsManagement.js';
 import { ISessionsProvidersService } from './sessionsProvidersService.js';
 import { SessionsNavigation } from './sessionNavigation.js';
@@ -626,6 +626,12 @@ export class SessionsService extends Disposable implements ISessionsService {
 		if (this.uriIdentityService.extUri.isEqual(chat.resource, session.mainChat.get().resource)) {
 			return;
 		}
+		// Subagent (tool-origin) chats are hidden by default and toggled via an
+		// in-memory shown set, not the persisted closed set, so they never
+		// participate in closed-chat persistence.
+		if (chat.origin?.kind === ChatOriginKind.Tool) {
+			return;
+		}
 		const existing = this._sessionStates.get(session.resource);
 		const closedSet = new Set(existing?.closedChatResources ?? []);
 		const chatResource = chat.resource.toString();

src/vs/sessions/services/sessions/browser/visibleSessions.ts

@@ -43,6 +43,12 @@ export class VisibleSession extends Disposable implements IActiveSession {
 
 	/** Resource strings of chats that have been closed (hidden from the tab strip). */
 	private readonly _closedChatUris: ISettableObservable<ReadonlySet<string>>;
+	/**
+	 * Resource strings of subagent (tool-origin) chats the user explicitly opened,
+	 * so they surface as tabs. Subagents are hidden from the tab strip by default;
+	 * this set is not persisted, so they revert to hidden on reload.
+	 */
+	private readonly _shownSubagentUris: ISettableObservable<ReadonlySet<string>>;
 	/** Append-only list tracking close order; last element is the most recently closed. */
 	private readonly _closedChatOrder: IChat[] = [];
 	readonly openChats: IObservable<readonly IChat[]>;
@@ -73,6 +79,14 @@ export class VisibleSession extends Disposable implements IActiveSession {
 		}
 		this._closedChatUris = observableValue<ReadonlySet<string>>('closedChatUris', seed);
 
+		// Subagents are hidden by default; if the restored active chat is one,
+		// surface its tab so the session opens where the user left off.
+		const shownSubagents = new Set<string>();
+		if (initialChat?.origin?.kind === ChatOriginKind.Tool) {
+			shownSubagents.add(initialChat.resource.toString());
+		}
+		this._shownSubagentUris = observableValue<ReadonlySet<string>>('shownSubagentUris', shownSubagents);
+
 		this._isCreated = _session.status.map(status => status !== SessionStatus.Untitled);
 		this.isCreated = this._isCreated;
 
@@ -92,15 +106,20 @@ export class VisibleSession extends Disposable implements IActiveSession {
 			}
 			return this._session.chats.read(reader).filter(c => closed.has(c.resource.toString()));
 		});
-		// Tab strip contents: the open chats in the provider's order. Subagent
-		// (tool-origin) chats are surfaced as read-only tabs alongside the rest,
-		// so opening one (e.g. from the Subagents dropdown) shows it as the
-		// active tab. Hidden and closed chats are already excluded by `openChats`.
-		this.visibleChatTabs = this.openChats;
+		// Tab strip contents: the open chats in the provider's order, with subagent
+		// (tool-origin) chats hidden by default. A subagent surfaces as a tab only
+		// once explicitly opened (e.g. from the Subagents dropdown), tracked in
+		// `_shownSubagentUris`. Hidden and closed chats are excluded by `openChats`.
+		this.visibleChatTabs = derived(this, reader => {
+			const shownSubagents = this._shownSubagentUris.read(reader);
+			return this.openChats.read(reader).filter(c =>
+				c.origin?.kind !== ChatOriginKind.Tool ||
+				shownSubagents.has(c.resource.toString()));
+		});
 		// Shown for more than one real (non-tool) chat — counting closed ones —
-		// or a single chat whose title diverged from the session title. Surfaced
-		// subagent (tool-origin) tabs also warrant showing the strip, so any time
-		// there is more than one visible tab the strip is shown.
+		// or a single chat whose title diverged from the session title. An opened
+		// subagent tab also warrants showing the strip, so any time there is more
+		// than one visible tab the strip is shown.
 		this.shouldShowChatTabs = derived(this, reader => {
 			const tabChats = this._session.chats.read(reader).filter(c =>
 				c.origin?.kind !== ChatOriginKind.Tool &&
@@ -128,6 +147,24 @@ export class VisibleSession extends Disposable implements IActiveSession {
 		if (chatUri === this._session.mainChat.get().resource.toString()) {
 			return;
 		}
+		// Closing a subagent (tool-origin) tab just hides it again; it stays
+		// reachable from the Subagents dropdown and is not added to the
+		// reopenable closed set.
+		if (chat.origin?.kind === ChatOriginKind.Tool) {
+			const shown = this._shownSubagentUris.get();
+			if (!shown.has(chatUri)) {
+				return;
+			}
+			const nextShown = new Set(shown);
+			nextShown.delete(chatUri);
+			transaction(tx => {
+				this._shownSubagentUris.set(nextShown, tx);
+				if (this._activeChat.get().resource.toString() === chatUri) {
+					this._activeChat.set(this._defaultActiveChat(this._closedChatUris.get(), nextShown), tx);
+				}
+			});
+			return;
+		}
 		const closed = this._closedChatUris.get();
 		if (closed.has(chatUri)) {
 			return;
@@ -137,18 +174,25 @@ export class VisibleSession extends Disposable implements IActiveSession {
 		this._closedChatOrder.push(chat);
 		transaction(tx => {
 			this._closedChatUris.set(next, tx);
-			// If the closed chat was active, fall back to another open chat.
-			// Skip hidden chats so the active chat is always user-visible.
+			// If the closed chat was active, fall back to another visible tab.
 			if (this._activeChat.get().resource.toString() === chatUri) {
-				const open = this._session.chats.get().filter(c =>
-					c.interactivity.get() !== ChatInteractivity.Hidden &&
-					!next.has(c.resource.toString()));
-				this._activeChat.set(open[open.length - 1] ?? this._session.mainChat.get(), tx);
+				this._activeChat.set(this._defaultActiveChat(next, this._shownSubagentUris.get()), tx);
 			}
 		});
 	}
 
 	openChat(chat: IChat): void {
+		// Opening a subagent (tool-origin) chat surfaces it as a tab.
+		if (chat.origin?.kind === ChatOriginKind.Tool) {
+			const shown = this._shownSubagentUris.get();
+			if (shown.has(chat.resource.toString())) {
+				return;
+			}
+			const next = new Set(shown);
+			next.add(chat.resource.toString());
+			this._shownSubagentUris.set(next, undefined);
+			return;
+		}
 		const closed = this._closedChatUris.get();
 		if (!closed.has(chat.resource.toString())) {
 			return;
@@ -162,6 +206,19 @@ export class VisibleSession extends Disposable implements IActiveSession {
 		}
 	}
 
+	/**
+	 * Pick the active chat to fall back to when the current one is closed: the
+	 * last chat that would appear as a visible tab given the closed and shown-
+	 * subagent sets, or the main chat.
+	 */
+	private _defaultActiveChat(closed: ReadonlySet<string>, shownSubagents: ReadonlySet<string>): IChat {
+		const candidates = this._session.chats.get().filter(c =>
+			c.interactivity.get() !== ChatInteractivity.Hidden &&
+			!closed.has(c.resource.toString()) &&
+			(c.origin?.kind !== ChatOriginKind.Tool || shownSubagents.has(c.resource.toString())));
+		return candidates[candidates.length - 1] ?? this._session.mainChat.get();
+	}
+
 	get lastClosedChat(): IChat | undefined {
 		// Filter out stale entries whose chat has since been deleted from the session.
 		const currentChats = this._session.chats.get();