From e31bc4c60ae060b2f0b38e7ebecd940f14532e5f Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 18:23:55 +0200
Subject: [PATCH 01/13] chat: fix: stop capitalizing localized customization
 group headers

`text-transform: capitalize` on the shared group header re-cased strings that
were already cased correctly, and got them wrong: "Included Based on Context"
rendered as "Included Based On Context" and "Loaded on Demand" as "Loaded On
Demand", against this repo's own rule that short prepositions stay lowercase,
and "Built-in" rendered as "Built-In".

Per-word capitalization is also not a transform that survives translation, so
the rule was wrong for every locale rather than just awkward in English.

The header is shared, so this reaches every customizations tab -- Agents,
Skills, Instructions, Hooks, Prompts, Plugins and MCP Servers. Every group
label on those tabs is already a correctly cased localized string, so the only
rendered differences are the three the transform was getting wrong.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../aiCustomization/media/aiCustomizationManagement.css      | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
index 275c364052e427..36d1c804611c0c 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
@@ -479,9 +479,12 @@
 	min-width: 0;
 }
 
+/* No text-transform: these labels are localized strings that are already cased correctly, and
+capitalize re-cased them wrongly -- "Included Based on Context" became "Based On" (against this
+repo's own rule that short prepositions stay lowercase) and "Built-in" became "Built-In". Per-word
+casing is also not a transform that survives translation. */
 .ai-customization-group-header .group-label {
 	font-weight: var(--vscode-agents-fontWeight-semiBold);
-	text-transform: capitalize;
 	color: var(--vscode-sideBarSectionHeader-foreground, var(--vscode-foreground));
 	overflow: hidden;
 	text-overflow: ellipsis;

From b30d08ca2179337b7d6e58cf834c498751128b83 Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 18:28:03 +0200
Subject: [PATCH 02/13] mcp: fix: make Show Output clickable on a failing MCP
 server

`updateStatus` began by clearing the row's action disposables and emptying its
actions node, then rebuilt them. It runs from an autorun over the server's
connection state, and an erroring server re-runs it about twice a second while
producing byte-identical content: measured in a real Code OSS build, 9-10
rebuilds per 5 seconds, every one of them a no-op.

A DOM node replaced between mousedown and mouseup never receives the click, so
the inline `Show Output` button did nothing on precisely the rows that needed
it -- the failing ones, which are the only rows that offer it at all.

The row's actions are now rebuilt only when something about them changed.
`getMcpStatusRenderSignature` reduces them to a comparable value covering both
what they render and what they act on; leaving anything out would drop an
update that matters, so it is a pure exported function with a test that fails
to compile if a field is added without being covered.

The list re-splices on every customizations change, so `renderElement` would
otherwise undo this by clearing the actions itself. It now keys on the row's
content identity rather than the entry object, which is recreated on every
refresh and therefore says nothing about whether this is the same row.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../browser/aiCustomization/mcpListWidget.ts  | 112 +++++++++++++++++-
 .../aiCustomization/mcpListWidget.test.ts     |  56 +++++++++
 2 files changed, 162 insertions(+), 6 deletions(-)

diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
index 92b45cae6fbcf8..6cf8ddb7d29457 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
@@ -162,6 +162,10 @@ interface IMcpServerItemTemplateData {
 	readonly actions: HTMLElement;
 	readonly elementDisposables: DisposableStore;
 	readonly actionDisposables: DisposableStore;
+	/** Which row the actions currently belong to, so a recycled template cannot reuse another row's. */
+	renderedRowKey?: string;
+	/** What the actions currently show, so an unchanged status does not rebuild them. */
+	renderedStatusSignature?: string;
 }
 
 /**
@@ -206,8 +210,18 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 	}
 
 	renderElement(element: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry, index: number, templateData: IMcpServerItemTemplateData): void {
+		// Tearing down the actions is what makes a click land on a node that is about to be
+		// replaced, so only do it when this template starts showing a different row. Whether the
+		// same row's actions need rebuilding is decided by `updateStatus` from its own signature.
+		const rowKey = getMcpRowKey(element);
+		if (templateData.renderedRowKey !== rowKey) {
+			templateData.renderedRowKey = rowKey;
+			templateData.renderedStatusSignature = undefined;
+			templateData.actionDisposables.clear();
+			DOM.clearNode(templateData.actions);
+		}
+		// Always re-created: these capture `element`, which is a fresh object on every refresh.
 		templateData.elementDisposables.clear();
-		templateData.actionDisposables.clear();
 
 		if (element.type === 'builtin-item') {
 			templateData.container.classList.add('builtin');
@@ -314,17 +328,40 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 	}
 
 	private updateStatus(templateData: IMcpServerItemTemplateData, element: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry, state: McpStatusKind | undefined, disabledReason?: CustomizationDisabledReason): void {
+		const presentation = getMcpStatusPresentation(state, disabledReason);
+		const activeSessionServer = getActiveSessionServer(element);
+		const label = getMcpEntryLabel(element);
+		const activeSessionResource = this.customizationHarnessService.activeSessionResource.get();
+		const localServer = element.type === 'session-server-item' ? undefined : element.localServer;
+
+		// This runs from an autorun over the server's connection state, and an erroring server
+		// re-runs it about twice a second with byte-identical content. Rebuilding regardless meant
+		// a node replaced between mousedown and mouseup never saw the click, so `Show Output` did
+		// nothing on precisely the rows that needed it.
+		const signature = getMcpStatusRenderSignature({
+			rowKey: getMcpRowKey(element),
+			label,
+			state,
+			statusLabel: presentation?.label,
+			statusClassName: presentation?.className,
+			statusIconId: presentation?.icon?.id,
+			activeSessionServerId: activeSessionServer?.id,
+			logOutputChannelId: activeSessionServer?.logOutputChannelId,
+			localServerId: localServer?.definition.id,
+			activeSessionResource: activeSessionResource.toString(),
+		});
+		if (templateData.renderedStatusSignature === signature) {
+			return;
+		}
+		templateData.renderedStatusSignature = signature;
+
 		templateData.actionDisposables.clear();
 		DOM.clearNode(templateData.actions);
 
-		const presentation = getMcpStatusPresentation(state, disabledReason);
 		if (!presentation) {
 			return;
 		}
 
-		const activeSessionServer = getActiveSessionServer(element);
-		const label = getMcpEntryLabel(element);
-		const activeSessionResource = this.customizationHarnessService.activeSessionResource.get();
 		const showActiveSessionOutput = activeSessionServer !== undefined
 			? (beforeShow?: () => Promise<void>) => this.agentHostCustomizationService.showMcpServerLog(activeSessionResource, activeSessionServer.id, beforeShow)
 			: undefined;
@@ -354,7 +391,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 		}
 
 		const showOutput = state === McpServerStatus.Error || state === McpConnectionState.Kind.Error
-			? getMcpServerOutputHandler(this.outputService, element.type === 'session-server-item' ? undefined : element.localServer, activeSessionServer, this._afterShowOutput, showActiveSessionOutput)
+			? getMcpServerOutputHandler(this.outputService, localServer, activeSessionServer, this._afterShowOutput, showActiveSessionOutput)
 			: undefined;
 		if (showOutput) {
 			const showOutputLabel = localize('showMcpServerOutput', "Show output for {0}", label);
@@ -451,6 +488,69 @@ function getActiveSessionServer(entry: IMcpServerItemEntry | IMcpSessionServerIt
 	return entry.type === 'session-server-item' ? entry.server : entry.activeSessionServer;
 }
 
+/**
+ * Which row a template is currently showing. List entries are recreated on every refresh, so
+ * object identity says nothing about whether this is still the same server in the same place.
+ */
+function getMcpRowKey(entry: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry): string {
+	switch (entry.type) {
+		case 'server-item':
+			return `server:${entry.server.id}:${entry.marketplace ? 1 : 0}`;
+		case 'session-server-item':
+			return `session:${entry.server.id}`;
+		case 'builtin-item':
+			return `builtin:${entry.id}`;
+	}
+}
+
+/** Everything the status actions of a row are built from: what they show, and what they act on. */
+export interface IMcpStatusRenderInput {
+	/** Identifies the row, so a recycled template never mistakes one server's actions for another's. */
+	readonly rowKey: string;
+	/** The server's name, which appears in the button titles and aria labels. */
+	readonly label: string;
+	/** Decides which actions exist at all: sign-in when auth is required, output on error. */
+	readonly state: McpStatusKind | undefined;
+	readonly statusLabel: string | undefined;
+	readonly statusClassName: string | undefined;
+	readonly statusIconId: string | undefined;
+	/** The active-session twin the sign-in and output actions are bound to. */
+	readonly activeSessionServerId: string | undefined;
+	readonly logOutputChannelId: string | undefined;
+	/** The local server the output action falls back to. */
+	readonly localServerId: string | undefined;
+	/** Captured when the output action is built, so switching sessions has to rebuild it. */
+	readonly activeSessionResource: string | undefined;
+}
+
+/**
+ * Reduces a row's status actions to a comparable value, so they are only rebuilt when something
+ * about them actually changed.
+ *
+ * The status update runs from an autorun over the server's connection state, which for an erroring
+ * server fires about twice a second while producing byte-identical content. Tearing the actions
+ * down and rebuilding them anyway meant a node could be replaced between mousedown and mouseup,
+ * and a node replaced mid-click never receives the click -- so the inline `Show Output` button did
+ * nothing on precisely the rows that needed it.
+ *
+ * The signature therefore has to cover every value the actions are built from, both what they
+ * render and what they act on, or an update that matters would be dropped.
+ */
+export function getMcpStatusRenderSignature(input: IMcpStatusRenderInput): string {
+	return JSON.stringify([
+		input.rowKey,
+		input.label,
+		input.state ?? null,
+		input.statusLabel ?? null,
+		input.statusClassName ?? null,
+		input.statusIconId ?? null,
+		input.activeSessionServerId ?? null,
+		input.logOutputChannelId ?? null,
+		input.localServerId ?? null,
+		input.activeSessionResource ?? null,
+	]);
+}
+
 function getMcpEntryLabel(element: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry): string {
 	return element.type === 'session-server-item'
 		? element.server.name
diff --git a/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts b/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
index efcaf77ff25cee..429f9df7f9bb8c 100644
--- a/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
+++ b/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
@@ -29,8 +29,10 @@ import {
 	getLocalMcpServerEnablementActions,
 	getMcpServerOutputHandler,
 	getMcpStatusPresentation,
+	getMcpStatusRenderSignature,
 	getServerItemContextMenuActions,
 	registerMcpInlineButtonAction,
+	type IMcpStatusRenderInput,
 } from '../../../browser/aiCustomization/mcpListWidget.js';
 
 function createAgentHostServer(overrides: Partial<AgentHostMcpServer> = {}): AgentHostMcpServer {
@@ -508,6 +510,60 @@ suite('mcpListWidget', () => {
 		});
 	});
 
+	suite('getMcpStatusRenderSignature', () => {
+		const base: IMcpStatusRenderInput = {
+			rowKey: 'server:mcp.config.workspace/notion:0',
+			label: 'notion',
+			state: McpServerStatus.Error,
+			statusLabel: 'Error',
+			statusClassName: 'error',
+			statusIconId: 'error',
+			activeSessionServerId: 'session-1/notion',
+			logOutputChannelId: 'mcp.session-1.notion',
+			localServerId: 'mcp.config.workspace/notion',
+			activeSessionResource: 'vscode-agent-session:///session-1',
+		};
+
+		// A different, and differently-typed-where-possible, value for every field. The mapped type
+		// is what makes this a barrier: a field added to the input fails to compile until it is
+		// given a value here, and the test below then proves the signature actually covers it.
+		const changed: { [K in keyof IMcpStatusRenderInput]-?: IMcpStatusRenderInput[K] } = {
+			rowKey: 'server:mcp.config.user/notion:0',
+			label: 'Notion',
+			state: McpServerStatus.Ready,
+			statusLabel: 'Running',
+			statusClassName: 'running',
+			statusIconId: 'check',
+			activeSessionServerId: 'session-1/other',
+			logOutputChannelId: 'mcp.session-1.other',
+			localServerId: 'mcp.config.user/notion',
+			activeSessionResource: 'vscode-agent-session:///session-2',
+		};
+
+		const fields = Object.keys(base) as (keyof IMcpStatusRenderInput)[];
+
+		test('the same row state produces the same signature', () => {
+			assert.strictEqual(getMcpStatusRenderSignature({ ...base }), getMcpStatusRenderSignature({ ...base }));
+		});
+
+		test('changing any covered value changes the signature', () => {
+			const baseline = getMcpStatusRenderSignature(base);
+			const missed = fields.filter(field => getMcpStatusRenderSignature({ ...base, [field]: changed[field] }) === baseline);
+
+			assert.deepStrictEqual(missed, []);
+		});
+
+		test('clearing any optional value changes the signature', () => {
+			const baseline = getMcpStatusRenderSignature(base);
+			// `rowKey` and `label` are always present; everything else can legitimately go away,
+			// e.g. when a server loses its active-session twin.
+			const clearable = fields.filter(field => field !== 'rowKey' && field !== 'label');
+			const missed = clearable.filter(field => getMcpStatusRenderSignature({ ...base, [field]: undefined }) === baseline);
+
+			assert.deepStrictEqual(missed, []);
+		});
+	});
+
 	suite('inline actions', () => {
 		test('authentication receives the active session and server without opening the row', () => {
 			const sessionResource = URI.parse('vscode-agent-session:///session-1');

From 6b308e444200221545699af5ea92e0d8ae1d75b5 Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 18:32:04 +0200
Subject: [PATCH 03/13] mcp: fix: show one row per agent MCP server, not one
 per customization

A session can carry two customizations for a single MCP server. The agent host
publishes the declaration as a child of whatever declared it -- a plugin, or
the .mcp.json VS Code syncs into the agent -- and separately mints a top-level
customization for any server the SDK reports before that child can be resolved
by name. `McpCustomizationController._applyOne` never retires the minted entry
once the child becomes resolvable ("Once promoted to a top-level entry, stay
top-level for the session"), so both remain in state:

    notion -> file:///.../vscode-synced-customization-.../.mcp.json#mcp=notion
              state: stopped                 <- the declaration
    notion -> mcp-top-level:copilotcli:<session>:notion
              state: ready, channel: mcp://  <- the live one

Every consumer of getMcpServers saw both, so the servers list rendered the same
server twice with contradictory status. It was worse than a repeat: the list's
matcher only matches when exactly one candidate answers a key, so with two
copies the server's local row could not adopt either, and both fell through as
extra rows.

getMcpServers now drops a child that a top-level customization already speaks
for. The top-level copy wins because it is the one the host treats as live: it
carries the running state and channel, and its id is what the host resolves for
lifecycle and enablement. Position in the tree is the signal, not the shape of
the minted id, which is the host's own business -- and not the absence of an
owning plugin either, since a directory-declared child has none.

Nothing else is collapsed. Two plugins that each declare a server named
`search` stay two rows, because they are two servers. Only the presentation
path dedupes; log, diagnostics and id lookups still walk every customization,
so an id from either copy continues to resolve.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../agentHostCustomizationService.ts          | 79 +++++++++++++++----
 .../agentHostMcpServerCustomizations.test.ts  | 75 ++++++++++++++++++
 2 files changed, 140 insertions(+), 14 deletions(-)
 create mode 100644 src/vs/workbench/contrib/chat/test/browser/agentSessions/agentHostMcpServerCustomizations.test.ts

diff --git a/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.ts b/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.ts
index a55b21623956e3..c0eda9e926b011 100644
--- a/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.ts
+++ b/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.ts
@@ -184,7 +184,7 @@ export abstract class AbstractAgentHostCustomizationService extends Disposable i
 		if (!target) {
 			return [];
 		}
-		return this._flattenMcpServers(target.customizations)
+		return getPresentableMcpServerCustomizations(target.customizations)
 			.map(({ server, plugin }): IAgentHostMcpServer => ({
 				id: this._scopedMcpServerId(sessionResource, server.id),
 				name: server.name,
@@ -208,7 +208,7 @@ export abstract class AbstractAgentHostCustomizationService extends Disposable i
 		if (!target) {
 			return Promise.resolve();
 		}
-		const entry = this._flattenMcpServers(target.customizations).find(({ server }) => this._scopedMcpServerId(sessionResource, server.id) === serverId);
+		const entry = flattenMcpServerCustomizations(target.customizations).find(({ server }) => this._scopedMcpServerId(sessionResource, server.id) === serverId);
 		if (!entry) {
 			return Promise.resolve();
 		}
@@ -226,7 +226,7 @@ export abstract class AbstractAgentHostCustomizationService extends Disposable i
 	 */
 	private _trackMcpDiagnostics(sessionResource: URI, target: IAgentHostCustomizationTarget): void {
 		this._mcpDiagnosticSessions.add(sessionResource);
-		for (const { server, plugin } of this._flattenMcpServers(target.customizations)) {
+		for (const { server, plugin } of flattenMcpServerCustomizations(target.customizations)) {
 			this._mcpLogRegistry.record({ sessionResource, rawId: server.id, name: server.name, enabled: isCustomizationEnabled(server) && (!plugin || isCustomizationEnabled(plugin)), state: server.state });
 		}
 	}
@@ -238,7 +238,7 @@ export abstract class AbstractAgentHostCustomizationService extends Disposable i
 			if (!target) {
 				continue;
 			}
-			for (const { server, plugin } of this._flattenMcpServers(target.customizations)) {
+			for (const { server, plugin } of flattenMcpServerCustomizations(target.customizations)) {
 				this._mcpLogRegistry.record({ sessionResource, rawId: server.id, name: server.name, enabled: isCustomizationEnabled(server) && (!plugin || isCustomizationEnabled(plugin)), state: server.state });
 			}
 		}
@@ -327,17 +327,8 @@ export abstract class AbstractAgentHostCustomizationService extends Disposable i
 		this._onDidChangeCustomizations.fire();
 	}
 
-	private _flattenMcpServers(customizations: readonly Customization[]): readonly { readonly server: McpServerCustomization; readonly plugin?: PluginCustomization }[] {
-		return customizations.flatMap(customization => customization.type === CustomizationType.McpServer
-			? [{ server: customization }]
-			: customization.children?.filter(child => child.type === CustomizationType.McpServer).map(server => ({
-				server,
-				plugin: customization.type === CustomizationType.Plugin ? customization : undefined,
-			})) ?? []);
-	}
-
 	private _findMcpServer(customizations: readonly Customization[], serverId: string): McpServerCustomization | undefined {
-		for (const { server } of this._flattenMcpServers(customizations)) {
+		for (const { server } of flattenMcpServerCustomizations(customizations)) {
 			if (server.id === serverId || this._isScopedMcpServerIdForRawId(serverId, server.id)) {
 				return server;
 			}
@@ -368,6 +359,66 @@ export abstract class AbstractAgentHostCustomizationService extends Disposable i
 	}
 }
 
+/** One MCP server customization, with the position it was published at. */
+export interface IMcpServerCustomizationEntry {
+	readonly server: McpServerCustomization;
+	/**
+	 * The plugin that declares this server. Absent both for a server published at the top level
+	 * and for one declared by a {@link CustomizationType.Directory} container, so it says nothing
+	 * about where in the tree the server sits -- use {@link isTopLevel} for that.
+	 */
+	readonly plugin?: PluginCustomization;
+	/** Whether the agent host published this server as a customization of the session itself. */
+	readonly isTopLevel: boolean;
+}
+
+/** Every MCP server customization in a session, including duplicates of the same server. */
+export function flattenMcpServerCustomizations(customizations: readonly Customization[]): readonly IMcpServerCustomizationEntry[] {
+	return customizations.flatMap((customization): IMcpServerCustomizationEntry[] => customization.type === CustomizationType.McpServer
+		? [{ server: customization, isTopLevel: true }]
+		: customization.children?.filter(child => child.type === CustomizationType.McpServer).map(server => ({
+			server,
+			plugin: customization.type === CustomizationType.Plugin ? customization : undefined,
+			isTopLevel: false,
+		})) ?? []);
+}
+
+/**
+ * The MCP servers to *show* for a session: one entry per server.
+ *
+ * A session can carry two customizations for a single server. The agent host publishes the
+ * declaration as a child of whatever declared it -- a plugin, or the `.mcp.json` VS Code syncs
+ * into the agent -- and separately mints a top-level customization for any server the SDK reports
+ * before that child can be resolved by name. Once minted, the top-level entry stays for the
+ * session, so both remain: the child holds the declaration and never leaves `stopped`, while the
+ * top-level entry is the one the host keeps up to date. Rendering both showed the same server
+ * twice, with contradictory status, and it was worse than a repeat -- the list refuses to match a
+ * local row to its session twin when two candidates answer to one name, so both copies fell
+ * through as extra rows.
+ *
+ * A child is therefore dropped when a top-level customization already speaks for that name,
+ * because that is the copy the agent host treats as live: it carries the running state and
+ * channel, and its id is what the host resolves for lifecycle and enablement. Position in the tree
+ * is the signal rather than the shape of the minted id, which is the host's own business.
+ *
+ * Nothing else is collapsed. Two plugins that each declare a server named `search` stay two
+ * entries, because they are two servers and this is not the place to decide otherwise. Lookups
+ * elsewhere still walk every customization, so an id from either copy continues to resolve.
+ */
+export function getPresentableMcpServerCustomizations(customizations: readonly Customization[]): readonly IMcpServerCustomizationEntry[] {
+	const entries = flattenMcpServerCustomizations(customizations);
+	const topLevelNames = new Set<string>();
+	for (const entry of entries) {
+		if (entry.isTopLevel) {
+			topLevelNames.add(entry.server.name);
+		}
+	}
+	if (topLevelNames.size === 0) {
+		return entries;
+	}
+	return entries.filter(entry => entry.isTopLevel || !topLevelNames.has(entry.server.name));
+}
+
 class WorkbenchAgentHostCustomizationService extends AbstractAgentHostCustomizationService {
 
 	private readonly _sessionStateSubscriptions = this._register(new DisposableResourceMap<IDisposable & { readonly connection: IAgentConnection; readonly backendSession: URI; readonly sub: IAgentSubscription<SessionState> }>());
diff --git a/src/vs/workbench/contrib/chat/test/browser/agentSessions/agentHostMcpServerCustomizations.test.ts b/src/vs/workbench/contrib/chat/test/browser/agentSessions/agentHostMcpServerCustomizations.test.ts
new file mode 100644
index 00000000000000..8da0e59cbc931a
--- /dev/null
+++ b/src/vs/workbench/contrib/chat/test/browser/agentSessions/agentHostMcpServerCustomizations.test.ts
@@ -0,0 +1,75 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import assert from 'assert';
+import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../../base/test/common/utils.js';
+import { CustomizationType, McpServerStatus, type Customization, type DirectoryCustomization, type McpServerCustomization, type McpServerState, type PluginCustomization } from '../../../../../../platform/agentHost/common/state/protocol/state.js';
+import { getPresentableMcpServerCustomizations } from '../../../browser/agentSessions/agentHost/agentHostCustomizationService.js';
+
+suite('agent host MCP server customizations', () => {
+
+	ensureNoDisposablesAreLeakedInTestSuite();
+
+	function mcpServer(id: string, name: string, state: McpServerState = { kind: McpServerStatus.Stopped }): McpServerCustomization {
+		return { type: CustomizationType.McpServer, id, uri: `file:///${encodeURIComponent(id)}`, name, state };
+	}
+
+	function plugin(id: string, children: McpServerCustomization[]): PluginCustomization {
+		return { type: CustomizationType.Plugin, id, uri: `file:///${encodeURIComponent(id)}`, name: id, children };
+	}
+
+	function directory(id: string, children: McpServerCustomization[]): DirectoryCustomization {
+		return { type: CustomizationType.Directory, id, uri: `file:///${encodeURIComponent(id)}`, name: id, enabled: true, writable: true, contents: CustomizationType.McpServer, children };
+	}
+
+	function shown(customizations: readonly Customization[]): [string, string][] {
+		return getPresentableMcpServerCustomizations(customizations).map(({ server }) => [server.name, server.id]);
+	}
+
+	test('a server a plugin declares and the host also minted is shown once, as the live copy', () => {
+		// The shape an agent host actually publishes: the synced `.mcp.json` declares the server
+		// and never leaves `stopped`, while the minted top-level entry is the one it keeps current.
+		const declaration = mcpServer('file:///synced/.mcp.json#mcp=notion', 'notion');
+		const live = mcpServer('mcp-top-level:copilotcli:session:notion', 'notion', { kind: McpServerStatus.Ready });
+
+		assert.deepStrictEqual(shown([plugin('synced', [declaration]), live]), [
+			['notion', 'mcp-top-level:copilotcli:session:notion'],
+		]);
+	});
+
+	test('a server a directory declares and the host also minted is shown once, as the live copy', () => {
+		// A directory-declared child carries no owning plugin, so "has no plugin" cannot stand in
+		// for "is top-level": doing so would let this child claim the name and survive shadowing.
+		const declaration = mcpServer('file:///.mcp.json#mcp=notion', 'notion');
+		const live = mcpServer('mcp-top-level:copilotcli:session:notion', 'notion', { kind: McpServerStatus.Ready });
+
+		assert.deepStrictEqual(shown([directory('mcp-config', [declaration]), live]), [
+			['notion', 'mcp-top-level:copilotcli:session:notion'],
+		]);
+	});
+
+	test('a server only a container declares is kept, and so is one only the host minted', () => {
+		const declared = mcpServer('file:///synced/.mcp.json#mcp=cleanshot', 'cleanshot');
+		const inDirectory = mcpServer('file:///.mcp.json#mcp=playwright', 'playwright');
+		const minted = mcpServer('mcp-top-level:copilotcli:session:notion', 'notion', { kind: McpServerStatus.Ready });
+
+		// Source order is preserved, exactly as it was before duplicates were collapsed.
+		assert.deepStrictEqual(shown([plugin('synced', [declared]), directory('mcp-config', [inDirectory]), minted]), [
+			['cleanshot', 'file:///synced/.mcp.json#mcp=cleanshot'],
+			['playwright', 'file:///.mcp.json#mcp=playwright'],
+			['notion', 'mcp-top-level:copilotcli:session:notion'],
+		]);
+	});
+
+	test('two plugins declaring the same name stay two servers, because they are two servers', () => {
+		assert.deepStrictEqual(shown([
+			plugin('a', [mcpServer('file:///a/.mcp.json#mcp=search', 'search')]),
+			plugin('b', [mcpServer('file:///b/.mcp.json#mcp=search', 'search')]),
+		]), [
+			['search', 'file:///a/.mcp.json#mcp=search'],
+			['search', 'file:///b/.mcp.json#mcp=search'],
+		]);
+	});
+});

From 5ad89264d3241b083752b43f52fdb55020b31be5 Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 18:32:17 +0200
Subject: [PATCH 04/13] chat: feat: let a harness report the name of the agent
 behind it

UI that needs to name the agent cannot derive it from the descriptor's
label: that string is localized and carries a disambiguating suffix, so
stripping the suffix would break in translation.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../agentHost/agentHostChatContribution.ts             |  1 +
 .../contrib/chat/common/customizationHarnessService.ts | 10 ++++++++++
 2 files changed, 11 insertions(+)

diff --git a/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostChatContribution.ts b/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostChatContribution.ts
index 39be482241374c..5a2bc766fd1577 100644
--- a/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostChatContribution.ts
+++ b/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostChatContribution.ts
@@ -322,6 +322,7 @@ export class AgentHostContribution extends Disposable implements IWorkbenchContr
 		store.add(this._customizationHarnessService.registerExternalHarness({
 			id: sessionType,
 			label: localize('agentHostHarnessLabel.local', "{0} [Agent Host]", agent.displayName),
+			agentName: agent.displayName,
 			icon: ThemeIcon.fromId(Codicon.server.id),
 			// The Tools section is surfaced for the Copilot CLI agent host only.
 			hiddenSections: agent.provider === 'copilotcli' ? [AICustomizationManagementSection.Prompts] : [AICustomizationManagementSection.Tools, AICustomizationManagementSection.Prompts],
diff --git a/src/vs/workbench/contrib/chat/common/customizationHarnessService.ts b/src/vs/workbench/contrib/chat/common/customizationHarnessService.ts
index 10b25c470df61d..ec8132d72b2860 100644
--- a/src/vs/workbench/contrib/chat/common/customizationHarnessService.ts
+++ b/src/vs/workbench/contrib/chat/common/customizationHarnessService.ts
@@ -79,6 +79,16 @@ export interface IHarnessDescriptor {
 	 */
 	readonly id: string;
 	readonly label: string;
+	/**
+	 * The agent's own name, without any disambiguating suffix — e.g. `Copilot`
+	 * where {@link label} is `Copilot [Agent Host]`.
+	 *
+	 * Exists because UI that needs to *name the agent* cannot derive it from
+	 * `label`: that string is localized and suffixed, so stripping the suffix
+	 * would break in translation. Undefined for harnesses that are not backed
+	 * by a distinct agent, where callers should fall back to their own wording.
+	 */
+	readonly agentName?: string;
 	readonly icon: ThemeIcon;
 	/**
 	 * Management sections that should be hidden when this harness is active.

From 0f3f6d337625efce9240c0ac59097ea18aa569bb Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 18:32:19 +0200
Subject: [PATCH 05/13] chat: feat: turn a contribution on or off without
 moving its scope

A contribution turned off for this workspace should come back on for this
workspace, and one turned off everywhere should come back on everywhere.
Promoting or demoting the scope behind the user's back rewrites a choice
they made deliberately, and a plain on/off control shows the scope only
while the row is off, so they would not even see it happen.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../contrib/chat/common/enablement.ts         | 25 ++++++++++
 .../chat/test/common/enablement.test.ts       | 50 +++++++++++++++++++
 2 files changed, 75 insertions(+)
 create mode 100644 src/vs/workbench/contrib/chat/test/common/enablement.test.ts

diff --git a/src/vs/workbench/contrib/chat/common/enablement.ts b/src/vs/workbench/contrib/chat/common/enablement.ts
index 2c6b674ac22716..4d55642f4ee6a1 100644
--- a/src/vs/workbench/contrib/chat/common/enablement.ts
+++ b/src/vs/workbench/contrib/chat/common/enablement.ts
@@ -23,6 +23,31 @@ export function isContributionDisabled(state: ContributionEnablementState): bool
 	return !isContributionEnabled(state);
 }
 
+/**
+ * Turns a contribution on or off *without* moving which layer decides it.
+ *
+ * A server turned off for this workspace comes back on for this workspace, and one turned off
+ * everywhere comes back on everywhere. Promoting or demoting the scope behind the user's back
+ * would silently rewrite a choice they made deliberately -- and because a plain on/off control
+ * shows the scope only while the row is off, the user would not even see it happen. Changing
+ * scope stays an explicit act, available from the context menu.
+ *
+ * Writing the deciding layer is also what makes the control truthful: the workspace entry wins
+ * over the profile one in {@link EnablementModel.readEnabled}, so writing the *other* layer
+ * would leave the row visibly unchanged after the user asked for something.
+ */
+export function withContributionEnabled(state: ContributionEnablementState, enabled: boolean): ContributionEnablementState {
+	if (isWorkspaceScopedEnablement(state)) {
+		return enabled ? ContributionEnablementState.EnabledWorkspace : ContributionEnablementState.DisabledWorkspace;
+	}
+	return enabled ? ContributionEnablementState.EnabledProfile : ContributionEnablementState.DisabledProfile;
+}
+
+/** Whether the workspace layer, rather than the profile, is deciding this state. */
+export function isWorkspaceScopedEnablement(state: ContributionEnablementState): boolean {
+	return state === ContributionEnablementState.EnabledWorkspace || state === ContributionEnablementState.DisabledWorkspace;
+}
+
 export interface IEnablementModel {
 	readEnabled(key: string, reader?: IReader): ContributionEnablementState;
 	readProfileEnabled(key: string, reader?: IReader): boolean;
diff --git a/src/vs/workbench/contrib/chat/test/common/enablement.test.ts b/src/vs/workbench/contrib/chat/test/common/enablement.test.ts
new file mode 100644
index 00000000000000..889be4e1825ab1
--- /dev/null
+++ b/src/vs/workbench/contrib/chat/test/common/enablement.test.ts
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import assert from 'assert';
+import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';
+import { ContributionEnablementState, isWorkspaceScopedEnablement, withContributionEnabled } from '../../common/enablement.js';
+
+suite('enablement', () => {
+
+	ensureNoDisposablesAreLeakedInTestSuite();
+
+	suite('withContributionEnabled', () => {
+
+		test('answers a workspace choice where it was made, rather than promoting it', () => {
+			assert.deepStrictEqual([
+				withContributionEnabled(ContributionEnablementState.EnabledWorkspace, false),
+				withContributionEnabled(ContributionEnablementState.DisabledWorkspace, true),
+			], [
+				ContributionEnablementState.DisabledWorkspace,
+				ContributionEnablementState.EnabledWorkspace,
+			]);
+		});
+
+		test('answers a profile choice at the profile', () => {
+			assert.deepStrictEqual([
+				withContributionEnabled(ContributionEnablementState.EnabledProfile, false),
+				withContributionEnabled(ContributionEnablementState.DisabledProfile, true),
+			], [
+				ContributionEnablementState.DisabledProfile,
+				ContributionEnablementState.EnabledProfile,
+			]);
+		});
+
+		test('turning a workspace choice off and on again returns it to where it started', () => {
+			const start = ContributionEnablementState.EnabledWorkspace;
+			assert.strictEqual(withContributionEnabled(withContributionEnabled(start, false), true), start);
+		});
+	});
+
+	test('isWorkspaceScopedEnablement names only the workspace states', () => {
+		assert.deepStrictEqual([
+			ContributionEnablementState.EnabledWorkspace,
+			ContributionEnablementState.DisabledWorkspace,
+			ContributionEnablementState.EnabledProfile,
+			ContributionEnablementState.DisabledProfile,
+		].map(isWorkspaceScopedEnablement), [true, true, false, false]);
+	});
+});

From 2301b28d779ea0295b440392b8428bca90eade6b Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 18:33:38 +0200
Subject: [PATCH 06/13] mcp: feat: add a reusable on/off switch for
 customization rows

Enablement used to be reachable only through a right-click menu, which
meant the most common thing someone wants to do with a server was also
the least discoverable. This gives a row one control in one place, so the
eye learns a single target while scanning a long list.

The accessible name is the subject rather than the act: role=switch
announces on/off from aria-checked, so an action phrase would read
"Disable Redis, switch, on" -- a label arguing with the state beside it.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../aiCustomization/enablementSwitch.ts       | 86 +++++++++++++++++++
 .../media/aiCustomizationManagement.css       | 58 +++++++++++++
 2 files changed, 144 insertions(+)
 create mode 100644 src/vs/workbench/contrib/chat/browser/aiCustomization/enablementSwitch.ts

diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/enablementSwitch.ts b/src/vs/workbench/contrib/chat/browser/aiCustomization/enablementSwitch.ts
new file mode 100644
index 00000000000000..58729bb53c5565
--- /dev/null
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/enablementSwitch.ts
@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as DOM from '../../../../../base/browser/dom.js';
+import { $ } from '../../../../../base/browser/dom.js';
+import { StandardKeyboardEvent } from '../../../../../base/browser/keyboardEvent.js';
+import { Emitter, Event } from '../../../../../base/common/event.js';
+import { KeyCode } from '../../../../../base/common/keyCodes.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+
+/**
+ * A compact on/off switch for turning a customization on or off directly from a list row.
+ *
+ * Enablement used to be reachable only through a right-click menu, which meant the most common
+ * thing someone wants to do with a server was also the least discoverable. This gives every row
+ * one control in one place, so the eye learns a single target while scanning a long list.
+ *
+ * The widget is deliberately dumb: it renders state and reports intent. Callers decide what
+ * toggling means, and own any hover text, because the surrounding scope rules differ per list.
+ */
+export class EnablementSwitch extends Disposable {
+
+	readonly element: HTMLElement;
+
+	private readonly _onDidToggle = this._register(new Emitter<void>());
+	/** Fired when the user asks to flip the switch. The caller applies the change. */
+	readonly onDidToggle: Event<void> = this._onDidToggle.event;
+
+	private _checked = false;
+
+	constructor(parent: HTMLElement) {
+		super();
+
+		// A real <button role="switch"> rather than a styled div: it is focusable, announces its
+		// on/off state, and responds to Enter and Space without us reimplementing any of it.
+		this.element = DOM.append(parent, $('button.ai-customization-switch'));
+		this.element.setAttribute('role', 'switch');
+		this.element.setAttribute('type', 'button');
+		// A bare <button> is focusable, but List.onTab finds the control inside a row with
+		// querySelector('[tabIndex]'), which only matches the content attribute. Assigning the
+		// property reflects it, so Tab from the row reaches the switch.
+		this.element.tabIndex = 0;
+		DOM.append(this.element, $('span.ai-customization-switch-knob'));
+
+		this._register(DOM.addDisposableListener(this.element, DOM.EventType.CLICK, e => {
+			// Rows react to clicks too; a click on the switch is about the switch alone.
+			e.stopPropagation();
+			e.preventDefault();
+			this._onDidToggle.fire();
+		}));
+
+		// Space would otherwise scroll the list before the button ever sees it.
+		this._register(DOM.addDisposableListener(this.element, DOM.EventType.KEY_DOWN, e => {
+			const event = new StandardKeyboardEvent(e);
+			if (event.equals(KeyCode.Space) || event.equals(KeyCode.Enter)) {
+				event.stopPropagation();
+				event.preventDefault();
+				this._onDidToggle.fire();
+			}
+		}));
+	}
+
+	/** Rows share one template, so the switch is hidden rather than rebuilt when a row has none. */
+	setVisible(visible: boolean): void {
+		this.element.style.display = visible ? '' : 'none';
+	}
+
+	get checked(): boolean {
+		return this._checked;
+	}
+
+	/**
+	 * @param checked whether the customization is currently on.
+	 * @param ariaLabel the customization this switch acts on. Deliberately the subject rather
+	 * than the act: `role="switch"` announces on/off from `aria-checked`, so an action phrase
+	 * would read "Disable Redis, switch, on" -- a label arguing with the state beside it.
+	 */
+	update(checked: boolean, ariaLabel: string): void {
+		this._checked = checked;
+		this.element.classList.toggle('checked', checked);
+		this.element.setAttribute('aria-checked', String(checked));
+		this.element.setAttribute('aria-label', ariaLabel);
+	}
+}
diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
index 36d1c804611c0c..d6fac16504fa82 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
@@ -1808,6 +1808,64 @@ casing is also not a transform that survives translation. */
 	color: var(--vscode-disabledForeground);
 }
 
+/* On/off switch
+-------------------------------------------------------------------------- */
+
+.ai-customization-switch {
+	flex-shrink: 0;
+	position: relative;
+	width: var(--vscode-spacing-size280);
+	height: var(--vscode-spacing-size160);
+	padding: 0;
+	border: 1px solid var(--vscode-checkbox-border);
+	border-radius: var(--vscode-cornerRadius-circle);
+	background-color: var(--vscode-checkbox-background);
+	cursor: pointer;
+	transition: background-color 100ms ease-out;
+}
+
+.ai-customization-switch-knob {
+	position: absolute;
+	top: 50%;
+	left: var(--vscode-spacing-size20);
+	width: var(--vscode-spacing-size100);
+	height: var(--vscode-spacing-size100);
+	border-radius: var(--vscode-cornerRadius-circle);
+	background-color: var(--vscode-checkbox-foreground);
+	transform: translateY(-50%);
+	transition: left 100ms ease-out, background-color 100ms ease-out;
+}
+
+/* The knob slide is decorative: the state is already carried by colour and aria-checked, so
+honouring reduceMotion costs nothing. workbench.reduceMotion sets this class, which the OS-level
+prefers-reduced-motion query does not cover on its own. */
+.monaco-reduce-motion .ai-customization-switch,
+.monaco-reduce-motion .ai-customization-switch-knob {
+	transition: none;
+}
+
+.ai-customization-switch.checked {
+	background-color: var(--vscode-button-background);
+	/* High-contrast themes flatten the fill, so on/off would differ by knob position alone.
+	contrastActiveBorder is only defined there, so this is inert in the other themes. */
+	border-color: var(--vscode-contrastActiveBorder, var(--vscode-checkbox-border));
+}
+
+.ai-customization-switch.checked .ai-customization-switch-knob {
+	left: calc(100% - var(--vscode-spacing-size100) - var(--vscode-spacing-size20));
+	background-color: var(--vscode-button-foreground);
+}
+
+.ai-customization-switch:focus-visible {
+	outline: 1px solid var(--vscode-focusBorder);
+	outline-offset: 2px;
+}
+
+/* The row dims when a server is off, but its switch must stay readable -- it is the way back. */
+.mcp-server-item.disabled .ai-customization-switch {
+	opacity: 1;
+}
+
 /* Button group for Add Server + Browse Marketplace */
 .mcp-list-widget .list-button-group {
 	display: flex;

From 5150073270eef1763611a3bb52395e1a8e6a95b3 Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 18:38:31 +0200
Subject: [PATCH 07/13] mcp: refactor: resolve one row's status in one place

There were three paths deciding what a row's status was: two that shared
updateKnownServerStatus and a third that computed the same answer inline.
They agreed only by coincidence, and this is the same file whose history
says copies of a status rule had already drifted apart.

The accessible name now comes from that one resolver too, as an
observable. It has to be one: a row's status changes without the list
being spliced, so a plain string is computed once and then describes the
past. getMcpServers is a plain read rather than an observable, so
agent-host state is folded into the same reactive graph through a signal
over onDidChangeCustomizations -- without it a derived over it would
never re-run.

A session row whose server momentarily leaves the service now keeps
showing what it last knew instead of blanking, because both paths share
the same fallback.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../browser/aiCustomization/mcpListWidget.ts  | 190 +++++++++++-------
 1 file changed, 118 insertions(+), 72 deletions(-)

diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
index 6cf8ddb7d29457..ad8e6a221c1f4c 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
@@ -24,7 +24,7 @@ import { MCP_PLUGIN_COLLECTION_ID_PREFIX } from '../../../mcp/common/discovery/p
 import { ExtensionIdentifier } from '../../../../../platform/extensions/common/extensions.js';
 import { ContributionEnablementState, isContributionDisabled } from '../../common/enablement.js';
 import { McpCommandIds } from '../../../../contrib/mcp/common/mcpCommandIds.js';
-import { autorun } from '../../../../../base/common/observable.js';
+import { autorun, derived, observableSignalFromEvent, type IObservable, type IReader } from '../../../../../base/common/observable.js';
 import { IOpenerService } from '../../../../../platform/opener/common/opener.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { InputBox } from '../../../../../base/browser/ui/inputbox/inputBox.js';
@@ -119,6 +119,49 @@ type IMcpListEntry = IMcpGroupHeaderEntry | IMcpServerItemEntry | IMcpSessionSer
 
 export type McpStatusKind = McpConnectionState.Kind | McpServerStatus | 'disabled';
 
+/**
+ * Reads the live view of an agent-host MCP server, reactively.
+ *
+ * A list entry holds the snapshot taken when the list was last built, and `getMcpServers` is a
+ * plain read rather than an observable, so nothing derived from it would re-run on its own.
+ * Reading through here inside an `autorun` or `derived` puts agent-host state into the same
+ * reactive graph as the local runtime's observables, so a row's status -- and the accessible
+ * name spoken beside it -- keep up with a server that starts, fails, or asks to sign in.
+ */
+class ActiveSessionMcpServerReader {
+
+	private readonly _changes: IObservable<void>;
+
+	constructor(
+		private readonly _agentHostCustomizationService: IAgentHostCustomizationService,
+		private readonly _customizationHarnessService: ICustomizationHarnessService,
+	) {
+		this._changes = observableSignalFromEvent('agentHostCustomizations', this._agentHostCustomizationService.onDidChangeCustomizations);
+	}
+
+	/**
+	 * Re-reads `snapshot` from the service. Falls back to the snapshot itself when the server has
+	 * gone, so a row keeps describing what it last knew rather than blanking.
+	 */
+	read(snapshot: AgentHostMcpServer | undefined, reader: IReader | undefined): AgentHostMcpServer | undefined {
+		if (!snapshot) {
+			return undefined;
+		}
+		this._changes.read(reader);
+		const sessionResource = this._customizationHarnessService.activeSessionResource.read(reader);
+		return this._agentHostCustomizationService.getMcpServers(sessionResource).find(server => server.id === snapshot.id) ?? snapshot;
+	}
+}
+
+/** The parts of a row that come from observables and change while the row is bound to an element. */
+interface IMcpRowState {
+	readonly status: McpStatusKind | undefined;
+	/** Why the row is off, when it is. Names the layer, or the plugin that owns it. */
+	readonly disabledReason?: CustomizationDisabledReason;
+	/** The live agent-host view of this row's server, re-read rather than the stale snapshot. */
+	readonly activeSessionServer?: AgentHostMcpServer;
+}
+
 /**
  * Delegate for the MCP server list.
  */
@@ -176,6 +219,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 
 	constructor(
 		private readonly _afterShowOutput: () => Promise<void>,
+		private readonly _activeSessionReader: ActiveSessionMcpServerReader,
 		@IAICustomizationWorkspaceService private readonly workspaceService: IAICustomizationWorkspaceService,
 		@IAgentPluginService private readonly agentPluginService: IAgentPluginService,
 		@IHoverService private readonly hoverService: IHoverService,
@@ -234,7 +278,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 				templateData.description.textContent = '';
 				templateData.description.style.display = 'none';
 			}
-			this.updateKnownServerStatus(templateData, element);
+			this.bindRowState(templateData, element);
 
 			// Add hover with plugin provenance for plugin-sourced builtin items
 			const pluginUriStr = getPluginUriFromCollectionId(element.collectionId);
@@ -259,7 +303,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			templateData.name.textContent = formatDisplayName(element.server.name);
 			templateData.description.textContent = '';
 			templateData.description.style.display = 'none';
-			this.updateActiveSessionStatus(templateData, element);
+			this.bindRowState(templateData, element);
 			return;
 		}
 
@@ -280,56 +324,30 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			templateData.description.style.display = 'none';
 		}
 
-		if (element.activeSessionServer !== undefined) {
-			this.updateKnownServerStatus(templateData, element);
-		} else if (this.workspaceService.isSessionsWindow) {
-			this.updateKnownServerStatus(templateData, element);
-		} else {
-			templateData.elementDisposables.add(autorun(reader => {
-				const disabled = element.localServer ? isContributionDisabled(element.localServer.enablement.read(reader)) : false;
-				const connectionState = element.localServer?.connectionState.read(reader);
-				templateData.container.classList.toggle('disabled', disabled);
-				this.updateStatus(templateData, element, disabled ? 'disabled' : connectionState?.state);
-			}));
-		}
+		this.bindRowState(templateData, element);
 	}
 
-	private updateKnownServerStatus(templateData: IMcpServerItemTemplateData, element: IMcpServerItemEntry | IMcpBuiltinItemEntry): void {
-		let localDisabled = false;
-		const update = () => {
-			const activeSessionServer = element.activeSessionServer === undefined
-				? undefined
-				: this.agentHostCustomizationService.getMcpServers(this.customizationHarnessService.activeSessionResource.get()).find(server => server.id === element.activeSessionServer?.id) ?? element.activeSessionServer;
-			if (activeSessionServer !== undefined) {
-				const presentation = getActiveSessionServerPresentation(activeSessionServer);
-				templateData.container.classList.toggle('disabled', !presentation.enabled);
-				this.updateStatus(templateData, element, presentation.status, presentation.enabled ? undefined : activeSessionServer.disabledReason);
-				return;
-			}
-			templateData.container.classList.toggle('disabled', localDisabled);
-			this.updateStatus(templateData, element, localDisabled ? 'disabled' : undefined);
-		};
+	/**
+	 * Drives a row from one resolver, for every kind of row.
+	 *
+	 * There were three paths here: two that shared `updateKnownServerStatus` and a third that
+	 * computed the same answer inline. They agreed only by coincidence, and this is the same
+	 * file whose history says copies of a status rule had already drifted apart.
+	 */
+	private bindRowState(templateData: IMcpServerItemTemplateData, element: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry): void {
 		templateData.elementDisposables.add(autorun(reader => {
-			localDisabled = element.localServer ? isContributionDisabled(element.localServer.enablement.read(reader)) : false;
-			update();
+			const rowState = resolveMcpRowState(element, this._activeSessionReader, this.workspaceService.isSessionsWindow, reader);
+			templateData.container.classList.toggle('disabled', rowState.status === 'disabled');
+			this.updateStatus(templateData, element, rowState);
 		}));
-		templateData.elementDisposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(update));
 	}
 
-	private updateActiveSessionStatus(templateData: IMcpServerItemTemplateData, element: IMcpSessionServerItemEntry): void {
-		const update = () => {
-			const server = this.agentHostCustomizationService.getMcpServers(this.customizationHarnessService.activeSessionResource.get()).find(server => server.id === element.server.id);
-			const presentation = server && getActiveSessionServerPresentation(server);
-			templateData.container.classList.toggle('disabled', presentation?.enabled === false);
-			this.updateStatus(templateData, element, presentation?.status, server?.disabledReason);
-		};
-		update();
-		templateData.elementDisposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(update));
-	}
-
-	private updateStatus(templateData: IMcpServerItemTemplateData, element: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry, state: McpStatusKind | undefined, disabledReason?: CustomizationDisabledReason): void {
-		const presentation = getMcpStatusPresentation(state, disabledReason);
-		const activeSessionServer = getActiveSessionServer(element);
+	private updateStatus(templateData: IMcpServerItemTemplateData, element: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry, rowState: IMcpRowState): void {
+		const state = rowState.status;
+		const presentation = getMcpStatusPresentation(state, rowState.disabledReason);
+		// The live agent-host view rather than the entry's snapshot, so the sign-in and output
+		// actions are bound to the server as it is now.
+		const activeSessionServer = rowState.activeSessionServer;
 		const label = getMcpEntryLabel(element);
 		const activeSessionResource = this.customizationHarnessService.activeSessionResource.get();
 		const localServer = element.type === 'session-server-item' ? undefined : element.localServer;
@@ -559,45 +577,70 @@ function getMcpEntryLabel(element: IMcpServerItemEntry | IMcpSessionServerItemEn
 			: element.server.label;
 }
 
-function getMcpStatusKind(entry: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry, isSessionsWindow: boolean): McpStatusKind | undefined {
-	if (entry.type === 'session-server-item') {
-		return getActiveSessionServerPresentation(entry.server).status;
+/**
+ * The single answer to "what is this row's state right now".
+ *
+ * Every surface that describes a row -- the rendered status, its accessible name, and the switch
+ * -- reads through here, so they cannot disagree about the same server. When an agent host has a
+ * view of a server it wins: the agent is the one actually running it, and it is also the only
+ * layer that knows a server is held off by the plugin that owns it.
+ */
+function resolveMcpRowState(
+	entry: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry,
+	activeSessionReader: ActiveSessionMcpServerReader,
+	isSessionsWindow: boolean,
+	reader: IReader | undefined,
+): IMcpRowState {
+	const activeSessionServer = activeSessionReader.read(getActiveSessionServer(entry), reader);
+	if (activeSessionServer !== undefined) {
+		const presentation = getActiveSessionServerPresentation(activeSessionServer);
+		return {
+			status: presentation.status,
+			disabledReason: presentation.enabled ? undefined : activeSessionServer.disabledReason,
+			activeSessionServer,
+		};
 	}
-	if (entry.activeSessionServer !== undefined) {
-		return getActiveSessionServerPresentation(entry.activeSessionServer).status;
+
+	if (entry.type === 'session-server-item') {
+		return { status: undefined };
 	}
-	if (entry.localServer && isContributionDisabled(entry.localServer.enablement.get())) {
-		return 'disabled';
+
+	if (entry.localServer && isContributionDisabled(entry.localServer.enablement.read(reader))) {
+		return { status: 'disabled' };
 	}
+
+	// Only a plain local row reports its connection state. A built-in row has never shown it, and
+	// in the Agents window the local runtime is not what governs whether a server is working.
 	if (entry.type === 'server-item' && !isSessionsWindow) {
-		return entry.localServer?.connectionState.get().state;
+		return { status: entry.localServer?.connectionState.read(reader).state };
 	}
-	return undefined;
+	return { status: undefined };
+}
+
+/**
+ * The accessible name for a row, as an observable.
+ *
+ * It has to be observable because a row's status changes without the list being spliced: the
+ * visible status is driven by an autorun over the runtime's observables and the agent host's
+ * change signal, and nothing re-renders the row around it. A plain string would be computed once
+ * and then quietly describe the past.
+ */
+function observeMcpEntryAriaLabel(element: IMcpListEntry, activeSessionReader: ActiveSessionMcpServerReader, isSessionsWindow: boolean): IObservable<string> {
+	return derived(reader => getMcpEntryAriaLabel(element, activeSessionReader, isSessionsWindow, reader));
 }
 
-function getMcpEntryAriaLabel(element: IMcpListEntry, isSessionsWindow: boolean): string {
+function getMcpEntryAriaLabel(element: IMcpListEntry, activeSessionReader: ActiveSessionMcpServerReader, isSessionsWindow: boolean, reader: IReader | undefined): string {
 	if (element.type === 'group-header') {
 		return localize('mcpGroupAriaLabel', "{0}, {1} items, {2}", element.label, element.count, element.collapsed ? localize('collapsed', "collapsed") : localize('expanded', "expanded"));
 	}
 	const label = getMcpEntryLabel(element);
-	const statusKind = getMcpStatusKind(element, isSessionsWindow);
-	const disabledReason = statusKind === 'disabled' ? getMcpDisabledReason(element) : undefined;
-	const status = getMcpStatusPresentation(statusKind, disabledReason);
+	const rowState = resolveMcpRowState(element, activeSessionReader, isSessionsWindow, reader);
+	const status = getMcpStatusPresentation(rowState.status, rowState.disabledReason);
 	return status
 		? localize('mcpServerAriaLabelWithStatus', "{0}, {1}", label, status.label)
 		: label;
 }
 
-function getMcpDisabledReason(entry: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry): CustomizationDisabledReason | undefined {
-	if (entry.type === 'session-server-item') {
-		return entry.server.disabledReason;
-	}
-	if (entry.activeSessionServer !== undefined) {
-		return entry.activeSessionServer.disabledReason;
-	}
-	return undefined;
-}
-
 function normalizeMcpMatchKey(value: string | undefined): string | undefined {
 	return value || undefined;
 }
@@ -1170,7 +1213,10 @@ export class McpListWidget extends Disposable {
 		// Create list
 		const delegate = new McpServerItemDelegate();
 		const groupHeaderRenderer = new CustomizationGroupHeaderRenderer<IMcpGroupHeaderEntry>('mcpGroupHeader', this.hoverService);
-		const localRenderer = this.instantiationService.createInstance(McpServerItemRenderer, () => this._closeCustomizationEditor());
+		// Shared by the rows and their accessible names, so both observe the same agent-host
+		// state through the same signal rather than each installing their own listener.
+		const activeSessionReader = new ActiveSessionMcpServerReader(this.agentHostCustomizationService, this.customizationHarnessService);
+		const localRenderer = this.instantiationService.createInstance(McpServerItemRenderer, () => this._closeCustomizationEditor(), activeSessionReader);
 		const galleryRenderer = new GalleryItemRenderer<IMcpServerItemEntry>(MCP_GALLERY_ITEM_TEMPLATE_ID, new McpGalleryItemProvider(this.mcpWorkbenchService));
 
 		this.list = this._register(this.instantiationService.createInstance(
@@ -1185,7 +1231,7 @@ export class McpListWidget extends Disposable {
 				horizontalScrolling: false,
 				accessibilityProvider: {
 					getAriaLabel: (element: IMcpListEntry) => {
-						return getMcpEntryAriaLabel(element, this.workspaceService.isSessionsWindow);
+						return observeMcpEntryAriaLabel(element, activeSessionReader, this.workspaceService.isSessionsWindow);
 					},
 					getWidgetAriaLabel() {
 						return localize('mcpServersListAriaLabel', "MCP Servers");

From 7157014737008c9b3c2f5e6d71fc05ed3f0e03a3 Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 18:48:06 +0200
Subject: [PATCH 08/13] mcp: feat: say a server's status in words next to its
 name

Status was a bare coloured icon in the far-right actions slot, and
getMcpStatusPresentation returned no icon for Stopped while the render
path bailed out on a missing one -- so the most common state in the list
drew zero pixels, and the states that did draw asked the user to infer a
meaning from a colour.

It is now a word beside the name, where the eye already is when reading
which server a row is, with a dot alongside so the distinction is never
carried by colour alone. Running and Idle are left unsaid: MCP servers
start lazily, so whether one holds a process right now is an
implementation detail that flickers and that nobody acts on.

Failing rows get an explicit 'Show Output' button rather than a coloured
icon that was both the only sign a row had failed and the only way to
read why.

Wording follows: 'Idle' rather than 'Stopped' for a resting state,
'Failed' rather than 'Error' because a row reports what happened rather
than being an error itself, and 'Sign-in needed' in the same words as the
button beside it.

A locally disabled row now reports its scope through the same
getCustomizationDisabledLabel path the agent-host rows use, so
'Disabled (Workspace)' cannot be worded two ways.

statusIconId leaves IMcpStatusRenderInput with the icon it described.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../browser/aiCustomization/mcpListWidget.ts  | 108 +++++++++++++-----
 .../media/aiCustomizationManagement.css       |  83 ++++++++++----
 .../aiCustomization/mcpListWidget.test.ts     |  42 ++++++-
 3 files changed, 178 insertions(+), 55 deletions(-)

diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
index ad8e6a221c1f4c..db7ffa5baf8599 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
@@ -22,7 +22,7 @@ import { IMcpWorkbenchService, IWorkbenchMcpServer, McpConnectionState, McpServe
 import { IMcpRegistry } from '../../../mcp/common/mcpRegistryTypes.js';
 import { MCP_PLUGIN_COLLECTION_ID_PREFIX } from '../../../mcp/common/discovery/pluginMcpDiscovery.js';
 import { ExtensionIdentifier } from '../../../../../platform/extensions/common/extensions.js';
-import { ContributionEnablementState, isContributionDisabled } from '../../common/enablement.js';
+import { ContributionEnablementState, isContributionDisabled, isWorkspaceScopedEnablement } from '../../common/enablement.js';
 import { McpCommandIds } from '../../../../contrib/mcp/common/mcpCommandIds.js';
 import { autorun, derived, observableSignalFromEvent, type IObservable, type IReader } from '../../../../../base/common/observable.js';
 import { IOpenerService } from '../../../../../platform/opener/common/opener.js';
@@ -201,6 +201,8 @@ interface IMcpServerItemTemplateData {
 	readonly container: HTMLElement;
 	readonly typeIcon: HTMLElement;
 	readonly name: HTMLElement;
+	/** Status word and dot, next to the name so state reads as part of the server's identity. */
+	readonly status: HTMLElement;
 	readonly description: HTMLElement;
 	readonly actions: HTMLElement;
 	readonly elementDisposables: DisposableStore;
@@ -237,6 +239,9 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 		const details = DOM.append(container, $('.mcp-server-details'));
 		const nameRow = DOM.append(details, $('.mcp-server-name-row'));
 		const name = DOM.append(nameRow, $('.mcp-server-name'));
+		// Status sits next to the name rather than in the far-right actions slot: it describes the
+		// server, so it belongs where the eye already is when reading which server this is.
+		const status = DOM.append(nameRow, $('.mcp-server-status'));
 
 		const description = DOM.append(details, $('.mcp-server-description'));
 
@@ -246,6 +251,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			container,
 			typeIcon,
 			name,
+			status,
 			description,
 			actions,
 			elementDisposables: new DisposableStore(),
@@ -362,7 +368,6 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			state,
 			statusLabel: presentation?.label,
 			statusClassName: presentation?.className,
-			statusIconId: presentation?.icon?.id,
 			activeSessionServerId: activeSessionServer?.id,
 			logOutputChannelId: activeSessionServer?.logOutputChannelId,
 			localServerId: localServer?.definition.id,
@@ -375,6 +380,18 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 
 		templateData.actionDisposables.clear();
 		DOM.clearNode(templateData.actions);
+		DOM.clearNode(templateData.status);
+		templateData.status.className = 'mcp-server-status';
+
+		// Status reads as a word beside the name, including the states that used to resolve to an
+		// icon-less presentation and therefore drew nothing at all -- which was every idle server,
+		// the most common row in the list.
+		if (presentation && isNoteworthyMcpStatus(state)) {
+			templateData.status.classList.add(presentation.className);
+			// A dot as well as the word: colour alone is not a distinction everyone can make.
+			DOM.append(templateData.status, $('.mcp-server-status-dot'));
+			DOM.append(templateData.status, $('.mcp-server-status-label')).textContent = presentation.label;
+		}
 
 		if (!presentation) {
 			return;
@@ -393,7 +410,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 				ariaLabel: signInLabel,
 			}));
 			signInButton.label = localize('signIn', "Sign In");
-			signInButton.element.classList.add('mcp-server-sign-in');
+			signInButton.element.classList.add('mcp-server-inline-button', 'mcp-server-sign-in');
 			registerMcpInlineButtonAction(templateData.actionDisposables, signInButton, async () => {
 				signInButton.enabled = false;
 				try {
@@ -404,29 +421,25 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			});
 		}
 
-		if (!presentation.icon) {
-			return;
-		}
-
+		// An explicit, labelled action now that the status is a word: the coloured icon-button it
+		// replaces was the only thing saying a row had failed *and* the only way to read why, so
+		// its meaning had to be guessed from its colour.
 		const showOutput = state === McpServerStatus.Error || state === McpConnectionState.Kind.Error
 			? getMcpServerOutputHandler(this.outputService, localServer, activeSessionServer, this._afterShowOutput, showActiveSessionOutput)
 			: undefined;
 		if (showOutput) {
 			const showOutputLabel = localize('showMcpServerOutput', "Show output for {0}", label);
-			const statusButton = templateData.actionDisposables.add(new Button(templateData.actions, {
+			const outputButton = templateData.actionDisposables.add(new Button(templateData.actions, {
+				...defaultButtonStyles,
+				secondary: true,
+				small: true,
 				title: showOutputLabel,
 				ariaLabel: showOutputLabel,
 			}));
-			statusButton.icon = presentation.icon;
-			statusButton.element.classList.add('mcp-server-status', 'mcp-server-status-action', presentation.className);
-			registerMcpInlineButtonAction(templateData.actionDisposables, statusButton, showOutput);
-			return;
+			outputButton.label = localize('showOutput', "Show Output");
+			outputButton.element.classList.add('mcp-server-inline-button');
+			registerMcpInlineButtonAction(templateData.actionDisposables, outputButton, showOutput);
 		}
-
-		const statusElement = DOM.append(templateData.actions, $('.mcp-server-status'));
-		statusElement.classList.add(presentation.className, ...ThemeIcon.asClassNameArray(presentation.icon));
-		statusElement.setAttribute('aria-hidden', 'true');
-		templateData.actionDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('element'), statusElement, presentation.label));
 	}
 
 	disposeTemplate(templateData: IMcpServerItemTemplateData): void {
@@ -473,7 +486,6 @@ export function getMcpServerOutputHandler(outputService: Pick<IOutputService, 's
 export interface IMcpStatusPresentation {
 	readonly label: string;
 	readonly className: string;
-	readonly icon?: ThemeIcon;
 }
 
 export function getMcpStatusPresentation(state: McpStatusKind | undefined, disabledReason?: CustomizationDisabledReason): IMcpStatusPresentation | undefined {
@@ -481,24 +493,51 @@ export function getMcpStatusPresentation(state: McpStatusKind | undefined, disab
 		return undefined;
 	}
 	if (state === 'disabled') {
-		return { label: getCustomizationDisabledLabel(disabledReason), className: 'disabled', icon: Codicon.circleSlash };
+		return { label: getCustomizationDisabledLabel(disabledReason), className: 'disabled' };
 	}
 	switch (state) {
 		case McpConnectionState.Kind.Running:
 		case McpServerStatus.Ready:
-			return { label: localize('running', "Running"), className: 'running', icon: Codicon.check };
+			return { label: localize('running', "Running"), className: 'running' };
 		case McpConnectionState.Kind.Starting:
 		case McpServerStatus.Starting:
-			return { label: localize('starting', "Starting"), className: 'starting', icon: ThemeIcon.modify(Codicon.loading, 'spin') };
+			return { label: localize('starting', "Starting"), className: 'starting' };
 		case McpServerStatus.AuthRequired:
-			return { label: localize('authRequired', "Authentication required"), className: 'auth-required', icon: Codicon.account };
+			// "Sign-in needed" rather than "Authentication required": it is the same fact in the
+			// words the button beside it uses, and it fits a row.
+			return { label: localize('authRequired', "Sign-in needed"), className: 'auth-required' };
 		case McpConnectionState.Kind.Error:
 		case McpServerStatus.Error:
-			return { label: localize('error', "Error"), className: 'error', icon: Codicon.error };
+			// "Failed" rather than "Error": a row says what happened to the server, and the row
+			// is not itself an error message.
+			return { label: localize('error', "Failed"), className: 'error' };
+		case McpConnectionState.Kind.Stopped:
+		case McpServerStatus.Stopped:
+		default:
+			// "Idle" rather than "Stopped": MCP servers start lazily, so not holding a process is
+			// the resting state, not something that went wrong.
+			return { label: localize('stopped', "Idle"), className: 'stopped' };
+	}
+}
+
+/**
+ * Whether a status is worth saying at all.
+ *
+ * Running and Idle are lifecycle, not news. VS Code starts MCP servers lazily -- a server launches
+ * when a tool call needs it and shuts down afterwards -- so whether a process happens to be alive
+ * right now is an implementation detail that flickers and that nobody acts on. Printing it made the
+ * most common word in the list also the least informative one.
+ */
+export function isNoteworthyMcpStatus(state: McpStatusKind | undefined): boolean {
+	switch (state) {
+		case undefined:
+		case McpConnectionState.Kind.Running:
+		case McpServerStatus.Ready:
 		case McpConnectionState.Kind.Stopped:
 		case McpServerStatus.Stopped:
+			return false;
 		default:
-			return { label: localize('stopped', "Stopped"), className: 'stopped' };
+			return true;
 	}
 }
 
@@ -531,7 +570,6 @@ export interface IMcpStatusRenderInput {
 	readonly state: McpStatusKind | undefined;
 	readonly statusLabel: string | undefined;
 	readonly statusClassName: string | undefined;
-	readonly statusIconId: string | undefined;
 	/** The active-session twin the sign-in and output actions are bound to. */
 	readonly activeSessionServerId: string | undefined;
 	readonly logOutputChannelId: string | undefined;
@@ -561,7 +599,6 @@ export function getMcpStatusRenderSignature(input: IMcpStatusRenderInput): strin
 		input.state ?? null,
 		input.statusLabel ?? null,
 		input.statusClassName ?? null,
-		input.statusIconId ?? null,
 		input.activeSessionServerId ?? null,
 		input.logOutputChannelId ?? null,
 		input.localServerId ?? null,
@@ -605,8 +642,19 @@ function resolveMcpRowState(
 		return { status: undefined };
 	}
 
-	if (entry.localServer && isContributionDisabled(entry.localServer.enablement.read(reader))) {
-		return { status: 'disabled' };
+	if (entry.localServer) {
+		const enablement = entry.localServer.enablement.read(reader);
+		if (isContributionDisabled(enablement)) {
+			// Described as a scope reason so the wording comes from the same helper the agent-host
+			// rows use. A workspace choice is worth naming; "off everywhere" is just off.
+			return {
+				status: 'disabled',
+				disabledReason: {
+					source: 'scope',
+					scope: isWorkspaceScopedEnablement(enablement) ? CustomizationEnablementKind.Workspace : CustomizationEnablementKind.Global,
+				},
+			};
+		}
 	}
 
 	// Only a plain local row reports its connection state. A built-in row has never shown it, and
@@ -635,7 +683,9 @@ function getMcpEntryAriaLabel(element: IMcpListEntry, activeSessionReader: Activ
 	}
 	const label = getMcpEntryLabel(element);
 	const rowState = resolveMcpRowState(element, activeSessionReader, isSessionsWindow, reader);
-	const status = getMcpStatusPresentation(rowState.status, rowState.disabledReason);
+	// Deliberately looser than the row: a screen reader reads the row label on its own, so a
+	// status the row can leave to a neighbouring control is still new information here.
+	const status = isNoteworthyMcpStatus(rowState.status) ? getMcpStatusPresentation(rowState.status, rowState.disabledReason) : undefined;
 	return status
 		? localize('mcpServerAriaLabelWithStatus', "{0}, {1}", label, status.label)
 		: label;
diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
index d6fac16504fa82..d941f3db95c195 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
@@ -612,11 +612,14 @@ casing is also not a transform that survives translation. */
 	margin-right: 4px;
 }
 
-/* MCP bridged badge — shown inline next to the server name */
+/* Name and status share a line so state reads as part of the server's identity. */
 .mcp-server-item .mcp-server-name-row {
 	display: flex;
+	/* Center, not baseline: the status dot is an empty box, so baseline alignment would anchor to
+	its bottom edge and drop the status word below the name. */
 	align-items: center;
 	gap: 6px;
+	min-width: 0;
 }
 
 .ai-customization-list-item .item-type-icon {
@@ -1737,6 +1740,17 @@ casing is also not a transform that survives translation. */
 	line-height: 18px;
 }
 
+/* Scoped to the name row so the plugin list, which reuses `.mcp-server-name` as a flex container
+for its own name and badge, is not dragged into this sizing. */
+.mcp-server-item .mcp-server-name-row .mcp-server-name {
+	/* Sized to its text, and the first thing to shrink, so the status stays pinned to the name
+	instead of drifting away from short names or being pushed off by long ones. It keeps a floor,
+	though: the name is what the row is *for*, and without one a narrow pane spent its width on
+	the qualifier -- "Web S... - Disabled (Workspace)". Identity does not yield to its own note. */
+	flex: 0 1 auto;
+	min-width: 7em;
+}
+
 .mcp-server-item .mcp-server-description {
 	font-size: var(--vscode-agents-fontSize-body2);
 	color: var(--vscode-descriptionForeground);
@@ -1762,50 +1776,73 @@ casing is also not a transform that survives translation. */
 }
 
 .mcp-server-item .mcp-server-status {
-	flex-shrink: 0;
-	width: var(--vscode-spacing-size240);
-	height: var(--vscode-spacing-size240);
+	min-width: 0;
+	overflow: hidden;
+	flex: 0 1 auto;
 	display: flex;
 	align-items: center;
-	justify-content: center;
-	font-size: var(--vscode-codiconFontSize);
+	gap: var(--vscode-spacing-size40);
+	font-size: var(--vscode-agents-fontSize-label2);
+	color: var(--vscode-descriptionForeground);
+	white-space: nowrap;
 }
 
-.mcp-server-item .mcp-server-status-action.monaco-button {
-	min-width: var(--vscode-spacing-size240);
-	min-height: var(--vscode-spacing-size240);
-	padding: var(--vscode-spacing-size40);
-	border: 0;
-	border-radius: var(--vscode-cornerRadius-small);
-	background-color: transparent;
+.mcp-server-item .mcp-server-status-label {
+	overflow: hidden;
+	text-overflow: ellipsis;
 }
 
-.mcp-server-item .mcp-server-status-action.monaco-button:hover {
-	background-color: var(--vscode-toolbar-hoverBackground);
+.mcp-server-item .mcp-server-status:empty {
+	display: none;
+}
+
+.mcp-server-item .mcp-server-status-dot {
+	/* The dot is the redundancy that keeps status from being colour-only, so it is the one part
+	of the status that must never be squeezed away. */
+	flex: 0 0 auto;
+	width: var(--vscode-spacing-size40);
+	height: var(--vscode-spacing-size40);
+	border-radius: var(--vscode-cornerRadius-circle);
+	background-color: currentColor;
+}
+
+.mcp-server-item .mcp-server-inline-button.monaco-button {
+	min-width: 0;
+	min-height: var(--vscode-spacing-size240);
+	padding: 0 var(--vscode-spacing-size80);
+	font-size: var(--vscode-agents-fontSize-label1);
+	border-radius: var(--vscode-cornerRadius-small);
+	white-space: nowrap;
 }
 
-.mcp-server-item .mcp-server-status.running {
+/* Status colour is shared by the list row and the detail pane so the two can never disagree
+about what "Running" looks like. Layout stays scoped to each surface. */
+.mcp-server-status.running {
 	color: var(--vscode-charts-green);
 }
 
-.mcp-server-item .mcp-server-status.starting {
+.mcp-server-status.starting {
 	color: var(--vscode-progressBar-background, var(--vscode-icon-foreground));
 }
 
-.mcp-server-item .mcp-server-status.auth-required {
+.mcp-server-status.auth-required {
 	color: var(--vscode-list-warningForeground, var(--vscode-editorWarning-foreground));
 }
 
-.mcp-server-item .mcp-server-status.error {
+.mcp-server-status.error {
 	color: var(--vscode-testing-iconFailed, var(--vscode-errorForeground));
 }
 
-.mcp-server-item.disabled {
-	opacity: 0.5;
+.mcp-server-status.stopped,
+.mcp-server-status.disabled {
+	color: var(--vscode-descriptionForeground);
 }
 
-.mcp-server-item .mcp-server-status.disabled {
-	color: var(--vscode-disabledForeground);
+/* Only the name dims when a server is off. Status and errors must stay readable -- they are the
+reason the user is looking at the row. */
+.mcp-server-item.disabled .mcp-server-name,
+.mcp-server-item.disabled .mcp-server-description {
+	opacity: 0.6;
 }
 
 /* On/off switch
diff --git a/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts b/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
index 429f9df7f9bb8c..ff9e8246e94b76 100644
--- a/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
+++ b/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
@@ -15,7 +15,7 @@ import { ContributionEnablementState } from '../../../common/enablement.js';
 import { ICommandService } from '../../../../../../platform/commands/common/commands.js';
 import { IAgentHostCustomizationService } from '../../../browser/agentSessions/agentHost/agentHostCustomizationService.js';
 import { IAgentPluginService } from '../../../common/plugins/agentPluginService.js';
-import { IMcpService } from '../../../../mcp/common/mcpTypes.js';
+import { IMcpService, McpConnectionState } from '../../../../mcp/common/mcpTypes.js';
 import { DisableMcpServerForWorkspaceAction, DisableMcpServerGloballyAction, EnableMcpServerForWorkspaceAction, EnableMcpServerGloballyAction } from '../../../../mcp/browser/mcpServerActions.js';
 import {
 	AgentHostMcpServer,
@@ -30,6 +30,7 @@ import {
 	getMcpServerOutputHandler,
 	getMcpStatusPresentation,
 	getMcpStatusRenderSignature,
+	isNoteworthyMcpStatus,
 	getServerItemContextMenuActions,
 	registerMcpInlineButtonAction,
 	type IMcpStatusRenderInput,
@@ -123,6 +124,43 @@ suite('mcpListWidget', () => {
 		]);
 	});
 
+	suite('isNoteworthyMcpStatus', () => {
+
+		test('lifecycle is not news, but anything needing attention is', () => {
+			assert.deepStrictEqual([
+				undefined,
+				McpServerStatus.Ready,
+				McpConnectionState.Kind.Running,
+				McpServerStatus.Stopped,
+				McpConnectionState.Kind.Stopped,
+				McpServerStatus.Starting,
+				McpServerStatus.AuthRequired,
+				McpServerStatus.Error,
+				McpConnectionState.Kind.Error,
+				'disabled' as const,
+			].map(isNoteworthyMcpStatus), [
+				false, false, false, false, false,
+				true, true, true, true, true,
+			]);
+		});
+
+		test('names a state for every status a row can be in', () => {
+			assert.deepStrictEqual([
+				getMcpStatusPresentation(McpServerStatus.Stopped)?.label,
+				getMcpStatusPresentation(McpServerStatus.Starting)?.label,
+				getMcpStatusPresentation(McpServerStatus.AuthRequired)?.label,
+				getMcpStatusPresentation(McpServerStatus.Error)?.label,
+				getMcpStatusPresentation(undefined)?.label,
+			], [
+				'Idle',
+				'Starting',
+				'Sign-in needed',
+				'Failed',
+				undefined,
+			]);
+		});
+	});
+
 	test('uses the current active-session server enablement for rows and lifecycle actions', () => {
 		const disabledServer = createAgentHostServer({ enabled: false });
 		const enabledServer = createAgentHostServer({ enabled: true });
@@ -517,7 +555,6 @@ suite('mcpListWidget', () => {
 			state: McpServerStatus.Error,
 			statusLabel: 'Error',
 			statusClassName: 'error',
-			statusIconId: 'error',
 			activeSessionServerId: 'session-1/notion',
 			logOutputChannelId: 'mcp.session-1.notion',
 			localServerId: 'mcp.config.workspace/notion',
@@ -533,7 +570,6 @@ suite('mcpListWidget', () => {
 			state: McpServerStatus.Ready,
 			statusLabel: 'Running',
 			statusClassName: 'running',
-			statusIconId: 'check',
 			activeSessionServerId: 'session-1/other',
 			logOutputChannelId: 'mcp.session-1.other',
 			localServerId: 'mcp.config.user/notion',

From bd89a6854030ba96d562da44d6f9fd7a430e1e2d Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 21:43:30 +0200
Subject: [PATCH 09/13] mcp: feat: give every installed MCP row an on/off
 switch

Turning a server off was reachable only through a right-click menu, so
the most common thing someone wants to do with a server was also the
least discoverable. Every row that has an enablement to write now carries
one switch, in the same place, so it is a single predictable target.

The switch writes the layer that already decides the row, falling back to
Global when nothing decides it yet. Replacing the decisive kind is what
actually moves the effective state, and it answers a deliberate workspace
or session choice where it was made rather than silently promoting it. An
unqualified control means the whole durable answer, so a first 'off' is
off everywhere; narrower scopes stay explicit, in the context menu.
Deliberately not IAgentHostMcpServer.setEnabled, which only ever writes
the session layer.

Rows held off by two layers align both, because a switch that leaves a
server visibly off after being turned on is a broken switch. Both sides
read live rather than through values captured at render: the render guard
cannot cover every decision in an enablement array, and writing back a
stale one would resurrect a scope the user had since changed.

Two rows get no switch. A gallery result has nothing installed to turn
on. And a server held off by the plugin that owns it cannot be freed by
writing its own enablement at all, so it keeps the word
'Disabled (Plugin)' and the context menu's 'Enable {plugin}' instead of a
control that would appear to do nothing.

Enablement is keyed by the workbench server's own id -- the key
EnableMcpServerGloballyAction already uses -- rather than the matched
runtime server's definition id. The runtime match is deliberately
conservative and declines whenever two servers answer to one name, and a
row must not lose its switch, or misreport its status, because of an
ambiguity in a lookup it never needed.

The row no longer prints a bare 'Disabled' beside an off switch, which
was the same fact twice. A qualified reason still shows, because it says
where the choice lives and the switch cannot express that. The accessible
name deliberately keeps saying it: a screen reader reads the row label
without the switch beside it.

The fixtures gain a working enablement model. The stub they had returned
nothing, which rendered every server as off -- and failed silently, since
the read happens inside an autorun.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../browser/aiCustomization/mcpListWidget.ts  | 234 +++++++++++++++++-
 .../media/aiCustomizationManagement.css       |  13 +
 .../aiCustomization/mcpListWidget.test.ts     | 141 +++++++++++
 ...aiCustomizationManagementEditor.fixture.ts |  36 ++-
 4 files changed, 410 insertions(+), 14 deletions(-)

diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
index db7ffa5baf8599..cfe9e78ce2e414 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
@@ -22,7 +22,7 @@ import { IMcpWorkbenchService, IWorkbenchMcpServer, McpConnectionState, McpServe
 import { IMcpRegistry } from '../../../mcp/common/mcpRegistryTypes.js';
 import { MCP_PLUGIN_COLLECTION_ID_PREFIX } from '../../../mcp/common/discovery/pluginMcpDiscovery.js';
 import { ExtensionIdentifier } from '../../../../../platform/extensions/common/extensions.js';
-import { ContributionEnablementState, isContributionDisabled, isWorkspaceScopedEnablement } from '../../common/enablement.js';
+import { ContributionEnablementState, IEnablementModel, isContributionDisabled, isContributionEnabled, isWorkspaceScopedEnablement, withContributionEnabled } from '../../common/enablement.js';
 import { McpCommandIds } from '../../../../contrib/mcp/common/mcpCommandIds.js';
 import { autorun, derived, observableSignalFromEvent, type IObservable, type IReader } from '../../../../../base/common/observable.js';
 import { IOpenerService } from '../../../../../platform/opener/common/opener.js';
@@ -48,8 +48,9 @@ import { IAgentHostCustomizationService } from '../agentSessions/agentHost/agent
 import { CustomizationEnablementKind, McpServerStatus } from '../../../../../platform/agentHost/common/state/protocol/state.js';
 import { GalleryItemInstallState, GalleryItemRenderer, IGalleryItemProvider } from './galleryItemRenderer.js';
 import { IOutputService } from '../../../../services/output/common/output.js';
-import { getCustomizationScopeEnablement, type CustomizationDisabledReason } from '../../../../../platform/agentHost/common/customizationEnablement.js';
+import { getCustomizationEnablementDecision, getCustomizationScopeEnablement, type CustomizationDisabledReason } from '../../../../../platform/agentHost/common/customizationEnablement.js';
 import { createAgentHostEnablePluginAction } from '../agentPluginActions.js';
+import { EnablementSwitch } from './enablementSwitch.js';
 
 const $ = DOM.$;
 
@@ -204,7 +205,14 @@ interface IMcpServerItemTemplateData {
 	/** Status word and dot, next to the name so state reads as part of the server's identity. */
 	readonly status: HTMLElement;
 	readonly description: HTMLElement;
+	/** Holds everything in the trailing slot that is rebuilt on every status change. */
 	readonly actions: HTMLElement;
+	/**
+	 * Built once and reused for the life of the template. Rebuilding it per status change would
+	 * remove the element a keyboard user is standing on: toggling notifies synchronously, which
+	 * re-runs the status autorun, which would tear the focused button out of the document.
+	 */
+	readonly enablementSwitch: EnablementSwitch;
 	readonly elementDisposables: DisposableStore;
 	readonly actionDisposables: DisposableStore;
 	/** Which row the actions currently belong to, so a recycled template cannot reuse another row's. */
@@ -228,6 +236,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 		@IAgentHostCustomizationService private readonly agentHostCustomizationService: IAgentHostCustomizationService,
 		@ICustomizationHarnessService private readonly customizationHarnessService: ICustomizationHarnessService,
 		@IOutputService private readonly outputService: IOutputService,
+		@IMcpService private readonly mcpService: IMcpService,
 	) { }
 
 	renderTemplate(container: HTMLElement): IMcpServerItemTemplateData {
@@ -245,7 +254,9 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 
 		const description = DOM.append(details, $('.mcp-server-description'));
 
-		const actions = DOM.append(container, $('.mcp-server-actions'));
+		const actionsSlot = DOM.append(container, $('.mcp-server-actions'));
+		const actions = DOM.append(actionsSlot, $('.mcp-server-actions-transient'));
+		const enablementSwitch = new EnablementSwitch(actionsSlot);
 
 		return {
 			container,
@@ -254,6 +265,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			status,
 			description,
 			actions,
+			enablementSwitch,
 			elementDisposables: new DisposableStore(),
 			actionDisposables: new DisposableStore(),
 		};
@@ -342,7 +354,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 	 */
 	private bindRowState(templateData: IMcpServerItemTemplateData, element: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry): void {
 		templateData.elementDisposables.add(autorun(reader => {
-			const rowState = resolveMcpRowState(element, this._activeSessionReader, this.workspaceService.isSessionsWindow, reader);
+			const rowState = resolveMcpRowState(element, this._activeSessionReader, this.mcpService.enablementModel, this.workspaceService.isSessionsWindow, reader);
 			templateData.container.classList.toggle('disabled', rowState.status === 'disabled');
 			this.updateStatus(templateData, element, rowState);
 		}));
@@ -358,6 +370,15 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 		const activeSessionResource = this.customizationHarnessService.activeSessionResource.get();
 		const localServer = element.type === 'session-server-item' ? undefined : element.localServer;
 
+		const enablementTarget = getEnablementTarget(
+			element,
+			rowState,
+			this.mcpService,
+			this.agentHostCustomizationService,
+			activeSessionResource,
+			snapshot => this._activeSessionReader.read(snapshot, undefined));
+		const switchChecked = enablementTarget?.isEnabled();
+
 		// This runs from an autorun over the server's connection state, and an erroring server
 		// re-runs it about twice a second with byte-identical content. Rebuilding regardless meant
 		// a node replaced between mousedown and mouseup never saw the click, so `Show Output` did
@@ -372,6 +393,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			logOutputChannelId: activeSessionServer?.logOutputChannelId,
 			localServerId: localServer?.definition.id,
 			activeSessionResource: activeSessionResource.toString(),
+			switchChecked,
 		});
 		if (templateData.renderedStatusSignature === signature) {
 			return;
@@ -383,10 +405,12 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 		DOM.clearNode(templateData.status);
 		templateData.status.className = 'mcp-server-status';
 
+		this.renderEnablementSwitch(templateData, enablementTarget, switchChecked, label);
+
 		// Status reads as a word beside the name, including the states that used to resolve to an
 		// icon-less presentation and therefore drew nothing at all -- which was every idle server,
 		// the most common row in the list.
-		if (presentation && isNoteworthyMcpStatus(state)) {
+		if (presentation && shouldShowStatusOnRow(state, rowState.disabledReason, switchChecked !== undefined)) {
 			templateData.status.classList.add(presentation.className);
 			// A dot as well as the word: colour alone is not a distinction everyone can make.
 			DOM.append(templateData.status, $('.mcp-server-status-dot'));
@@ -442,9 +466,35 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 		}
 	}
 
+	/**
+	 * Renders the on/off switch at the trailing edge of an installed row.
+	 *
+	 * It is the last thing in the row on purpose: every row that has one has it in the same place,
+	 * so turning a server off is a single predictable target rather than a right-click someone has
+	 * to guess at.
+	 */
+	private renderEnablementSwitch(templateData: IMcpServerItemTemplateData, target: IMcpEnablementTarget | undefined, checked: boolean | undefined, label: string): void {
+		const toggle = templateData.enablementSwitch;
+		toggle.setVisible(target !== undefined);
+		if (!target || checked === undefined) {
+			return;
+		}
+		// The accessible name is the server, not the act: `role="switch"` announces its own state
+		// from aria-checked, so an action phrase would read "Disable Redis, switch, on" -- a label
+		// arguing with the state beside it. The hover still names the act, because a pointer user
+		// has no announced state to go on.
+		toggle.update(checked, label);
+		templateData.actionDisposables.add(toggle.onDidToggle(() => target.setEnabled(!target.isEnabled())));
+		templateData.actionDisposables.add(this.hoverService.setupManagedHover(
+			getDefaultHoverDelegate('element'),
+			toggle.element,
+			getEnablementSwitchTooltip(label, checked)));
+	}
+
 	disposeTemplate(templateData: IMcpServerItemTemplateData): void {
 		templateData.elementDisposables.dispose();
 		templateData.actionDisposables.dispose();
+		templateData.enablementSwitch.dispose();
 	}
 }
 
@@ -577,6 +627,8 @@ export interface IMcpStatusRenderInput {
 	readonly localServerId: string | undefined;
 	/** Captured when the output action is built, so switching sessions has to rebuild it. */
 	readonly activeSessionResource: string | undefined;
+	/** The switch's rendered state: `undefined` when the row has no switch at all. */
+	readonly switchChecked: boolean | undefined;
 }
 
 /**
@@ -603,6 +655,7 @@ export function getMcpStatusRenderSignature(input: IMcpStatusRenderInput): strin
 		input.logOutputChannelId ?? null,
 		input.localServerId ?? null,
 		input.activeSessionResource ?? null,
+		input.switchChecked ?? null,
 	]);
 }
 
@@ -614,6 +667,157 @@ function getMcpEntryLabel(element: IMcpServerItemEntry | IMcpSessionServerItemEn
 			: element.server.label;
 }
 
+/** How a row's switch reads and writes its server's enablement. */
+export interface IMcpEnablementTarget {
+	isEnabled(): boolean;
+	setEnabled(enabled: boolean): void;
+}
+
+/**
+ * The scope an agent-host switch writes.
+ *
+ * The decisive decision is `enablement[0]`, so replacing that same kind is what actually moves the
+ * effective state -- and it answers a deliberate workspace or session choice where it was made
+ * rather than silently promoting it to something broader.
+ *
+ * With nothing deciding yet, an unqualified switch means the whole durable answer: off everywhere.
+ * Narrower scopes stay an explicit act, available from the context menu. Note this is deliberately
+ * *not* `IAgentHostMcpServer.setEnabled`, which only ever writes the session layer.
+ */
+function getAgentHostSwitchScope(server: AgentHostMcpServer, agentHostCustomizations: IAgentHostCustomizationService, sessionResource: URI): CustomizationEnablementKind {
+	const decision = getCustomizationEnablementDecision(server);
+	if (decision === undefined) {
+		return CustomizationEnablementKind.Global;
+	}
+	// A workspace write is dropped when the session has no working directory, so fall back to the
+	// layer that can still be written rather than issuing one that silently vanishes.
+	if (decision.kind === CustomizationEnablementKind.Workspace && agentHostCustomizations.getWorkingDirectories(sessionResource).length === 0) {
+		return CustomizationEnablementKind.Global;
+	}
+	return decision.kind;
+}
+
+/**
+ * Resolves how a row's switch reads and writes enablement, or `undefined` when the row has none to
+ * offer.
+ *
+ * Two kinds of row have none. A gallery result has nothing installed to turn on yet. And a server
+ * held off by the plugin that owns it cannot be turned on by writing its own enablement at all --
+ * the honest thing is to show no switch, let the status say `Disabled (Plugin)`, and leave the
+ * context menu's "Enable {plugin}" as the way back.
+ *
+ * Both sides read and write *live* rather than through values captured when the row was rendered.
+ * The render guard cannot cover every decision in an enablement array, and writing back a stale
+ * one would resurrect a scope the user had since changed.
+ */
+export function getEnablementTarget(
+	element: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry,
+	rowState: IMcpRowState,
+	mcpService: IMcpService,
+	agentHostCustomizations: IAgentHostCustomizationService,
+	sessionResource: URI,
+	readActiveSessionServer: (snapshot: AgentHostMcpServer | undefined) => AgentHostMcpServer | undefined,
+): IMcpEnablementTarget | undefined {
+	if (rowState.disabledReason?.source === 'plugin') {
+		return undefined;
+	}
+
+	const sessionSnapshot = getActiveSessionServer(element);
+	const setAgentHostEnabled = (enabled: boolean): void => {
+		const live = readActiveSessionServer(sessionSnapshot);
+		if (!live) {
+			return;
+		}
+		agentHostCustomizations.setCustomizationEnablement(sessionResource, live.id, live.enablement, getAgentHostSwitchScope(live, agentHostCustomizations, sessionResource), enabled);
+	};
+
+	if (element.type === 'session-server-item') {
+		return {
+			isEnabled: () => readActiveSessionServer(sessionSnapshot)?.enabled !== false,
+			setEnabled: setAgentHostEnabled,
+		};
+	}
+
+	const enablementKey = getMcpEnablementKey(element);
+	if (enablementKey === undefined) {
+		return sessionSnapshot
+			? { isEnabled: () => readActiveSessionServer(sessionSnapshot)?.enabled !== false, setEnabled: setAgentHostEnabled }
+			: undefined;
+	}
+
+	return {
+		// A row can be held off by the durable choice, the session choice, or both, so the switch
+		// reflects the union.
+		isEnabled: () => isContributionEnabled(mcpService.enablementModel.readEnabled(enablementKey)) && readActiveSessionServer(sessionSnapshot)?.enabled !== false,
+		setEnabled: enabled => {
+			// Writes the layer that already decided this row rather than always writing the
+			// profile: EnablementModel.setEnabledWithWorkspaceKey deletes the workspace entry when
+			// the profile is written, so a deliberate workspace choice would be destroyed by a
+			// control that only ever displays the scope while the row is off.
+			mcpService.enablementModel.setEnabled(enablementKey, withContributionEnabled(mcpService.enablementModel.readEnabled(enablementKey), enabled));
+			// Dispatched unconditionally rather than only when the layers disagree: the durable
+			// write above notifies synchronously and can rebuild the list underneath this closure,
+			// so re-reading to decide would be racing it. Re-asserting a value the session already
+			// holds is harmless; a switch that leaves a server visibly off is not.
+			if (sessionSnapshot) {
+				setAgentHostEnabled(enabled);
+			}
+		},
+	};
+}
+
+/** Names the act, for a pointer user who has no announced state to go on. */
+function getEnablementSwitchTooltip(name: string, checked: boolean): string {
+	return checked
+		? localize('mcpSwitchOff', "Disable {0}", name)
+		: localize('mcpSwitchOn', "Enable {0}", name);
+}
+
+/**
+ * Whether a disabled reason says something a switch cannot: which layer holds the server off, or
+ * which plugin does.
+ */
+function isQualifiedDisabledReason(reason: CustomizationDisabledReason | undefined): boolean {
+	return reason !== undefined && (reason.source === 'plugin' || reason.scope !== CustomizationEnablementKind.Global);
+}
+
+/**
+ * Whether a *row* should print the status word.
+ *
+ * Stricter than {@link isNoteworthyMcpStatus} by one case: a row carrying a switch already shows
+ * off-ness better than a word can, so "Disabled" beside an off switch is the same fact twice. A
+ * qualified reason is different -- it says *where* the choice lives, which the switch cannot
+ * express.
+ */
+function shouldShowStatusOnRow(state: McpStatusKind | undefined, disabledReason: CustomizationDisabledReason | undefined, hasSwitch: boolean): boolean {
+	if (state === 'disabled') {
+		return !hasSwitch || isQualifiedDisabledReason(disabledReason);
+	}
+	return isNoteworthyMcpStatus(state);
+}
+
+/**
+ * The key a row's durable enablement is stored under.
+ *
+ * For an installed server this is the workbench server's own id -- the same key
+ * `EnableMcpServerGloballyAction` reads and writes, so the switch and the context menu act on one
+ * entry rather than two. Deliberately *not* the matched runtime server's definition id: that match
+ * is conservative and declines whenever two servers answer to one name, and a row must not lose
+ * its enablement because of an ambiguity in a lookup it never needed. Built-in rows have no
+ * workbench server, so they use the runtime definition id their own context menu uses.
+ */
+function getMcpEnablementKey(entry: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry): string | undefined {
+	switch (entry.type) {
+		case 'session-server-item':
+			return undefined;
+		case 'server-item':
+			// A gallery result is not installed, so it has no enablement to store.
+			return entry.server.local ? entry.server.id : undefined;
+		case 'builtin-item':
+			return entry.localServer?.definition.id;
+	}
+}
+
 /**
  * The single answer to "what is this row's state right now".
  *
@@ -625,6 +829,7 @@ function getMcpEntryLabel(element: IMcpServerItemEntry | IMcpSessionServerItemEn
 function resolveMcpRowState(
 	entry: IMcpServerItemEntry | IMcpSessionServerItemEntry | IMcpBuiltinItemEntry,
 	activeSessionReader: ActiveSessionMcpServerReader,
+	enablementModel: IEnablementModel,
 	isSessionsWindow: boolean,
 	reader: IReader | undefined,
 ): IMcpRowState {
@@ -642,8 +847,13 @@ function resolveMcpRowState(
 		return { status: undefined };
 	}
 
-	if (entry.localServer) {
-		const enablement = entry.localServer.enablement.read(reader);
+	const enablementKey = getMcpEnablementKey(entry);
+	if (enablementKey !== undefined) {
+		// Read through the model rather than the matched runtime server's observable: they are the
+		// same value (IMcpServer.enablement is a derived over exactly this read), but the model
+		// answers for rows the conservative runtime match declined, which would otherwise report
+		// a disabled server as fine.
+		const enablement = enablementModel.readEnabled(enablementKey, reader);
 		if (isContributionDisabled(enablement)) {
 			// Described as a scope reason so the wording comes from the same helper the agent-host
 			// rows use. A workspace choice is worth naming; "off everywhere" is just off.
@@ -673,16 +883,16 @@ function resolveMcpRowState(
  * change signal, and nothing re-renders the row around it. A plain string would be computed once
  * and then quietly describe the past.
  */
-function observeMcpEntryAriaLabel(element: IMcpListEntry, activeSessionReader: ActiveSessionMcpServerReader, isSessionsWindow: boolean): IObservable<string> {
-	return derived(reader => getMcpEntryAriaLabel(element, activeSessionReader, isSessionsWindow, reader));
+function observeMcpEntryAriaLabel(element: IMcpListEntry, activeSessionReader: ActiveSessionMcpServerReader, enablementModel: IEnablementModel, isSessionsWindow: boolean): IObservable<string> {
+	return derived(reader => getMcpEntryAriaLabel(element, activeSessionReader, enablementModel, isSessionsWindow, reader));
 }
 
-function getMcpEntryAriaLabel(element: IMcpListEntry, activeSessionReader: ActiveSessionMcpServerReader, isSessionsWindow: boolean, reader: IReader | undefined): string {
+function getMcpEntryAriaLabel(element: IMcpListEntry, activeSessionReader: ActiveSessionMcpServerReader, enablementModel: IEnablementModel, isSessionsWindow: boolean, reader: IReader | undefined): string {
 	if (element.type === 'group-header') {
 		return localize('mcpGroupAriaLabel', "{0}, {1} items, {2}", element.label, element.count, element.collapsed ? localize('collapsed', "collapsed") : localize('expanded', "expanded"));
 	}
 	const label = getMcpEntryLabel(element);
-	const rowState = resolveMcpRowState(element, activeSessionReader, isSessionsWindow, reader);
+	const rowState = resolveMcpRowState(element, activeSessionReader, enablementModel, isSessionsWindow, reader);
 	// Deliberately looser than the row: a screen reader reads the row label on its own, so a
 	// status the row can leave to a neighbouring control is still new information here.
 	const status = isNoteworthyMcpStatus(rowState.status) ? getMcpStatusPresentation(rowState.status, rowState.disabledReason) : undefined;
@@ -1281,7 +1491,7 @@ export class McpListWidget extends Disposable {
 				horizontalScrolling: false,
 				accessibilityProvider: {
 					getAriaLabel: (element: IMcpListEntry) => {
-						return observeMcpEntryAriaLabel(element, activeSessionReader, this.workspaceService.isSessionsWindow);
+						return observeMcpEntryAriaLabel(element, activeSessionReader, this.mcpService.enablementModel, this.workspaceService.isSessionsWindow);
 					},
 					getWidgetAriaLabel() {
 						return localize('mcpServersListAriaLabel', "MCP Servers");
diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
index d941f3db95c195..b92486e489c032 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
@@ -1762,11 +1762,24 @@ for its own name and badge, is not dragged into this sizing. */
 
 .mcp-server-item .mcp-server-actions {
 	flex-shrink: 0;
+	display: flex;
+	align-items: center;
+	gap: var(--vscode-spacing-size80);
+}
+
+/* The buttons live in their own box so clearing them cannot take the switch with them: the switch
+is built once per template, and rebuilding it would remove the element a keyboard user is standing
+on the moment they toggle it. */
+.mcp-server-item .mcp-server-actions-transient {
 	display: flex;
 	align-items: center;
 	gap: var(--vscode-spacing-size40);
 }
 
+.mcp-server-item .mcp-server-actions-transient:empty {
+	display: none;
+}
+
 .mcp-server-item .mcp-server-sign-in.monaco-button {
 	min-width: 0;
 	min-height: var(--vscode-spacing-size240);
diff --git a/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts b/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
index ff9e8246e94b76..bc07cc48f7ee91 100644
--- a/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
+++ b/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
@@ -29,6 +29,7 @@ import {
 	getLocalMcpServerEnablementActions,
 	getMcpServerOutputHandler,
 	getMcpStatusPresentation,
+	getEnablementTarget,
 	getMcpStatusRenderSignature,
 	isNoteworthyMcpStatus,
 	getServerItemContextMenuActions,
@@ -548,6 +549,144 @@ suite('mcpListWidget', () => {
 		});
 	});
 
+	suite('getEnablementTarget', () => {
+
+		const sessionResource = URI.parse('vscode-agent-session:///session-1');
+
+		type Element = Parameters<typeof getEnablementTarget>[0];
+		type RowState = Parameters<typeof getEnablementTarget>[1];
+
+		/** An enablement model that actually remembers, so a round trip can be asserted. */
+		function createMutableMcpService(initial: ContributionEnablementState): { service: IMcpService; read(): ContributionEnablementState } {
+			let state = initial;
+			const service = {
+				enablementModel: {
+					readEnabled: () => state,
+					setEnabled: (_key: string, next: ContributionEnablementState) => { state = next; },
+				},
+			} as unknown as IMcpService;
+			return { service, read: () => state };
+		}
+
+		function targetFor(element: Element, rowState: RowState, mcpService: IMcpService, agentHost: IAgentHostCustomizationService, live?: AgentHostMcpServer) {
+			return getEnablementTarget(element, rowState, mcpService, agentHost, sessionResource, snapshot => live ?? snapshot);
+		}
+
+		test('a gallery row has no switch, because nothing is installed to turn on yet', () => {
+			const element = { type: 'server-item', server: {} } as unknown as Element;
+			assert.strictEqual(
+				targetFor(element, { status: undefined }, createMcpService(ContributionEnablementState.EnabledProfile).service, createAgentHostCustomizations().service),
+				undefined);
+		});
+
+		test('a row held off by its plugin has no switch, because its own enablement cannot free it', () => {
+			const server = createAgentHostServer({ enabled: false });
+			const element = { type: 'session-server-item', server } as unknown as Element;
+			const rowState = {
+				status: 'disabled',
+				disabledReason: { source: 'plugin', plugin: { id: 'p', name: 'Plugin One', uri: 'file:///p' } },
+				activeSessionServer: server,
+			} as unknown as RowState;
+			assert.strictEqual(
+				targetFor(element, rowState, createMcpService(ContributionEnablementState.EnabledProfile).service, createAgentHostCustomizations().service),
+				undefined);
+		});
+
+		test('a workspace-scoped local choice is answered where it was made, not promoted', () => {
+			const mcp = createMutableMcpService(ContributionEnablementState.EnabledWorkspace);
+			const element = { type: 'server-item', server: { id: 'mcp-redis', local: {} } } as unknown as Element;
+			const target = targetFor(element, { status: undefined } as RowState, mcp.service, createAgentHostCustomizations().service);
+
+			target?.setEnabled(false);
+			const afterOff = mcp.read();
+			target?.setEnabled(true);
+
+			assert.deepStrictEqual([afterOff, mcp.read()], [
+				ContributionEnablementState.DisabledWorkspace,
+				ContributionEnablementState.EnabledWorkspace,
+			]);
+		});
+
+		test('turning on a row held off by both layers settles both, so it cannot stay visibly off', () => {
+			const mcp = createMutableMcpService(ContributionEnablementState.DisabledProfile);
+			const { service: agentHost, calls } = createAgentHostCustomizations();
+			const server = createAgentHostServer({ enabled: false, enablement: [{ kind: CustomizationEnablementKind.Session, enabled: false }] as readonly CustomizationEnablement[] });
+			const element = { type: 'server-item', server: { id: 'mcp-redis', local: {} }, activeSessionServer: server } as unknown as Element;
+			const target = targetFor(element, { status: 'disabled', activeSessionServer: server } as RowState, mcp.service, agentHost, server);
+
+			assert.strictEqual(target?.isEnabled(), false);
+			target?.setEnabled(true);
+
+			assert.deepStrictEqual([mcp.read(), calls.map(call => [call[1], call[3], call[4]])], [
+				ContributionEnablementState.EnabledProfile,
+				// The deciding layer, so the effective state actually moves.
+				[['server-1', CustomizationEnablementKind.Session, true]],
+			]);
+		});
+
+		test('an agent-host row nothing decides yet is turned off everywhere, not just for the session', () => {
+			const { service: agentHost, calls } = createAgentHostCustomizations();
+			const server = createAgentHostServer({ enabled: true });
+			const element = { type: 'session-server-item', server } as unknown as Element;
+			const target = targetFor(element, { status: McpServerStatus.Ready, activeSessionServer: server } as RowState, createMcpService(ContributionEnablementState.EnabledProfile).service, agentHost, server);
+
+			target?.setEnabled(false);
+
+			assert.deepStrictEqual(calls.map(call => [call[1], call[3], call[4]]), [
+				['server-1', CustomizationEnablementKind.Global, false],
+			]);
+		});
+
+		test('an agent-host row answers the layer that already decided it', () => {
+			const { service: agentHost, calls } = createAgentHostCustomizations();
+			const server = createAgentHostServer({
+				enabled: false,
+				enablement: [{ kind: CustomizationEnablementKind.Workspace, uri: 'file:///workspace', enabled: false }] as readonly CustomizationEnablement[],
+			});
+			const element = { type: 'session-server-item', server } as unknown as Element;
+			const target = targetFor(element, { status: 'disabled', activeSessionServer: server } as RowState, createMcpService(ContributionEnablementState.EnabledProfile).service, agentHost, server);
+
+			target?.setEnabled(true);
+
+			assert.deepStrictEqual(calls.map(call => [call[1], call[3], call[4]]), [
+				['server-1', CustomizationEnablementKind.Workspace, true],
+			]);
+		});
+
+		test('a workspace decision falls back to global when the session has no working directory', () => {
+			const { service: agentHost, calls } = createAgentHostCustomizations(false);
+			const server = createAgentHostServer({
+				enabled: false,
+				enablement: [{ kind: CustomizationEnablementKind.Workspace, uri: 'file:///gone', enabled: false }] as readonly CustomizationEnablement[],
+			});
+			const element = { type: 'session-server-item', server } as unknown as Element;
+			const target = targetFor(element, { status: 'disabled', activeSessionServer: server } as RowState, createMcpService(ContributionEnablementState.EnabledProfile).service, agentHost, server);
+
+			target?.setEnabled(true);
+
+			assert.deepStrictEqual(calls.map(call => [call[1], call[3], call[4]]), [
+				['server-1', CustomizationEnablementKind.Global, true],
+			]);
+		});
+
+		test('the write reads the server live, so a decision changed since render is not resurrected', () => {
+			const { service: agentHost, calls } = createAgentHostCustomizations();
+			const stale = createAgentHostServer({ enabled: true, enablement: [] as readonly CustomizationEnablement[] });
+			const live = createAgentHostServer({
+				enabled: false,
+				enablement: [{ kind: CustomizationEnablementKind.Session, enabled: false }] as readonly CustomizationEnablement[],
+			});
+			const element = { type: 'session-server-item', server: stale } as unknown as Element;
+			const target = targetFor(element, { status: McpServerStatus.Ready, activeSessionServer: stale } as RowState, createMcpService(ContributionEnablementState.EnabledProfile).service, agentHost, live);
+
+			target?.setEnabled(true);
+
+			assert.deepStrictEqual(calls.map(call => [call[2], call[3]]), [
+				[live.enablement, CustomizationEnablementKind.Session],
+			]);
+		});
+	});
+
 	suite('getMcpStatusRenderSignature', () => {
 		const base: IMcpStatusRenderInput = {
 			rowKey: 'server:mcp.config.workspace/notion:0',
@@ -559,6 +698,7 @@ suite('mcpListWidget', () => {
 			logOutputChannelId: 'mcp.session-1.notion',
 			localServerId: 'mcp.config.workspace/notion',
 			activeSessionResource: 'vscode-agent-session:///session-1',
+			switchChecked: true,
 		};
 
 		// A different, and differently-typed-where-possible, value for every field. The mapped type
@@ -574,6 +714,7 @@ suite('mcpListWidget', () => {
 			logOutputChannelId: 'mcp.session-1.other',
 			localServerId: 'mcp.config.user/notion',
 			activeSessionResource: 'vscode-agent-session:///session-2',
+			switchChecked: false,
 		};
 
 		const fields = Object.keys(base) as (keyof IMcpStatusRenderInput)[];
diff --git a/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts b/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
index 3b3df2eb8c938c..6c0c414d12f82b 100644
--- a/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
+++ b/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
@@ -13,7 +13,7 @@ import { Emitter, Event } from '../../../../../base/common/event.js';
 import { IMarkdownString } from '../../../../../base/common/htmlContent.js';
 import { IReference } from '../../../../../base/common/lifecycle.js';
 import { ResourceMap, ResourceSet } from '../../../../../base/common/map.js';
-import { constObservable, derived, IObservable, observableValue } from '../../../../../base/common/observable.js';
+import { constObservable, derived, IObservable, IReader, observableValue } from '../../../../../base/common/observable.js';
 import { dirname as dirnameUri } from '../../../../../base/common/resources.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { mock } from '../../../../../base/test/common/mock.js';
@@ -59,7 +59,7 @@ import { AICustomizationItemsModel, IAICustomizationItemsModel, ItemsModelSectio
 import { EmbeddedMcpServerDetail } from '../../../../contrib/chat/browser/aiCustomization/embeddedMcpServerDetail.js';
 import { EmbeddedAgentPluginDetail } from '../../../../contrib/chat/browser/aiCustomization/embeddedAgentPluginDetail.js';
 import { AgentPluginItemKind, IAgentPluginItem } from '../../../../contrib/chat/browser/agentPluginEditor/agentPluginItems.js';
-import { ContributionEnablementState } from '../../../../contrib/chat/common/enablement.js';
+import { ContributionEnablementState, IEnablementModel, isContributionEnabled } from '../../../../contrib/chat/common/enablement.js';
 import { AICustomizationManagementEditorInput } from '../../../../contrib/chat/browser/aiCustomization/aiCustomizationManagementEditorInput.js';
 import { IConfigurationService, IConfigurationValue } from '../../../../../platform/configuration/common/configuration.js';
 import { TestConfigurationService } from '../../../../../platform/configuration/test/common/testConfigurationService.js';
@@ -398,6 +398,35 @@ function createMockHarnessService(sessionResource: URI, descriptors: readonly IH
 	}();
 }
 
+/**
+ * A working enablement model for the fixtures.
+ *
+ * MCP rows read enablement to decide both the status word and the state of their on/off switch, so
+ * an unimplemented stub renders every server as off -- and, because the read happens inside an
+ * autorun, fails silently while doing it.
+ */
+function createFixtureEnablementModel(disabledKeys: readonly string[] = []): IEnablementModel {
+	const state = observableValue<ReadonlyMap<string, ContributionEnablementState>>(
+		'fixtureEnablement',
+		new Map(disabledKeys.map(key => [key, ContributionEnablementState.DisabledProfile])));
+	const read = (key: string, reader?: IReader) => state.read(reader).get(key) ?? ContributionEnablementState.EnabledProfile;
+	const write = (key: string, next: ContributionEnablementState | undefined) => {
+		const map = new Map(state.get());
+		if (next === undefined) {
+			map.delete(key);
+		} else {
+			map.set(key, next);
+		}
+		state.set(map, undefined);
+	};
+	return {
+		readEnabled: read,
+		readProfileEnabled: (key, reader) => isContributionEnabled(read(key, reader)),
+		setEnabled: (key, next) => write(key, next),
+		remove: key => write(key, undefined),
+	};
+}
+
 function makeLocalMcpServer(id: string, label: string, scope: LocalMcpServerScope, description?: string, config?: IWorkbenchMcpServer['config']): IWorkbenchMcpServer {
 	return new class extends mock<IWorkbenchMcpServer>() {
 		override readonly id = id;
@@ -897,6 +926,7 @@ async function renderEditor(ctx: ComponentFixtureContext, options: IRenderEditor
 			}());
 			reg.defineInstance(IMcpService, new class extends mock<IMcpService>() {
 				override readonly servers = constObservable(mcpRuntimeServers as never[]);
+				override readonly enablementModel = createFixtureEnablementModel(['mcp-web-search']);
 			}());
 			reg.defineInstance(IMcpRegistry, new class extends mock<IMcpRegistry>() {
 				override readonly collections = constObservable([]);
@@ -1030,6 +1060,7 @@ async function renderMcpBrowseMode(ctx: ComponentFixtureContext): Promise<void>
 			}());
 			reg.defineInstance(IMcpService, new class extends mock<IMcpService>() {
 				override readonly servers = constObservable([] as never[]);
+				override readonly enablementModel = createFixtureEnablementModel();
 			}());
 			reg.defineInstance(IMcpRegistry, new class extends mock<IMcpRegistry>() {
 				override readonly collections = constObservable([]);
@@ -1253,6 +1284,7 @@ function renderMcpDisabled(ctx: ComponentFixtureContext, byPolicy: boolean): voi
 			}());
 			reg.defineInstance(IMcpService, new class extends mock<IMcpService>() {
 				override readonly servers = constObservable([] as never[]);
+				override readonly enablementModel = createFixtureEnablementModel();
 			}());
 			reg.defineInstance(IMcpRegistry, new class extends mock<IMcpRegistry>() {
 				override readonly collections = constObservable([]);

From 210bcbcc1e2be862b49ec1de957af0cfe9e4885d Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 21:48:52 +0200
Subject: [PATCH 10/13] mcp: feat: show what a server offers and why it failed

A row said a server's name and its description. It did not say how many
tools the server provides -- the whole reason to install one -- and when
a server failed it said so only through a coloured icon, leaving the
reason readable exclusively by opening the output channel.

Tool counts are read from the cache state, so they survive a stopped
server: what a server offers is exactly what someone deciding whether to
turn it back on is looking for. A first refresh in flight is not treated
as a known empty result, and a count that came from the cache reads
quieter and says so on hover.

Line two becomes transport, then either the failure or the description.
A failure replaces the description and drops the transport with it: when
something is broken that is the only thing on the line worth the user's
attention, and truncating the error to make room for 'Local' helps
nobody.

The error hover is anchored to the line the error is printed on rather
than the row. Built-in rows already register a provenance hover on the
container, and the hover service keys delayed hovers by element, so two
registrations on one element would overwrite each other.

This widens IMcpStatusRenderInput. Line two genuinely cannot be built in
renderElement any more -- transport and the error are only known once the
row's observables have been read -- so it is drawn inside the guard, and
every value it draws from has to be covered. The failure mode is silent:
a field left out does not throw, it freezes that text on screen until
something else happens to move. The mapped type in the test is what makes
that a compile error rather than a bug report.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../browser/aiCustomization/mcpListWidget.ts  | 194 ++++++++++++++++--
 .../media/aiCustomizationManagement.css       |  35 ++++
 .../aiCustomization/mcpListWidget.test.ts     |  10 +
 ...aiCustomizationManagementEditor.fixture.ts |  22 +-
 4 files changed, 237 insertions(+), 24 deletions(-)

diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
index cfe9e78ce2e414..e4cf2d3ce1f352 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
@@ -18,7 +18,7 @@ import { defaultButtonStyles, defaultInputBoxStyles } from '../../../../../platf
 import { ICommandService } from '../../../../../platform/commands/common/commands.js';
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
 import { mcpAccessConfig, McpAccessValue } from '../../../../../platform/mcp/common/mcpManagement.js';
-import { IMcpWorkbenchService, IWorkbenchMcpServer, McpConnectionState, McpServerInstallState, IMcpService, IMcpServer } from '../../../../contrib/mcp/common/mcpTypes.js';
+import { IMcpWorkbenchService, IWorkbenchMcpServer, McpConnectionState, McpServerCacheState, McpServerInstallState, McpServerTransportType, IMcpService, IMcpServer } from '../../../../contrib/mcp/common/mcpTypes.js';
 import { IMcpRegistry } from '../../../mcp/common/mcpRegistryTypes.js';
 import { MCP_PLUGIN_COLLECTION_ID_PREFIX } from '../../../mcp/common/discovery/pluginMcpDiscovery.js';
 import { ExtensionIdentifier } from '../../../../../platform/extensions/common/extensions.js';
@@ -54,6 +54,8 @@ import { EnablementSwitch } from './enablementSwitch.js';
 
 const $ = DOM.$;
 
+const mcpToolsIcon = Codicon.tools;
+
 const MCP_ITEM_HEIGHT = 36;
 const MCP_ITEM_WITH_DESCRIPTION_HEIGHT = 44;
 
@@ -154,6 +156,59 @@ class ActiveSessionMcpServerReader {
 	}
 }
 
+/**
+ * Whether a cache state means "we know what tools this server has".
+ *
+ * `RefreshingFromUnknown` is a first refresh in flight: no tools have ever been read, so an empty
+ * list means "not yet", not "none". Treating it as a known result reported a server as offering no
+ * tools while its very first request was still outstanding.
+ */
+export function hasKnownMcpTools(cacheState: McpServerCacheState | undefined): boolean {
+	return cacheState !== undefined
+		&& cacheState !== McpServerCacheState.Unknown
+		&& cacheState !== McpServerCacheState.RefreshingFromUnknown;
+}
+
+/**
+ * Whether the tools currently shown came from the cache rather than a live connection.
+ *
+ * `RefreshingFromCached` is a refresh over cached tools: what is on screen is still the cached set
+ * until the refresh lands, so it keeps the same "from the last time this ran" caveat.
+ */
+export function areMcpToolsFromCache(cacheState: McpServerCacheState | undefined): boolean {
+	return cacheState === McpServerCacheState.Cached
+		|| cacheState === McpServerCacheState.Outdated
+		|| cacheState === McpServerCacheState.RefreshingFromCached;
+}
+
+/**
+ * Reads the facts a row shows about a running server.
+ *
+ * Tools are read even when the server is stopped: a cached result means we know what it offers
+ * from its last run, which is exactly what someone deciding whether to enable it wants to see.
+ */
+function readServerFacts(server: IMcpServer | undefined, reader: IReader | undefined): { toolCount?: number; toolsFromCache?: boolean; transport?: string } {
+	if (!server) {
+		return {};
+	}
+	const cacheState = server.cacheState.read(reader);
+	const launch = server.readDefinitions().read(reader).server?.launch;
+	return {
+		toolCount: hasKnownMcpTools(cacheState) ? server.tools.read(reader).length : undefined,
+		toolsFromCache: areMcpToolsFromCache(cacheState),
+		transport: launch?.type === McpServerTransportType.HTTP
+			? localize('transportHttp', "HTTP")
+			: launch?.type === McpServerTransportType.Stdio
+				? localize('transportLocal', "Local")
+				: undefined,
+	};
+}
+
+/** The failure an agent-host server is reporting, when it is reporting one. */
+function getAgentHostServerError(server: AgentHostMcpServer): string | undefined {
+	return server.state.kind === McpServerStatus.Error ? server.state.error.message : undefined;
+}
+
 /** The parts of a row that come from observables and change while the row is bound to an element. */
 interface IMcpRowState {
 	readonly status: McpStatusKind | undefined;
@@ -161,6 +216,17 @@ interface IMcpRowState {
 	readonly disabledReason?: CustomizationDisabledReason;
 	/** The live agent-host view of this row's server, re-read rather than the stale snapshot. */
 	readonly activeSessionServer?: AgentHostMcpServer;
+	/** Populated for a failing server, so the reason can be read in place. */
+	readonly errorMessage?: string;
+	readonly toolCount?: number;
+	/** Tools are last-known rather than live, so the count carries a caveat. */
+	readonly toolsFromCache?: boolean;
+	readonly transport?: string;
+}
+
+/** The parts of a row that do not change while the row is bound, but that line two draws from. */
+interface IMcpRowContext {
+	readonly description?: string;
 }
 
 /**
@@ -219,6 +285,8 @@ interface IMcpServerItemTemplateData {
 	renderedRowKey?: string;
 	/** What the actions currently show, so an unchanged status does not rebuild them. */
 	renderedStatusSignature?: string;
+	/** Static, per-element facts that the status update needs in order to draw line two. */
+	context: IMcpRowContext;
 }
 
 /**
@@ -268,6 +336,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			enablementSwitch,
 			elementDisposables: new DisposableStore(),
 			actionDisposables: new DisposableStore(),
+			context: {},
 		};
 	}
 
@@ -289,13 +358,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			templateData.container.classList.add('builtin');
 			templateData.container.classList.toggle('has-detail', false);
 			templateData.name.textContent = formatDisplayName(element.label);
-			if (element.description) {
-				templateData.description.textContent = truncateToFirstLine(element.description);
-				templateData.description.style.display = '';
-			} else {
-				templateData.description.textContent = '';
-				templateData.description.style.display = 'none';
-			}
+			templateData.context = { description: element.description ? truncateToFirstLine(element.description) : undefined };
 			this.bindRowState(templateData, element);
 
 			// Add hover with plugin provenance for plugin-sourced builtin items
@@ -319,8 +382,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			templateData.container.classList.remove('builtin');
 			templateData.container.classList.toggle('has-detail', false);
 			templateData.name.textContent = formatDisplayName(element.server.name);
-			templateData.description.textContent = '';
-			templateData.description.style.display = 'none';
+			templateData.context = {};
 			this.bindRowState(templateData, element);
 			return;
 		}
@@ -334,13 +396,7 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 		const isGallery = !element.server.local;
 		const hasDetail = !!description || isGallery;
 		templateData.container.classList.toggle('has-detail', hasDetail);
-		if (description) {
-			templateData.description.textContent = truncateToFirstLine(description);
-			templateData.description.style.display = '';
-		} else {
-			templateData.description.textContent = '';
-			templateData.description.style.display = 'none';
-		}
+		templateData.context = { description: description ? truncateToFirstLine(description) : undefined };
 
 		this.bindRowState(templateData, element);
 	}
@@ -394,6 +450,11 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			localServerId: localServer?.definition.id,
 			activeSessionResource: activeSessionResource.toString(),
 			switchChecked,
+			errorMessage: rowState.errorMessage,
+			toolCount: rowState.toolCount,
+			toolsFromCache: rowState.toolsFromCache,
+			transport: rowState.transport,
+			description: templateData.context.description,
 		});
 		if (templateData.renderedStatusSignature === signature) {
 			return;
@@ -406,6 +467,20 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 		templateData.status.className = 'mcp-server-status';
 
 		this.renderEnablementSwitch(templateData, enablementTarget, switchChecked, label);
+		this.renderMetaLine(templateData, rowState);
+
+		if (rowState.toolCount !== undefined && rowState.toolCount > 0) {
+			const toolsElement = DOM.append(templateData.actions, $('.mcp-server-tools'));
+			toolsElement.classList.toggle('is-cached', !!rowState.toolsFromCache);
+			DOM.append(toolsElement, $('span')).classList.add(...ThemeIcon.asClassNameArray(mcpToolsIcon));
+			DOM.append(toolsElement, $('span')).textContent = String(rowState.toolCount);
+			templateData.actionDisposables.add(this.hoverService.setupManagedHover(
+				getDefaultHoverDelegate('element'),
+				toolsElement,
+				rowState.toolsFromCache
+					? localize('mcpToolsCached', "{0} tools, from the last time this server ran", rowState.toolCount)
+					: localize('mcpTools', "{0} tools", rowState.toolCount)));
+		}
 
 		// Status reads as a word beside the name, including the states that used to resolve to an
 		// icon-less presentation and therefore drew nothing at all -- which was every idle server,
@@ -464,6 +539,55 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			outputButton.element.classList.add('mcp-server-inline-button');
 			registerMcpInlineButtonAction(templateData.actionDisposables, outputButton, showOutput);
 		}
+
+		if (rowState.errorMessage) {
+			// Anchored to the line the error is printed on, not the row. Built-in rows already
+			// register a provenance hover on the container, and the hover service keys delayed
+			// hovers by target element -- two registrations on one element overwrite each other's
+			// entry, so whichever was torn down last would take the survivor's with it.
+			templateData.actionDisposables.add(this.hoverService.setupDelayedHover(templateData.description, () => ({
+				content: rowState.errorMessage!,
+				appearance: { compact: false, skipFadeInAnimation: true },
+			})));
+		}
+	}
+
+	/**
+	 * Renders line two: how the server connects, and either the failure reason or its description.
+	 *
+	 * A failure replaces the description because when something is broken that is the only thing on
+	 * this line worth the user's attention, and transport drops out with it rather than truncating
+	 * the error to nothing.
+	 */
+	private renderMetaLine(templateData: IMcpServerItemTemplateData, rowState: IMcpRowState): void {
+		DOM.clearNode(templateData.description);
+		templateData.description.classList.toggle('is-error', !!rowState.errorMessage);
+
+		const parts: { text: string; isError?: boolean; isContext?: boolean }[] = [];
+		if (rowState.transport && !rowState.errorMessage) {
+			parts.push({ text: rowState.transport, isContext: true });
+		}
+		if (rowState.errorMessage) {
+			parts.push({ text: truncateToFirstLine(rowState.errorMessage), isError: true });
+		} else if (templateData.context.description) {
+			parts.push({ text: templateData.context.description });
+		}
+
+		if (!parts.length) {
+			templateData.description.style.display = 'none';
+			return;
+		}
+
+		templateData.description.style.display = '';
+		parts.forEach((part, index) => {
+			if (index > 0) {
+				DOM.append(templateData.description, $('span.mcp-server-meta-separator')).textContent = '·';
+			}
+			const span = DOM.append(templateData.description, $('span'));
+			span.textContent = part.text;
+			span.classList.toggle('mcp-server-meta-error', !!part.isError);
+			span.classList.toggle('mcp-server-meta-context', !!part.isContext);
+		});
 	}
 
 	/**
@@ -629,6 +753,17 @@ export interface IMcpStatusRenderInput {
 	readonly activeSessionResource: string | undefined;
 	/** The switch's rendered state: `undefined` when the row has no switch at all. */
 	readonly switchChecked: boolean | undefined;
+	/**
+	 * Line two is drawn from here down. It is built inside the guard because `transport` and
+	 * `errorMessage` are only known once the row's observables have been read, so unlike the name
+	 * it cannot be written in `renderElement`. Leaving one of these out does not throw -- it
+	 * freezes that text on screen until something else happens to move.
+	 */
+	readonly errorMessage: string | undefined;
+	readonly toolCount: number | undefined;
+	readonly toolsFromCache: boolean | undefined;
+	readonly transport: string | undefined;
+	readonly description: string | undefined;
 }
 
 /**
@@ -656,6 +791,11 @@ export function getMcpStatusRenderSignature(input: IMcpStatusRenderInput): strin
 		input.localServerId ?? null,
 		input.activeSessionResource ?? null,
 		input.switchChecked ?? null,
+		input.errorMessage ?? null,
+		input.toolCount ?? null,
+		input.toolsFromCache ?? null,
+		input.transport ?? null,
+		input.description ?? null,
 	]);
 }
 
@@ -833,13 +973,23 @@ function resolveMcpRowState(
 	isSessionsWindow: boolean,
 	reader: IReader | undefined,
 ): IMcpRowState {
+	// Facts about the running server are read for every row: a stopped server still knows what
+	// tools it offered last time it ran, which is exactly what someone deciding whether to turn it
+	// on wants to see.
+	const facts = readServerFacts(entry.type === 'session-server-item' ? undefined : entry.localServer, reader);
+
 	const activeSessionServer = activeSessionReader.read(getActiveSessionServer(entry), reader);
 	if (activeSessionServer !== undefined) {
 		const presentation = getActiveSessionServerPresentation(activeSessionServer);
 		return {
+			...facts,
 			status: presentation.status,
 			disabledReason: presentation.enabled ? undefined : activeSessionServer.disabledReason,
 			activeSessionServer,
+			// Read from whichever source decided the status. Reading the error off the local
+			// runtime regardless would let a row show the session's status beside an unrelated
+			// local failure -- or say "Failed" with nothing to read.
+			errorMessage: presentation.enabled ? getAgentHostServerError(activeSessionServer) : undefined,
 		};
 	}
 
@@ -858,6 +1008,7 @@ function resolveMcpRowState(
 			// Described as a scope reason so the wording comes from the same helper the agent-host
 			// rows use. A workspace choice is worth naming; "off everywhere" is just off.
 			return {
+				...facts,
 				status: 'disabled',
 				disabledReason: {
 					source: 'scope',
@@ -870,9 +1021,14 @@ function resolveMcpRowState(
 	// Only a plain local row reports its connection state. A built-in row has never shown it, and
 	// in the Agents window the local runtime is not what governs whether a server is working.
 	if (entry.type === 'server-item' && !isSessionsWindow) {
-		return { status: entry.localServer?.connectionState.read(reader).state };
+		const connectionState = entry.localServer?.connectionState.read(reader);
+		return {
+			...facts,
+			status: connectionState?.state,
+			errorMessage: connectionState?.state === McpConnectionState.Kind.Error ? connectionState.message : undefined,
+		};
 	}
-	return { status: undefined };
+	return { ...facts, status: undefined };
 }
 
 /**
diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
index b92486e489c032..f181900fe75e25 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
@@ -1760,6 +1760,41 @@ for its own name and badge, is not dragged into this sizing. */
 	line-height: 14px;
 }
 
+/* Line two is a sequence of spans rather than one string, so a failure can be coloured and the
+context around it can drop out when the line runs short. */
+.mcp-server-item .mcp-server-description > span {
+	min-width: 0;
+}
+
+.mcp-server-item .mcp-server-meta-separator {
+	margin: 0 var(--vscode-spacing-size40);
+	opacity: 0.6;
+}
+
+.mcp-server-item .mcp-server-meta-error {
+	color: var(--vscode-testing-iconFailed, var(--vscode-errorForeground));
+}
+
+/* Tool counts stay legible while the server is off -- what a server offers is exactly what someone
+deciding whether to turn it back on is looking for. */
+.mcp-server-item .mcp-server-tools {
+	display: flex;
+	align-items: center;
+	gap: var(--vscode-spacing-size20);
+	font-size: var(--vscode-agents-fontSize-label2);
+	color: var(--vscode-descriptionForeground);
+	white-space: nowrap;
+}
+
+.mcp-server-item .mcp-server-tools .codicon {
+	font-size: var(--vscode-codiconFontSize-compact);
+}
+
+/* Cached counts are last-known rather than live, and read a shade quieter to say so. */
+.mcp-server-item .mcp-server-tools.is-cached {
+	opacity: 0.7;
+}
+
 .mcp-server-item .mcp-server-actions {
 	flex-shrink: 0;
 	display: flex;
diff --git a/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts b/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
index bc07cc48f7ee91..cc8f08413bd43a 100644
--- a/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
+++ b/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
@@ -699,6 +699,11 @@ suite('mcpListWidget', () => {
 			localServerId: 'mcp.config.workspace/notion',
 			activeSessionResource: 'vscode-agent-session:///session-1',
 			switchChecked: true,
+			errorMessage: 'spawn ENOENT',
+			toolCount: 4,
+			toolsFromCache: true,
+			transport: 'Local',
+			description: 'Issue tracking',
 		};
 
 		// A different, and differently-typed-where-possible, value for every field. The mapped type
@@ -715,6 +720,11 @@ suite('mcpListWidget', () => {
 			localServerId: 'mcp.config.user/notion',
 			activeSessionResource: 'vscode-agent-session:///session-2',
 			switchChecked: false,
+			errorMessage: 'connection refused',
+			toolCount: 5,
+			toolsFromCache: false,
+			transport: 'HTTP',
+			description: 'Issue tracking and boards',
 		};
 
 		const fields = Object.keys(base) as (keyof IMcpStatusRenderInput)[];
diff --git a/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts b/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
index 6c0c414d12f82b..0edbca8e905b9e 100644
--- a/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
+++ b/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
@@ -69,7 +69,7 @@ import { ChatConfiguration } from '../../../../contrib/chat/common/constants.js'
 import { IAutomationDialogService } from '../../../../contrib/chat/common/automations/automationDialogService.js';
 import { IAutomationRunner } from '../../../../contrib/chat/common/automations/automationRunner.js';
 import { IAutomationService } from '../../../../contrib/chat/common/automations/automationService.js';
-import { IMcpWorkbenchService, IWorkbenchMcpServer, IMcpService, McpConnectionState, McpServerInstallState } from '../../../../contrib/mcp/common/mcpTypes.js';
+import { IMcpWorkbenchService, IWorkbenchMcpServer, IMcpService, McpConnectionState, McpServerCacheState, McpServerInstallState, McpServerTransportType } from '../../../../contrib/mcp/common/mcpTypes.js';
 import { IMcpRegistry } from '../../../../contrib/mcp/common/mcpRegistryTypes.js';
 import { IWorkbenchLocalMcpServer, LocalMcpServerScope } from '../../../../services/mcp/common/mcpWorkbenchManagementService.js';
 import { McpListWidget } from '../../../../contrib/chat/browser/aiCustomization/mcpListWidget.js';
@@ -590,11 +590,23 @@ const mcpUserServers = [
 	makeLocalMcpServer('mcp-filesystem', 'Filesystem', LocalMcpServerScope.User, 'Local file operations'),
 	makeLocalMcpServer('mcp-puppeteer', 'Puppeteer', LocalMcpServerScope.User, 'Browser automation'),
 ];
+/**
+ * Runtime facts a row draws on: how the server connects, and what tools it last reported. Tools
+ * survive a stopped server, so a fixture that omits them hides the count entirely.
+ */
+function makeRuntimeFacts(toolCount: number, transport: McpServerTransportType, cacheState = McpServerCacheState.Live) {
+	return {
+		cacheState: constObservable(cacheState),
+		tools: constObservable(Array.from({ length: toolCount }, (_, index) => ({ referenceName: `tool_${index}` }))),
+		readDefinitions: () => constObservable({ server: { launch: { type: transport } }, collection: undefined }),
+	};
+}
+
 const mcpRuntimeServers = [
-	{ definition: { id: 'github-copilot-mcp', label: 'GitHub Copilot' }, collection: { id: 'ext.github.copilot/mcp', label: 'ext.github.copilot/mcp' }, enablement: constObservable(ContributionEnablementState.EnabledProfile), connectionState: constObservable({ state: McpConnectionState.Kind.Starting }), showOutput() { } },
-	{ definition: { id: 'mcp-postgres', label: 'PostgreSQL' }, collection: { id: 'workspace-mcp', label: 'Workspace MCP' }, enablement: constObservable(ContributionEnablementState.EnabledProfile), connectionState: constObservable({ state: McpConnectionState.Kind.Error }), showOutput() { } },
-	{ definition: { id: 'mcp-web-search', label: 'Web Search' }, collection: { id: 'user-mcp', label: 'User MCP' }, enablement: constObservable(ContributionEnablementState.DisabledProfile), connectionState: constObservable({ state: McpConnectionState.Kind.Stopped }), showOutput() { } },
-	{ definition: { id: 'mcp-filesystem', label: 'Filesystem' }, collection: { id: 'user-mcp', label: 'User MCP' }, enablement: constObservable(ContributionEnablementState.EnabledProfile), connectionState: constObservable({ state: McpConnectionState.Kind.Stopped }), showOutput() { } },
+	{ definition: { id: 'github-copilot-mcp', label: 'GitHub Copilot' }, collection: { id: 'ext.github.copilot/mcp', label: 'ext.github.copilot/mcp' }, enablement: constObservable(ContributionEnablementState.EnabledProfile), connectionState: constObservable({ state: McpConnectionState.Kind.Starting }), showOutput() { }, ...makeRuntimeFacts(6, McpServerTransportType.Stdio) },
+	{ definition: { id: 'mcp-postgres', label: 'PostgreSQL' }, collection: { id: 'workspace-mcp', label: 'Workspace MCP' }, enablement: constObservable(ContributionEnablementState.EnabledProfile), connectionState: constObservable({ state: McpConnectionState.Kind.Error, message: 'spawn postgres ENOENT' }), showOutput() { }, ...makeRuntimeFacts(12, McpServerTransportType.Stdio, McpServerCacheState.Cached) },
+	{ definition: { id: 'mcp-web-search', label: 'Web Search' }, collection: { id: 'user-mcp', label: 'User MCP' }, enablement: constObservable(ContributionEnablementState.DisabledProfile), connectionState: constObservable({ state: McpConnectionState.Kind.Stopped }), showOutput() { }, ...makeRuntimeFacts(3, McpServerTransportType.HTTP, McpServerCacheState.Cached) },
+	{ definition: { id: 'mcp-filesystem', label: 'Filesystem' }, collection: { id: 'user-mcp', label: 'User MCP' }, enablement: constObservable(ContributionEnablementState.EnabledProfile), connectionState: constObservable({ state: McpConnectionState.Kind.Stopped }), showOutput() { }, ...makeRuntimeFacts(8, McpServerTransportType.Stdio) },
 ];
 
 const activeSessionMcpServers: FixtureAgentHostMcpServer[] = [

From 0cb2cc6c643dc7fd4d53f07694796c20b21dd003 Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 21:54:58 +0200
Subject: [PATCH 11/13] mcp: feat: group MCP servers by where they are defined

Five sections became four. Extension and Plugin were two headings for one
thing as a user experiences it -- software they installed -- so they now
share a section, and the distinction survives on the row, where the
header cannot say it. Ordering leads with the user's own settings rather
than the workspace, then moves outwards to the product's.

Servers only the agent knows about join Built-in rather than getting a
section of their own. They arrive because you are using that agent, which
is the same reason VS Code's own servers are there; the row names which
product it was, using the agent's own name where the harness reports one.

Line two gains the origin, but only where the header does not already say
it, so a row stops repeating what it sits under. A row with nothing else
to say falls back to naming its origin anyway, because a gap under the
name reads worse than repetition.

Session servers are claimed against the unfiltered lists and filtered
afterwards. Claiming is consuming, so claiming against filtered lists let
a row hidden by the search box release its claim for another row to pick
up. Claiming first keeps the join a property of the configuration rather
than of what happens to be on screen.

The sidebar badge counts what the user has rather than what the current
search matched. It was derived from the filtered arrays, so typing in the
search box silently rewrote the tab's badge -- and the consumed matcher
could not answer the question either, since the narrower the query the
more servers it reported as session-only.

Adds a scrolled active-session fixture: Built-in is where the agent's own
servers land, and it was the one section no screenshot could reach.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../browser/aiCustomization/mcpListWidget.ts  | 357 ++++++++++++------
 .../aiCustomization/mcpListWidget.test.ts     |  47 ++-
 ...aiCustomizationManagementEditor.fixture.ts |  13 +
 3 files changed, 292 insertions(+), 125 deletions(-)

diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
index e4cf2d3ce1f352..ae24c61c33f8f9 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
@@ -36,7 +36,7 @@ import { ConfigureModelAccessAction, DisableMcpServerForWorkspaceAction, Disable
 import { LocalMcpServerScope } from '../../../../services/mcp/common/mcpWorkbenchManagementService.js';
 import { IAgentPluginService } from '../../common/plugins/agentPluginService.js';
 import { IDialogService } from '../../../../../platform/dialogs/common/dialogs.js';
-import { workspaceIcon, userIcon, mcpServerIcon, builtinIcon, pluginIcon, extensionIcon } from './aiCustomizationIcons.js';
+import { workspaceIcon, userIcon, mcpServerIcon, builtinIcon, extensionIcon } from './aiCustomizationIcons.js';
 import { formatDisplayName, truncateToFirstLine } from './aiCustomizationListWidget.js';
 import { getDefaultHoverDelegate } from '../../../../../base/browser/ui/hover/hoverDelegateFactory.js';
 import { IHoverService } from '../../../../../platform/hover/browser/hover.js';
@@ -74,8 +74,61 @@ function getPluginUriFromCollectionId(collectionId: string | undefined): string
 /**
  * Represents a collapsible group header in the MCP server list.
  */
+/**
+ * Sections answer one question -- *where is this server defined?* -- ordered from the user's own
+ * choices outwards to the product's.
+ *
+ * Extension and Plugin were previously two sections, but they are one thing to a user: software
+ * they installed. The distinction still matters when acting on a row, so it survives on the row,
+ * where the header cannot say it.
+ *
+ * Grouping by origin also lets the rows stop repeating it: "Workspace" belongs once in a header,
+ * not on every row underneath it.
+ */
+type McpGroupId = 'user' | 'workspace' | 'installed' | 'builtin';
+
 interface IMcpGroupHeaderEntry extends ICustomizationGroupHeaderEntry {
-	readonly scope: LocalMcpServerScope | 'builtin' | 'plugin' | 'extension';
+	readonly scope: McpGroupId;
+}
+
+/**
+ * Where a server came from, phrased for line two of a row. Extension provenance cannot be read off
+ * the collection id -- extension collections are keyed `<extensionId>/<collectionId>` -- so the
+ * caller resolves it from the registry and passes it in.
+ */
+function getCollectionOriginLabel(collectionId: string | undefined, source: unknown): string {
+	if (collectionId?.startsWith(PLUGIN_COLLECTION_PREFIX)) {
+		return localize('originPlugin', "Plugin");
+	}
+	// Copilot ships MCP servers through an extension, but users experience them as part of the
+	// product, so they read as built-in rather than as something they installed.
+	if (source instanceof ExtensionIdentifier && !isCopilotExtension(source)) {
+		return localize('originExtension', "Extension");
+	}
+	return localize('originBuiltin', "Built-in");
+}
+
+function getScopeOriginLabel(scope: LocalMcpServerScope | undefined): string | undefined {
+	switch (scope) {
+		case LocalMcpServerScope.Workspace:
+			return localize('originWorkspace', "Workspace");
+		case LocalMcpServerScope.User:
+		case LocalMcpServerScope.RemoteUser:
+			// A remote-user server is still the user's own choice; where the profile lives is not
+			// a distinction this row is trying to draw, and dropping it left line two blank.
+			return localize('originUser', "User");
+		default:
+			return undefined;
+	}
+}
+
+/**
+ * What to call the agent a server came with, for rows that sit in Built-in beside VS Code's own
+ * servers. Harnesses that do not name their agent fall back to describing the machinery, which is
+ * the only honest thing left to say.
+ */
+export function getAgentOriginLabel(agentName: string | undefined): string {
+	return agentName ?? localize('originAgentHost', "Agent host");
 }
 
 /**
@@ -84,6 +137,10 @@ interface IMcpGroupHeaderEntry extends ICustomizationGroupHeaderEntry {
 interface IMcpServerItemEntry {
 	readonly type: 'server-item';
 	readonly server: IWorkbenchMcpServer;
+	/** Shown on the row only when the section header does not already say it. */
+	readonly origin?: string;
+	/** The origin the header implies; rendered only if line two would otherwise be empty. */
+	readonly impliedOrigin?: string;
 	readonly activeSessionServer?: AgentHostMcpServer;
 	readonly localServer?: IMcpServer;
 	/**
@@ -108,6 +165,10 @@ interface IMcpBuiltinItemEntry {
 	readonly label: string;
 	readonly description: string;
 	readonly collectionId?: string;
+	/** Shown on the row only when the section header does not already say it. */
+	readonly origin?: string;
+	/** The origin the header implies; rendered only if line two would otherwise be empty. */
+	readonly impliedOrigin?: string;
 	readonly activeSessionServer?: AgentHostMcpServer;
 	readonly localServer?: IMcpServer;
 }
@@ -226,6 +287,10 @@ interface IMcpRowState {
 
 /** The parts of a row that do not change while the row is bound, but that line two draws from. */
 interface IMcpRowContext {
+	/** Where the server came from, when the section header does not already answer it. */
+	readonly origin?: string;
+	/** The origin the header implies; a fallback so line two is never blank. */
+	readonly impliedOrigin?: string;
 	readonly description?: string;
 }
 
@@ -358,7 +423,11 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			templateData.container.classList.add('builtin');
 			templateData.container.classList.toggle('has-detail', false);
 			templateData.name.textContent = formatDisplayName(element.label);
-			templateData.context = { description: element.description ? truncateToFirstLine(element.description) : undefined };
+			templateData.context = {
+				origin: element.origin,
+				impliedOrigin: element.impliedOrigin,
+				description: element.description ? truncateToFirstLine(element.description) : undefined,
+			};
 			this.bindRowState(templateData, element);
 
 			// Add hover with plugin provenance for plugin-sourced builtin items
@@ -382,7 +451,12 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			templateData.container.classList.remove('builtin');
 			templateData.container.classList.toggle('has-detail', false);
 			templateData.name.textContent = formatDisplayName(element.server.name);
-			templateData.context = {};
+			// Named on the row rather than left to the header: these sit in Built-in beside
+			// VS Code's own servers, so the row is the only place that can say which product this
+			// one came with. It is the leading origin rather than the fallback, because a failing
+			// server fills line two with its error and would otherwise never say where it came
+			// from -- exactly the row you most need to place.
+			templateData.context = { origin: getAgentOriginLabel(this.customizationHarnessService.getActiveDescriptor().agentName) };
 			this.bindRowState(templateData, element);
 			return;
 		}
@@ -396,7 +470,11 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 		const isGallery = !element.server.local;
 		const hasDetail = !!description || isGallery;
 		templateData.container.classList.toggle('has-detail', hasDetail);
-		templateData.context = { description: description ? truncateToFirstLine(description) : undefined };
+		templateData.context = {
+			origin: element.origin,
+			impliedOrigin: isGallery ? undefined : getScopeOriginLabel(element.server.local?.scope),
+			description: description ? truncateToFirstLine(description) : undefined,
+		};
 
 		this.bindRowState(templateData, element);
 	}
@@ -455,6 +533,8 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 			toolsFromCache: rowState.toolsFromCache,
 			transport: rowState.transport,
 			description: templateData.context.description,
+			origin: templateData.context.origin,
+			impliedOrigin: templateData.context.impliedOrigin,
 		});
 		if (templateData.renderedStatusSignature === signature) {
 			return;
@@ -564,6 +644,9 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 		templateData.description.classList.toggle('is-error', !!rowState.errorMessage);
 
 		const parts: { text: string; isError?: boolean; isContext?: boolean }[] = [];
+		if (templateData.context.origin) {
+			parts.push({ text: templateData.context.origin, isContext: true });
+		}
 		if (rowState.transport && !rowState.errorMessage) {
 			parts.push({ text: rowState.transport, isContext: true });
 		}
@@ -574,8 +657,14 @@ class McpServerItemRenderer implements IListRenderer<IMcpServerItemEntry | IMcpS
 		}
 
 		if (!parts.length) {
-			templateData.description.style.display = 'none';
-			return;
+			// Origin normally lives in the section header rather than on the row. A row with no
+			// transport and no description would otherwise leave line two blank, so it comes back
+			// here -- repetition is better than a gap under the name.
+			if (!templateData.context.impliedOrigin) {
+				templateData.description.style.display = 'none';
+				return;
+			}
+			parts.push({ text: templateData.context.impliedOrigin, isContext: true });
 		}
 
 		templateData.description.style.display = '';
@@ -764,6 +853,8 @@ export interface IMcpStatusRenderInput {
 	readonly toolsFromCache: boolean | undefined;
 	readonly transport: string | undefined;
 	readonly description: string | undefined;
+	readonly origin: string | undefined;
+	readonly impliedOrigin: string | undefined;
 }
 
 /**
@@ -796,6 +887,8 @@ export function getMcpStatusRenderSignature(input: IMcpStatusRenderInput): strin
 		input.toolsFromCache ?? null,
 		input.transport ?? null,
 		input.description ?? null,
+		input.origin ?? null,
+		input.impliedOrigin ?? null,
 	]);
 }
 
@@ -1360,18 +1453,43 @@ export function getServerItemContextMenuActions(menuActionGroups: readonly (read
 	return actions;
 }
 
-function createBuiltinEntry(server: IMcpServer, activeSessionServer?: AgentHostMcpServer): IMcpBuiltinItemEntry {
+function createBuiltinEntry(server: IMcpServer, origin: string | undefined, activeSessionServer: AgentHostMcpServer | undefined, impliedOrigin: string): IMcpBuiltinItemEntry {
 	return {
 		type: 'builtin-item',
 		id: `builtin-${server.definition.id}`,
 		label: server.definition.label,
 		description: '',
 		collectionId: server.collection.id,
+		origin,
+		impliedOrigin,
 		activeSessionServer,
 		localServer: server,
 	};
 }
 
+/**
+ * Counts session servers that no installed or runtime server already accounts for.
+ *
+ * This exists so the sidebar badge cannot be moved by the search box. The matcher used to build the
+ * list is consumed against whatever it was given, so reading its leftovers after a filtered pass
+ * made the badge grow while typing. Claiming against the unfiltered lists in a throwaway matcher
+ * makes the answer a property of what the user has.
+ */
+export function countSessionOnlyMcpServers(
+	sessionServers: readonly AgentHostMcpServer[],
+	localServers: readonly IWorkbenchMcpServer[],
+	runtimeServers: readonly IMcpServer[],
+): number {
+	const matcher = new ActiveSessionMcpServerMatcher(sessionServers);
+	for (const server of localServers) {
+		matcher.take(getWorkbenchServerMatchKeys(server));
+	}
+	for (const server of runtimeServers) {
+		matcher.take(getRuntimeServerMatchKeys(server));
+	}
+	return matcher.unmatched('').length;
+}
+
 const MCP_GALLERY_ITEM_TEMPLATE_ID = 'mcpGalleryItem';
 
 /** Adapts a gallery MCP server entry to the shared gallery row renderer. */
@@ -1450,8 +1568,7 @@ export class McpListWidget extends Disposable {
 	private addButton!: Button;
 
 	private filteredServers: IWorkbenchMcpServer[] = [];
-	private filteredBuiltinCount = 0;
-	private filteredActiveSessionCount = 0;
+	private totalServerCount = 0;
 	private displayEntries: IMcpListEntry[] = [];
 	private galleryServers: IWorkbenchMcpServer[] = [];
 	private searchQuery: string = '';
@@ -1850,77 +1967,86 @@ export class McpListWidget extends Disposable {
 	private filterServers(): void {
 		const query = this.searchQuery.toLowerCase().trim();
 		const activeSessionResource = this.customizationHarnessService.activeSessionResource.get();
-		const activeSessionMatcher = new ActiveSessionMcpServerMatcher(this.agentHostCustomizationService.getMcpServers(activeSessionResource));
+		const allSessionServers = this.agentHostCustomizationService.getMcpServers(activeSessionResource);
+		const activeSessionMatcher = new ActiveSessionMcpServerMatcher(allSessionServers);
 		const localServerMatcher = new LocalMcpServerMatcher(this.mcpService.servers.get());
 
-		if (query) {
-			this.filteredServers = this.mcpWorkbenchService.local.filter(server =>
-				server.label.toLowerCase().includes(query) ||
-				(server.description?.toLowerCase().includes(query))
-			);
-		} else {
-			this.filteredServers = [...this.mcpWorkbenchService.local];
+		const matchesQuery = (label: string, description?: string): boolean =>
+			!query || label.toLowerCase().includes(query) || !!description?.toLowerCase().includes(query);
+
+		const allLocalServers = this.mcpWorkbenchService.local;
+		this.filteredServers = query
+			? allLocalServers.filter(server => matchesQuery(server.label, server.description))
+			: [...allLocalServers];
+
+		// Dedupe against the *unfiltered* local list: a local server hidden by the query must still
+		// suppress its runtime twin, otherwise searching makes duplicates appear.
+		const localIds = new Set(allLocalServers.map(server => server.id));
+		const allRuntimeServers = this.mcpService.servers.get().filter(server => !localIds.has(server.definition.id));
+		const runtimeServers = allRuntimeServers.filter(server => matchesQuery(server.definition.label));
+
+		// Claim session servers against everything the user has, not against what survived the
+		// search box. `take` is consuming, so a row hidden by a query would otherwise release its
+		// claim for some other row to pick up. Claiming first and filtering second keeps the join a
+		// property of the configuration rather than of what is on screen.
+		const claimedByLocal = new Map<string, AgentHostMcpServer | undefined>();
+		for (const server of allLocalServers) {
+			claimedByLocal.set(server.id, activeSessionMatcher.take(getWorkbenchServerMatchKeys(server)));
+		}
+		const claimedByRuntime = new Map<string, AgentHostMcpServer | undefined>();
+		for (const server of allRuntimeServers) {
+			claimedByRuntime.set(server.definition.id, activeSessionMatcher.take(getRuntimeServerMatchKeys(server)));
 		}
 
-		// Find extension-provided servers not in the local list (e.g. GitHub MCP)
-		const localIds = new Set(this.filteredServers.map(s => s.id));
-		const builtinServers = this.mcpService.servers.get()
-			.filter(s => !localIds.has(s.definition.id))
-			.filter(s => !query || s.definition.label.toLowerCase().includes(query));
-
-		const groups: { scope: LocalMcpServerScope; label: string; icon: ThemeIcon; description: string; entries: Array<IMcpServerItemEntry | IMcpSessionServerItemEntry> }[] = [
-			{ scope: LocalMcpServerScope.Workspace, label: localize('workspaceGroup', "Workspace"), icon: workspaceIcon, description: localize('workspaceGroupDescription', "MCP servers configured in your workspace or reported by the active session."), entries: [] },
-			{ scope: LocalMcpServerScope.User, label: localize('userGroup', "User"), icon: userIcon, description: localize('userGroupDescription', "MCP servers configured in your user settings. Private to you and available across all projects."), entries: [] },
-		];
+		const userEntries: IMcpListEntry[] = [];
+		const workspaceEntries: IMcpListEntry[] = [];
+		const installedEntries: IMcpListEntry[] = [];
+		const builtinEntries: IMcpListEntry[] = [];
 
 		for (const server of this.filteredServers) {
 			const entry: IMcpServerItemEntry = {
 				type: 'server-item',
 				server,
-				activeSessionServer: activeSessionMatcher.take(getWorkbenchServerMatchKeys(server)),
+				activeSessionServer: claimedByLocal.get(server.id),
 				localServer: localServerMatcher.find(getWorkbenchServerMatchKeys(server)),
 			};
-			const scope = server.local?.scope;
-			if (scope === LocalMcpServerScope.Workspace) {
-				groups[0].entries.push(entry);
+			if (server.local?.scope === LocalMcpServerScope.Workspace) {
+				workspaceEntries.push(entry);
 			} else {
-				// User, RemoteUser, or unknown → group under User
-				groups[1].entries.push(entry);
+				userEntries.push(entry);
 			}
 		}
 
-		// Add plugin-provided, extension-provided, and built-in servers.
-		// Servers from the Copilot extension (github.copilot / github.copilot-chat)
-		// are treated as built-in; servers from other extensions go under "Extensions".
-		const collectionSources = new Map(this.mcpRegistry.collections.get().map(c => [c.id, c.source]));
-		const pluginServers: Array<{ server: IMcpServer; activeSessionServer?: AgentHostMcpServer }> = [];
-		const extensionServers: Array<{ server: IMcpServer; activeSessionServer?: AgentHostMcpServer }> = [];
-		const otherBuiltinServers: Array<{ server: IMcpServer; activeSessionServer?: AgentHostMcpServer }> = [];
-		for (const server of builtinServers) {
-			const entry = { server, activeSessionServer: activeSessionMatcher.take(getRuntimeServerMatchKeys(server)) };
-			const source = collectionSources.get(server.collection.id);
-			if (server.collection.id.startsWith(PLUGIN_COLLECTION_PREFIX)) {
-				pluginServers.push(entry);
-			} else if (source instanceof ExtensionIdentifier && !isCopilotExtension(source)) {
-				extensionServers.push(entry);
+		// Extensions and plugins share a section because they are one thing to the user: software
+		// they installed. The distinction still matters when acting on a row (a plugin is
+		// uninstalled as a whole), so it survives on the row, where the header cannot say it.
+		const collectionSources = new Map(this.mcpRegistry.collections.get().map(collection => [collection.id, collection.source]));
+		const builtinOriginLabel = localize('originBuiltin', "Built-in");
+		for (const server of runtimeServers) {
+			const origin = getCollectionOriginLabel(server.collection.id, collectionSources.get(server.collection.id));
+			const sessionServer = claimedByRuntime.get(server.definition.id);
+			if (origin === builtinOriginLabel) {
+				builtinEntries.push(createBuiltinEntry(server, undefined, sessionServer, origin));
 			} else {
-				otherBuiltinServers.push(entry);
+				installedEntries.push(createBuiltinEntry(server, origin, sessionServer, origin));
 			}
 		}
+
+		// Servers only the agent knows about join Built-in rather than getting a section of their
+		// own. They arrive because you are using this agent, which is the same reason VS Code's own
+		// servers are there; the row names which product it was.
 		const activeSessionOnlyServers = activeSessionMatcher.unmatched(query);
-		const activeSessionBuiltinEntries = createBuiltinActiveSessionMcpEntries(activeSessionOnlyServers);
+		builtinEntries.push(...createBuiltinActiveSessionMcpEntries(activeSessionOnlyServers));
 
 		// Show empty state only when there are no servers at all (not when filtered to empty)
-		if (this.filteredServers.length === 0 && builtinServers.length === 0 && activeSessionOnlyServers.length === 0) {
+		if (this.filteredServers.length === 0 && runtimeServers.length === 0 && activeSessionOnlyServers.length === 0) {
 			this.emptyContainer.style.display = 'flex';
 			this.listContainer.style.display = 'none';
 
 			if (this.searchQuery.trim()) {
-				// Search with no results
 				this.emptyText.textContent = localize('noMatchingServers', "No servers match '{0}'", this.searchQuery);
 				this.emptySubtext.textContent = localize('tryDifferentSearch', "Try a different search term");
 			} else {
-				// No servers configured
 				this.emptyText.textContent = localize('noMcpServers', "No MCP servers configured");
 				this.emptySubtext.textContent = localize('addMcpServer', "Add an MCP server configuration to get started");
 			}
@@ -1929,17 +2055,59 @@ export class McpListWidget extends Disposable {
 			this.listContainer.style.display = '';
 		}
 
+		// The agent's own name when this editor is backed by one, so Built-in can admit it holds
+		// that agent's servers too.
+		const agentName = this.customizationHarnessService.getActiveDescriptor().agentName;
+
+		// Ordered from the user's own choices outwards to the product's. Empty sections are skipped
+		// below, so at most four are shown.
+		const groups: { id: McpGroupId; label: string; icon: ThemeIcon; description: string; entries: IMcpListEntry[] }[] = [
+			{
+				id: 'user',
+				label: localize('userServersGroup', "User"),
+				icon: userIcon,
+				description: localize('userServersGroupDescription', "Servers in your user settings. They follow you into every workspace."),
+				entries: userEntries,
+			},
+			{
+				id: 'workspace',
+				label: localize('workspaceServersGroup', "Workspace"),
+				icon: workspaceIcon,
+				description: localize('workspaceServersGroupDescription', "Servers configured in this workspace. They are shared with anyone who opens it."),
+				entries: workspaceEntries,
+			},
+			{
+				id: 'installed',
+				label: localize('installedServersGroup', "Extensions & Plugins"),
+				icon: extensionIcon,
+				description: localize('installedServersGroupDescription', "Servers that came with software you installed. You can turn these off, but not edit them."),
+				entries: installedEntries,
+			},
+			{
+				id: 'builtin',
+				label: localize('builtinServersGroup', "Built-in"),
+				icon: builtinIcon,
+				// Covers the agent's own servers too. A server that arrives because you are using
+				// an agent came with the product just as much as one that ships in VS Code; which
+				// product it was is a distinction the row makes.
+				description: agentName
+					? localize('builtinServersGroupDescriptionNamed', "Servers that come with VS Code or with {0}. You can turn these off, but not edit them here.", agentName)
+					: localize('builtinServersGroupDescription', "Servers that come with VS Code. You can turn these off, but not edit them."),
+				entries: builtinEntries,
+			},
+		];
+
 		const entries: IMcpListEntry[] = [];
 		let isFirst = true;
 		for (const group of groups) {
 			if (group.entries.length === 0) {
 				continue;
 			}
-			const collapsed = this.collapsedGroups.has(group.scope);
+			const collapsed = this.collapsedGroups.has(group.id);
 			entries.push({
 				type: 'group-header',
-				id: `mcp-group-${group.scope}`,
-				scope: group.scope,
+				id: `mcp-group-${group.id}`,
+				scope: group.id,
 				label: group.label,
 				icon: group.icon,
 				count: group.entries.length,
@@ -1953,76 +2121,17 @@ export class McpListWidget extends Disposable {
 			isFirst = false;
 		}
 
-		if (pluginServers.length > 0) {
-			const collapsed = this.collapsedGroups.has('plugin');
-			entries.push({
-				type: 'group-header',
-				id: 'mcp-group-plugin',
-				scope: 'plugin',
-				label: localize('pluginGroup', "Plugins"),
-				icon: pluginIcon,
-				count: pluginServers.length,
-				isFirst,
-				description: localize('pluginGroupDescription', "MCP servers provided by installed plugins."),
-				collapsed,
-			});
-			if (!collapsed) {
-				for (const { server, activeSessionServer } of pluginServers) {
-					entries.push(createBuiltinEntry(server, activeSessionServer));
-				}
-			}
-			isFirst = false;
-		}
-
-		if (extensionServers.length > 0) {
-			const collapsed = this.collapsedGroups.has('extension');
-			entries.push({
-				type: 'group-header',
-				id: 'mcp-group-extension',
-				scope: 'extension',
-				label: localize('extensionGroup', "Extensions"),
-				icon: extensionIcon,
-				count: extensionServers.length,
-				isFirst,
-				description: localize('extensionGroupDescription', "MCP servers contributed by installed VS Code extensions."),
-				collapsed,
-			});
-			if (!collapsed) {
-				for (const { server, activeSessionServer } of extensionServers) {
-					entries.push(createBuiltinEntry(server, activeSessionServer));
-				}
-			}
-			isFirst = false;
-		}
-
-		if (otherBuiltinServers.length > 0 || activeSessionBuiltinEntries.length > 0) {
-			const collapsed = this.collapsedGroups.has('builtin');
-			entries.push({
-				type: 'group-header',
-				id: 'mcp-group-builtin',
-				scope: 'builtin',
-				label: localize('builtInGroup', "Built-in"),
-				icon: builtinIcon,
-				count: otherBuiltinServers.length + activeSessionBuiltinEntries.length,
-				isFirst,
-				description: localize('builtInGroupDescription', "MCP servers built into VS Code. These are available automatically."),
-				collapsed,
-			});
-			if (!collapsed) {
-				for (const { server, activeSessionServer } of otherBuiltinServers) {
-					entries.push(createBuiltinEntry(server, activeSessionServer));
-				}
-				entries.push(...activeSessionBuiltinEntries);
-			}
-			isFirst = false;
-		}
-
 		this.displayEntries = entries;
 		this.list.splice(0, this.list.length, this.displayEntries);
 
-		// Compute sidebar badge directly from the data arrays (same source as group headers)
-		this.filteredBuiltinCount = builtinServers.length;
-		this.filteredActiveSessionCount = activeSessionOnlyServers.length;
+		// The sidebar badge counts what the user *has*, not what the current search matched.
+		// Deriving it from the filtered arrays made typing in the search box silently rewrite the
+		// tab's badge, which reads as servers disappearing. `activeSessionMatcher` cannot answer
+		// this either: it was consumed above, so a throwaway matcher over the unfiltered lists is
+		// what finds the servers only the session knows about.
+		this.totalServerCount = allLocalServers.length
+			+ allRuntimeServers.length
+			+ countSessionOnlyMcpServers(allSessionServers, allLocalServers, allRuntimeServers);
 		this._onDidChangeItemCount.fire(this.itemCount);
 	}
 
@@ -2031,7 +2140,7 @@ export class McpListWidget extends Disposable {
 	 * (the same source used to build group headers).
 	 */
 	get itemCount(): number {
-		return this.filteredServers.length + this.filteredBuiltinCount + this.filteredActiveSessionCount;
+		return this.totalServerCount;
 	}
 
 	/**
diff --git a/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts b/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
index cc8f08413bd43a..63e5e76ae6f101 100644
--- a/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
+++ b/src/vs/workbench/contrib/chat/test/browser/aiCustomization/mcpListWidget.test.ts
@@ -15,7 +15,7 @@ import { ContributionEnablementState } from '../../../common/enablement.js';
 import { ICommandService } from '../../../../../../platform/commands/common/commands.js';
 import { IAgentHostCustomizationService } from '../../../browser/agentSessions/agentHost/agentHostCustomizationService.js';
 import { IAgentPluginService } from '../../../common/plugins/agentPluginService.js';
-import { IMcpService, McpConnectionState } from '../../../../mcp/common/mcpTypes.js';
+import { IMcpServer, IMcpService, IWorkbenchMcpServer, McpConnectionState } from '../../../../mcp/common/mcpTypes.js';
 import { DisableMcpServerForWorkspaceAction, DisableMcpServerGloballyAction, EnableMcpServerForWorkspaceAction, EnableMcpServerGloballyAction } from '../../../../mcp/browser/mcpServerActions.js';
 import {
 	AgentHostMcpServer,
@@ -29,6 +29,8 @@ import {
 	getLocalMcpServerEnablementActions,
 	getMcpServerOutputHandler,
 	getMcpStatusPresentation,
+	countSessionOnlyMcpServers,
+	getAgentOriginLabel,
 	getEnablementTarget,
 	getMcpStatusRenderSignature,
 	isNoteworthyMcpStatus,
@@ -687,6 +689,45 @@ suite('mcpListWidget', () => {
 		});
 	});
 
+	suite('countSessionOnlyMcpServers', () => {
+
+		const installed = [{ id: 'notion', name: 'notion', label: 'Notion' }] as unknown as readonly IWorkbenchMcpServer[];
+		const runtime = [{ definition: { id: 'github-mcp', label: 'GitHub' } }] as unknown as readonly IMcpServer[];
+
+		test('a session server the user also installed is not counted twice', () => {
+			const servers = [createAgentHostServer({ id: 'session/notion', name: 'notion' })];
+			assert.strictEqual(countSessionOnlyMcpServers(servers, installed, runtime), 0);
+		});
+
+		test('a server only the session knows about is counted', () => {
+			const servers = [createAgentHostServer({ id: 'session/node_repl', name: 'node_repl' })];
+			assert.strictEqual(countSessionOnlyMcpServers(servers, installed, runtime), 1);
+		});
+
+		test('the count does not depend on what a search would have hidden', () => {
+			const servers = [
+				createAgentHostServer({ id: 'session/notion', name: 'notion' }),
+				createAgentHostServer({ id: 'session/node_repl', name: 'node_repl' }),
+			];
+			// The same answer whether or not a query would have hidden the installed row that
+			// claims one of them. Deriving this from the filtered lists made the badge grow while
+			// the user typed, which reads as servers appearing from nowhere.
+			assert.deepStrictEqual([
+				countSessionOnlyMcpServers(servers, installed, runtime),
+				countSessionOnlyMcpServers(servers, [], runtime),
+			], [1, 2]);
+		});
+	});
+
+	suite('getAgentOriginLabel', () => {
+
+		test('uses the agent name, and describes the machinery only when there is none', () => {
+			assert.deepStrictEqual(
+				[getAgentOriginLabel('Copilot'), getAgentOriginLabel(undefined)],
+				['Copilot', 'Agent host']);
+		});
+	});
+
 	suite('getMcpStatusRenderSignature', () => {
 		const base: IMcpStatusRenderInput = {
 			rowKey: 'server:mcp.config.workspace/notion:0',
@@ -704,6 +745,8 @@ suite('mcpListWidget', () => {
 			toolsFromCache: true,
 			transport: 'Local',
 			description: 'Issue tracking',
+			origin: 'Workspace',
+			impliedOrigin: 'Built-in',
 		};
 
 		// A different, and differently-typed-where-possible, value for every field. The mapped type
@@ -725,6 +768,8 @@ suite('mcpListWidget', () => {
 			toolsFromCache: false,
 			transport: 'HTTP',
 			description: 'Issue tracking and boards',
+			origin: 'User',
+			impliedOrigin: 'User',
 		};
 
 		const fields = Object.keys(base) as (keyof IMcpStatusRenderInput)[];
diff --git a/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts b/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
index 0edbca8e905b9e..cfb4a02dc05955 100644
--- a/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
+++ b/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
@@ -1686,6 +1686,19 @@ export default defineThemedFixtureGroup({ path: 'chat/aiCustomizations/' }, {
 		}),
 	}),
 
+	// The Built-in section holds the agent's own servers as well as VS Code's, and it is the only
+	// place a row names which product it came with -- so it needs a scrolled variant to be seen.
+	McpServersTabActiveSessionScrolled: defineComponentFixture({
+		labels: { kind: 'screenshot' },
+		render: ctx => renderEditor(ctx, {
+			sessionResource: localSessionResource,
+			isSessionsWindow: true,
+			selectedSection: AICustomizationManagementSection.McpServers,
+			activeSessionMcpServers,
+			scrollToBottom: true,
+		}),
+	}),
+
 	PluginsTabScrolled: defineComponentFixture({
 		labels: { kind: 'screenshot' },
 		render: ctx => renderEditor(ctx, {

From f75bb79aa364b5009d0dba452ef7abe6dab2d91a Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 22:01:29 +0200
Subject: [PATCH 12/13] mcp: feat: give MCP servers a detail pane worth opening

The pane showed a name, a scope, and the same description already on the
row, so opening a server told you nothing you had not just read. It now
answers the two questions a row has no room for: what the server can do,
and what it actually runs.

Tools are listed in full, with their descriptions, because that is the
whole reason to install a server and was otherwise visible only as a
count. A server that has never run says so rather than showing an empty
list that reads as "this server offers nothing", and one that is merely
off is told to turn on instead.

Configuration shows the command or address. Environment variables and
HTTP headers are reduced to their names: knowing a server reads
GITHUB_TOKEN is the useful part, and printing the token itself into a
pane that can be screen-shared is not a trade worth making. It is read
from the installed configuration rather than the resolved launch, so it
is what the user wrote and is available whether or not the server has
ever started.

Configuration sits above the tool list even though tools matter more,
because it is short and fixed-height while the tool list is unbounded.
The other order pushes it below the fold for any server with more than a
handful of tools.

The pane no longer re-derives which agent-host server a row is showing.
The matcher is consuming and order-dependent, so matching again here
starts from zero claims and can adopt a server the list had already given
to a different row -- the exact disagreement this is meant to prevent.
The row's claim now travels with the selection instead.

Status is resolved through the same helpers the row uses. Unlike a row
this pane has no switch, so it does say "Disabled"; Running and Idle stay
unsaid, since whether a lazily-started server holds a process right now
is not why anyone opened it.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../aiCustomizationManagementEditor.ts        |  10 +-
 .../embeddedMcpServerDetail.ts                | 342 ++++++++++++++++--
 .../browser/aiCustomization/mcpListWidget.ts  |  20 +-
 .../media/aiCustomizationManagement.css       |  63 ++++
 ...aiCustomizationManagementEditor.fixture.ts |  46 ++-
 5 files changed, 437 insertions(+), 44 deletions(-)

diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagementEditor.ts b/src/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagementEditor.ts
index 510b77c94bd198..fd99e3c47a74e1 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagementEditor.ts
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/aiCustomizationManagementEditor.ts
@@ -41,7 +41,7 @@ import { AICustomizationManagementEditorInput } from './aiCustomizationManagemen
 import { aiCustomizationManagementSectionRegistry, IAICustomizationManagementSectionWidget } from './aiCustomizationManagementSectionRegistry.js';
 import { AICustomizationListWidget } from './aiCustomizationListWidget.js';
 import { IAICustomizationItemsModel, ITEMS_MODEL_SECTIONS } from './aiCustomizationItemsModel.js';
-import { McpListWidget } from './mcpListWidget.js';
+import { AgentHostMcpServer, McpListWidget } from './mcpListWidget.js';
 import { PluginListWidget } from './pluginListWidget.js';
 import { ToolsListWidget } from './toolsListWidget.js';
 import { AGENT_HOST_COPILOT_CLI_SESSION_TYPE } from '../agentSessions/agentHost/agentHostToolSetEnablementService.js';
@@ -994,8 +994,8 @@ export class AICustomizationManagementEditor extends EditorPane {
 			this.mcpDetailContainer = DOM.append(contentInner, $('.mcp-detail-container'));
 			this.createEmbeddedMcpDetail();
 
-			this.editorDisposables.add(this.mcpListWidget.onDidSelectServer(server => {
-				this.showEmbeddedMcpDetail(server);
+			this.editorDisposables.add(this.mcpListWidget.onDidSelectServer(selection => {
+				this.showEmbeddedMcpDetail(selection.server, selection.activeSessionServer);
 			}));
 
 			this.editorDisposables.add(this.mcpListWidget.onDidRequestShowPlugin(item => {
@@ -3085,7 +3085,7 @@ export class AICustomizationManagementEditor extends EditorPane {
 		}));
 	}
 
-	private async showEmbeddedMcpDetail(server: IWorkbenchMcpServer): Promise<void> {
+	private async showEmbeddedMcpDetail(server: IWorkbenchMcpServer, activeSessionServer?: AgentHostMcpServer): Promise<void> {
 		if (!this.embeddedMcpDetail) {
 			return;
 		}
@@ -3094,7 +3094,7 @@ export class AICustomizationManagementEditor extends EditorPane {
 		this.updateContentVisibility();
 
 		this.mcpDetailDisposables.clear();
-		this.embeddedMcpDetail.setInput(server);
+		this.embeddedMcpDetail.setInput(server, activeSessionServer);
 
 		if (this.dimension) {
 			this.layout(this.dimension);
diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/embeddedMcpServerDetail.ts b/src/vs/workbench/contrib/chat/browser/aiCustomization/embeddedMcpServerDetail.ts
index 5cb83790537354..baf70564f7285c 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/embeddedMcpServerDetail.ts
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/embeddedMcpServerDetail.ts
@@ -4,21 +4,44 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as DOM from '../../../../../base/browser/dom.js';
-import { Disposable } from '../../../../../base/common/lifecycle.js';
-import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { status } from '../../../../../base/browser/ui/aria/aria.js';
+import { Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
+import { autorun, IReader } from '../../../../../base/common/observable.js';
 import { localize } from '../../../../../nls.js';
+import { McpServerType } from '../../../../../platform/mcp/common/mcpPlatformTypes.js';
 import { LocalMcpServerScope } from '../../../../services/mcp/common/mcpWorkbenchManagementService.js';
-import { IMcpWorkbenchService, IWorkbenchMcpServer } from '../../../mcp/common/mcpTypes.js';
-import { userIcon, workspaceIcon } from './aiCustomizationIcons.js';
+import { IMcpServer, IMcpService, IMcpWorkbenchService, IWorkbenchMcpServer, McpConnectionState } from '../../../mcp/common/mcpTypes.js';
+import { isContributionDisabled } from '../../common/enablement.js';
+import { IAgentHostCustomizationService } from '../agentSessions/agentHost/agentHostCustomizationService.js';
+import { CustomizationEnablementKind } from '../../../../../platform/agentHost/common/state/protocol/state.js';
+import type { CustomizationDisabledReason } from '../../../../../platform/agentHost/common/customizationEnablement.js';
+import {
+	AgentHostMcpServer,
+	areMcpToolsFromCache,
+	getActiveSessionServerPresentation,
+	getMcpStatusPresentation,
+	hasKnownMcpTools,
+	isNoteworthyMcpStatus,
+	type McpStatusKind,
+} from './mcpListWidget.js';
 
 const $ = DOM.$;
 
 /**
- * Compact detail view for an MCP server inside the AI Customizations management editor's
- * split-pane host. Renders identity (icon + name + scope) and description.
+ * Detail view for an MCP server inside the AI Customizations management editor's split-pane host.
  *
- * Advanced actions (enable / disable / uninstall / configure) remain accessible via the
- * row's existing context menu, so this component intentionally stays small.
+ * The list row already answers "what is this and is it working". This view exists to answer the
+ * two questions a row has no room for:
+ *
+ * - *What can it do?* -- the tool list, which is the whole reason to install a server and is
+ *   otherwise only visible as a count.
+ * - *What does it run?* -- the command or address, so the user can judge what they have given their
+ *   machine to, and find the file to edit.
+ *
+ * Configuration is rendered above the tool list even though tools matter more, because the
+ * configuration block is short and fixed-height while the tool list is unbounded. Ordering it the
+ * other way would push the configuration below the fold for any server with more than a handful of
+ * tools, making it effectively unreachable.
  */
 export class EmbeddedMcpServerDetail extends Disposable {
 
@@ -26,15 +49,33 @@ export class EmbeddedMcpServerDetail extends Disposable {
 	private readonly headerEl: HTMLElement;
 	private readonly leadingSlotEl: HTMLElement;
 	private readonly nameEl: HTMLElement;
+	private readonly subtitleEl: HTMLElement;
+	private readonly statusEl: HTMLElement;
 	private readonly scopeEl: HTMLElement;
 	private readonly descriptionEl: HTMLElement;
+	private readonly configEl: HTMLElement;
+	private readonly configListEl: HTMLElement;
+	private readonly toolsEl: HTMLElement;
+	private readonly toolsHeadingEl: HTMLElement;
+	private readonly toolsMessageEl: HTMLElement;
+	private readonly toolsListEl: HTMLElement;
 	private readonly emptyEl: HTMLElement;
 
+	private readonly liveRender = this._register(new MutableDisposable());
+
+	private announcedToolCount: number | undefined;
+
 	private current: IWorkbenchMcpServer | undefined;
+	/** The session server the *list row* claimed, not one re-matched here. See render(). */
+	private activeSessionServer: AgentHostMcpServer | undefined;
+	/** Content identity of the last rendered tool list, so an unchanged list is left alone. */
+	private renderedToolsSignature: string | undefined;
 
 	constructor(
 		parent: HTMLElement,
 		@IMcpWorkbenchService private readonly mcpWorkbenchService: IMcpWorkbenchService,
+		@IMcpService private readonly mcpService: IMcpService,
+		@IAgentHostCustomizationService private readonly agentHostCustomizationService: IAgentHostCustomizationService,
 	) {
 		super();
 
@@ -47,22 +88,56 @@ export class EmbeddedMcpServerDetail extends Disposable {
 		const headerText = DOM.append(this.headerEl, $('.embedded-detail-header-text'));
 		this.nameEl = DOM.append(headerText, $('h2.embedded-detail-name'));
 		this.nameEl.setAttribute('role', 'heading');
-		this.scopeEl = DOM.append(headerText, $('.embedded-detail-scope'));
+		this.subtitleEl = DOM.append(headerText, $('.embedded-detail-scope.mcp-detail-subtitle'));
+		this.statusEl = DOM.append(this.subtitleEl, $('span.mcp-server-status'));
+		this.scopeEl = DOM.append(this.subtitleEl, $('span.mcp-detail-scope-text'));
 
 		this.descriptionEl = DOM.append(this.root, $('.embedded-detail-description'));
 
+		this.configEl = DOM.append(this.root, $('.embedded-detail-section.mcp-detail-config'));
+		DOM.append(this.configEl, $('h3.embedded-detail-tools-heading')).textContent = localize('mcpDetailConfiguration', "Configuration");
+		this.configListEl = DOM.append(this.configEl, $('dl.mcp-detail-facts'));
+
+		this.toolsEl = DOM.append(this.root, $('.embedded-detail-tools'));
+		this.toolsHeadingEl = DOM.append(this.toolsEl, $('h3.embedded-detail-tools-heading'));
+		this.toolsMessageEl = DOM.append(this.toolsEl, $('.embedded-detail-tools-message'));
+		this.toolsListEl = DOM.append(this.toolsEl, $('.embedded-detail-tools-list'));
+		this.toolsListEl.setAttribute('role', 'list');
+
 		this.emptyEl = DOM.append(this.root, $('.embedded-detail-empty'));
 		this.emptyEl.textContent = localize('mcpDetailEmpty', "No MCP server selected.");
 
-		// Refresh when the underlying server changes (install state, enablement, etc.).
+		// The agent host reports its own MCP status, and `getMcpServers` is a plain read rather
+		// than an observable, so nothing below would re-run when a session server starts, fails, or
+		// needs sign-in. Without this the pane that exists to explain status is the one surface
+		// that keeps showing the old one.
+		this._register(this.agentHostCustomizationService.onDidChangeCustomizations(() => {
+			if (this.current) {
+				this.render();
+			}
+		}));
+
+		// `undefined` means "something global changed" -- a profile switch, an mcp.json edit, an
+		// enablement write -- and the service rebuilds its server objects when it fires it.
+		// Ignoring it left this pane showing configuration the user had just finished editing,
+		// which is precisely the file this pane exists to point them at.
 		this._register(this.mcpWorkbenchService.onChange(server => {
-			if (this.current && server && server.id === this.current.id) {
-				this.current = server;
-				this.renderItem();
+			if (!this.current) {
+				return;
 			}
+			if (server) {
+				if (server.id === this.current.id) {
+					this.current = server;
+					this.render();
+				}
+				return;
+			}
+			const id = this.current.id;
+			this.current = this.mcpWorkbenchService.local.find(local => local.id === id) ?? this.current;
+			this.render();
 		}));
 
-		this.renderItem();
+		this.render();
 	}
 
 	get element(): HTMLElement {
@@ -81,55 +156,256 @@ export class EmbeddedMcpServerDetail extends Disposable {
 		return this.leadingSlotEl;
 	}
 
-	setInput(server: IWorkbenchMcpServer): void {
+	setInput(server: IWorkbenchMcpServer, activeSessionServer?: AgentHostMcpServer): void {
 		this.current = server;
-		this.renderItem();
+		this.activeSessionServer = activeSessionServer;
+		this.renderedToolsSignature = undefined;
+		// Reset here rather than in render(): render() also runs for unrelated global changes, and
+		// resetting there re-spoke the tool count every time any other server was toggled.
+		this.announcedToolCount = undefined;
+		this.render();
 	}
 
 	clearInput(): void {
 		this.current = undefined;
-		this.renderItem();
+		this.activeSessionServer = undefined;
+		this.announcedToolCount = undefined;
+		this.render();
 	}
 
-	private renderItem(): void {
+	/**
+	 * Configuration comes from the installed server and is static, so it is rendered once. Status
+	 * and tools come from observables on the running server, so they live inside an autorun that is
+	 * torn down whenever the input changes.
+	 */
+	private render(): void {
 		const server = this.current;
 		const hasItem = !!server;
 		this.emptyEl.style.display = hasItem ? 'none' : '';
 		this.root.classList.toggle('is-empty', !hasItem);
+
 		if (!server) {
+			this.liveRender.clear();
 			this.nameEl.textContent = '';
+			this.statusEl.textContent = '';
 			this.scopeEl.textContent = '';
 			this.descriptionEl.textContent = '';
+			DOM.clearNode(this.configListEl);
+			DOM.clearNode(this.toolsListEl);
+			// Emptying the list is not enough: the section keeps its heading, which left a bare
+			// "Configuration" floating above "No MCP server selected".
+			this.configEl.style.display = 'none';
+			this.setToolsMessage(undefined);
 			return;
 		}
 
 		this.nameEl.textContent = server.label || server.name;
 
-		// Scope label
-		const scope = server.local?.scope;
-		const scopeInfo = describeMcpScope(scope);
-		if (scopeInfo) {
-			this.scopeEl.textContent = scopeInfo.label;
-			this.scopeEl.style.display = '';
-		} else {
-			this.scopeEl.replaceChildren();
-			this.scopeEl.style.display = 'none';
-		}
-
-		// Description (single line, but allow wrapping in CSS)
 		const description = (server.description || '').trim();
 		this.descriptionEl.textContent = description;
 		this.descriptionEl.style.display = description ? '' : 'none';
+
+		this.renderConfiguration(server);
+
+		this.liveRender.value = autorun(reader => {
+			const runtime = findRuntimeMcpServer(this.mcpService.servers.read(reader), server);
+			// The row prefers the active session's view of a server, so this pane has to as well,
+			// or the two disagree about the same server.
+			//
+			// It has to be the row's *claim*, not a fresh match. The matcher is consuming: it
+			// answers only while exactly one unclaimed server responds to a key, and the list
+			// drains one matcher across every row in order. Re-matching here starts from zero
+			// claims, so with two rows answering to one name this pane would happily adopt the
+			// server the list had already given to a different row -- the exact disagreement this
+			// is supposed to prevent.
+			this.renderStatus(server, runtime, this.activeSessionServer, reader);
+			this.renderTools(runtime, reader);
+		});
+	}
+
+	private renderStatus(server: IWorkbenchMcpServer, runtime: IMcpServer | undefined, sessionServer: AgentHostMcpServer | undefined, reader: IReader): void {
+		const enablement = runtime?.enablement.read(reader);
+		const locallyDisabled = enablement !== undefined && isContributionDisabled(enablement);
+
+		let kind: McpStatusKind;
+		let disabledReason: CustomizationDisabledReason | undefined;
+		if (sessionServer) {
+			// Resolved through the same helper the row uses rather than a second copy of the rule.
+			const presentation = getActiveSessionServerPresentation(sessionServer);
+			kind = presentation.status;
+			disabledReason = presentation.enabled ? undefined : sessionServer.disabledReason;
+		} else if (locallyDisabled) {
+			kind = 'disabled';
+			disabledReason = { source: 'scope', scope: CustomizationEnablementKind.Global };
+		} else {
+			// An installed server with no runtime counterpart is idle, not statusless. The row says
+			// so; without the same fallback the pane went blank for exactly the servers the
+			// conservative runtime matching declines to match.
+			kind = runtime?.connectionState.read(reader).state ?? McpConnectionState.Kind.Stopped;
+		}
+
+		// This pane has no switch, so "Disabled" is worth saying here. Running and Idle still are
+		// not: whether a lazily-started server happens to hold a process right now is not why
+		// anyone opened this pane, and the Tools section below already says whether it has run.
+		const presentation = isNoteworthyMcpStatus(kind) ? getMcpStatusPresentation(kind, disabledReason) : undefined;
+
+		this.statusEl.className = presentation ? `mcp-server-status ${presentation.className}` : 'mcp-server-status';
+		this.statusEl.textContent = presentation?.label ?? '';
+		this.statusEl.style.display = presentation ? '' : 'none';
+
+		const scope = describeMcpScope(server.local?.scope);
+		this.scopeEl.textContent = scope ?? '';
+		this.scopeEl.style.display = scope ? '' : 'none';
+		this.subtitleEl.classList.toggle('has-separator', !!presentation && !!scope);
+	}
+
+	/**
+	 * Shows what the server actually runs. Values that routinely carry secrets -- environment
+	 * variables and HTTP headers -- are reduced to their names: knowing a server reads
+	 * `GITHUB_TOKEN` is the useful part, and printing the token itself into a pane that can be
+	 * screen-shared is not a trade worth making.
+	 */
+	private renderConfiguration(server: IWorkbenchMcpServer): void {
+		DOM.clearNode(this.configListEl);
+
+		// Read from the installed configuration rather than the running server's resolved launch:
+		// it is what the user wrote, it is available whether or not the server has ever started,
+		// and it does not depend on a runtime match succeeding.
+		const config = server.local?.config ?? server.config;
+		const facts: { label: string; value: string; code?: boolean }[] = [];
+
+		if (config?.type === McpServerType.LOCAL) {
+			facts.push({
+				label: localize('mcpDetailCommand', "Command"),
+				value: [config.command, ...(config.args ?? [])].join(' '),
+				code: true,
+			});
+			if (config.cwd) {
+				facts.push({ label: localize('mcpDetailCwd', "Working directory"), value: config.cwd, code: true });
+			}
+			const envNames = Object.keys(config.env ?? {});
+			if (envNames.length) {
+				facts.push({ label: localize('mcpDetailEnv', "Environment"), value: envNames.join(', '), code: true });
+			}
+		} else if (config?.type === McpServerType.REMOTE) {
+			facts.push({ label: localize('mcpDetailUrl', "Address"), value: config.url, code: true });
+			const headerNames = Object.keys(config.headers ?? {});
+			if (headerNames.length) {
+				facts.push({ label: localize('mcpDetailHeaders', "Headers"), value: headerNames.join(', '), code: true });
+			}
+		}
+
+		const version = server.local?.version;
+		if (version) {
+			facts.push({ label: localize('mcpDetailVersion', "Version"), value: version });
+		}
+
+		this.configEl.style.display = facts.length ? '' : 'none';
+		for (const fact of facts) {
+			DOM.append(this.configListEl, $('dt.mcp-detail-fact-label')).textContent = fact.label;
+			const value = DOM.append(this.configListEl, $('dd.mcp-detail-fact-value'));
+			value.classList.toggle('is-code', !!fact.code);
+			value.textContent = fact.value;
+		}
+	}
+
+	private renderTools(runtime: IMcpServer | undefined, reader: IReader): void {
+		const cacheState = runtime?.cacheState.read(reader);
+		const tools = runtime?.tools.read(reader) ?? [];
+		const enablement = runtime?.enablement.read(reader);
+
+		// This autorun re-runs on every MCP change -- about twice a second while a server retries
+		// -- and tearing the list down mid-drag cancels a selection the user is making over the
+		// tool descriptions this pane exists to let them read. Only rebuild when the rendered
+		// content actually differs, which means the signature has to name every value read below:
+		// a missing one is not a slow render, it is text that silently stops updating.
+		const signature = JSON.stringify([
+			cacheState,
+			enablement,
+			tools.map(tool => [tool.referenceName, tool.definition.description]),
+		]);
+		if (this.renderedToolsSignature === signature) {
+			return;
+		}
+		this.renderedToolsSignature = signature;
+		DOM.clearNode(this.toolsListEl);
+
+		if (!runtime || !hasKnownMcpTools(cacheState)) {
+			// Tools are only known once a server has run at least once. Saying so is more useful
+			// than an empty list, which reads as "this server offers nothing" -- but only a server
+			// that is actually off should be told to turn on, or the pane asks the user to flip a
+			// switch they can see is already flipped.
+			const isOff = enablement !== undefined && isContributionDisabled(enablement);
+			this.toolsHeadingEl.textContent = localize('mcpDetailTools', "Tools");
+			this.setToolsMessage(isOff
+				? localize('mcpDetailToolsUnknown', "Turn this server on to see the tools it provides.")
+				: localize('mcpDetailToolsNotRun', "Tools are listed once this server has run."));
+			return;
+		}
+
+		this.toolsHeadingEl.textContent = tools.length
+			? localize('mcpDetailToolsCount', "Tools ({0})", tools.length)
+			: localize('mcpDetailTools', "Tools");
+
+		if (!tools.length) {
+			this.setToolsMessage(localize('mcpDetailNoTools', "This server does not provide any tools."));
+			return;
+		}
+
+		this.setToolsMessage(areMcpToolsFromCache(cacheState)
+			? localize('mcpDetailToolsCached', "From the last time this server ran.")
+			: undefined);
+
+		for (const tool of tools) {
+			const row = DOM.append(this.toolsListEl, $('.embedded-detail-tool'));
+			row.setAttribute('role', 'listitem');
+			DOM.append(row, $('.embedded-detail-tool-name')).textContent = tool.referenceName;
+			const description = tool.definition.description?.trim();
+			if (description) {
+				DOM.append(row, $('.embedded-detail-tool-description')).textContent = description;
+			}
+		}
+
+		// The autorun re-runs on every connection change; only speak when the count moves,
+		// otherwise the pane repeats itself at a screen reader for no new information.
+		if (this.announcedToolCount !== tools.length) {
+			this.announcedToolCount = tools.length;
+			status(tools.length === 1
+				? localize('mcpDetailToolsLoadedOne', "1 tool")
+				: localize('mcpDetailToolsLoaded', "{0} tools", tools.length));
+		}
+	}
+
+	private setToolsMessage(message: string | undefined): void {
+		this.toolsMessageEl.textContent = message ?? '';
+		this.toolsMessageEl.style.display = message ? '' : 'none';
+	}
+}
+
+/**
+ * Finds the running counterpart of an installed server.
+ *
+ * Conservative on purpose: a candidate is only accepted when exactly one runtime server answers to
+ * a key. Showing nothing is better than attributing one server's tools to another.
+ */
+function findRuntimeMcpServer(servers: readonly IMcpServer[], server: IWorkbenchMcpServer): IMcpServer | undefined {
+	const keys = [server.id, server.name, server.label].filter((key): key is string => !!key);
+	for (const key of new Set(keys)) {
+		const matches = servers.filter(candidate => candidate.definition.id === key || candidate.definition.label === key);
+		if (matches.length === 1) {
+			return matches[0];
+		}
 	}
+	return undefined;
 }
 
-function describeMcpScope(scope: LocalMcpServerScope | undefined): { label: string; icon: ThemeIcon } | undefined {
+function describeMcpScope(scope: LocalMcpServerScope | undefined): string | undefined {
 	switch (scope) {
 		case LocalMcpServerScope.Workspace:
-			return { label: localize('mcpScopeWorkspace', "Workspace"), icon: workspaceIcon };
+			return localize('mcpScopeWorkspace', "Workspace");
 		case LocalMcpServerScope.User:
 		case LocalMcpServerScope.RemoteUser:
-			return { label: localize('mcpScopeUser', "User"), icon: userIcon };
+			return localize('mcpScopeUser', "User");
 		default:
 			return undefined;
 	}
diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
index ae24c61c33f8f9..33aa302e94948f 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.ts
@@ -1537,11 +1537,23 @@ class McpGalleryItemProvider implements IGalleryItemProvider<IMcpServerItemEntry
 /**
  * Widget that displays a list of MCP servers with marketplace browsing.
  */
+/**
+ * A row's selection, carrying the agent-host server that row claimed.
+ *
+ * The claim travels with the selection rather than being re-derived downstream: the matcher is
+ * consuming and order-dependent, so matching again from scratch can hand a server to a second
+ * consumer that the list had already given to a different row.
+ */
+export interface IMcpServerSelection {
+	readonly server: IWorkbenchMcpServer;
+	readonly activeSessionServer?: AgentHostMcpServer;
+}
+
 export class McpListWidget extends Disposable {
 
 	readonly element: HTMLElement;
 
-	private readonly _onDidSelectServer = this._register(new Emitter<IWorkbenchMcpServer>());
+	private readonly _onDidSelectServer = this._register(new Emitter<IMcpServerSelection>());
 	readonly onDidSelectServer = this._onDidSelectServer.event;
 
 	private readonly _onDidChangeItemCount = this._register(new Emitter<number>());
@@ -1798,7 +1810,11 @@ export class McpListWidget extends Disposable {
 					const server = e.element.server;
 					const isGallery = e.element.marketplace || !server.local;
 					if (isGallery || server.description) {
-						this._onDidSelectServer.fire(server);
+						// The row's own claim travels with the selection. The detail pane must not
+						// re-derive it: ActiveSessionMcpServerMatcher is consuming and
+						// order-dependent, so a fresh match there could adopt a server this list
+						// had already given to a different row.
+						this._onDidSelectServer.fire({ server, activeSessionServer: e.element.activeSessionServer });
 					}
 				} else if (e.element.type === 'session-server-item') {
 					this.openActiveSessionServerOptions(e.element.server);
diff --git a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
index f181900fe75e25..938a0cb1263f54 100644
--- a/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
+++ b/src/vs/workbench/contrib/chat/browser/aiCustomization/media/aiCustomizationManagement.css
@@ -1411,6 +1411,7 @@ casing is also not a transform that survives translation. */
 
 .ai-customization-management-editor .ai-customization-embedded-detail.is-empty .embedded-detail-header,
 .ai-customization-management-editor .ai-customization-embedded-detail.is-empty .embedded-detail-description,
+.ai-customization-management-editor .ai-customization-embedded-detail.is-empty .embedded-detail-section,
 .ai-customization-management-editor .ai-customization-embedded-detail.is-empty .embedded-detail-tools {
 	display: none;
 }
@@ -1534,6 +1535,68 @@ casing is also not a transform that survives translation. */
 	overflow: hidden;
 }
 
+/* MCP server detail
+-------------------------------------------------------------------------- */
+
+/* The MCP pane exists to be read: a tool's description is the thing that tells you what it does,
+so it is not clamped here the way it is in the browse list. */
+.ai-customization-management-editor .embedded-mcp-detail .embedded-detail-tool-description {
+	display: block;
+	-webkit-line-clamp: none;
+	line-clamp: none;
+	overflow: visible;
+}
+
+.ai-customization-management-editor .embedded-mcp-detail .mcp-detail-subtitle {
+	display: inline-flex;
+	align-items: center;
+	gap: var(--vscode-spacing-size40);
+}
+
+.ai-customization-management-editor .embedded-mcp-detail .mcp-detail-subtitle .mcp-server-status {
+	font-size: inherit;
+}
+
+.ai-customization-management-editor .embedded-mcp-detail .mcp-detail-subtitle.has-separator .mcp-detail-scope-text::before {
+	content: '\00b7';
+	margin-inline-end: var(--vscode-spacing-size40);
+}
+
+.ai-customization-management-editor .embedded-mcp-detail .embedded-detail-section {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+	min-width: 0;
+}
+
+/* Two columns so labels form a scannable edge, collapsing to stacked rows when the pane is too
+narrow for a label column to be worth the space it takes. */
+.ai-customization-management-editor .embedded-mcp-detail .mcp-detail-facts {
+	display: grid;
+	grid-template-columns: minmax(0, max-content) minmax(0, 1fr);
+	gap: var(--vscode-spacing-size40) var(--vscode-spacing-size120);
+	margin: 0;
+	min-width: 0;
+}
+
+.ai-customization-management-editor .embedded-mcp-detail .mcp-detail-fact-label {
+	color: var(--vscode-descriptionForeground);
+	font-size: var(--vscode-agents-fontSize-body2);
+}
+
+.ai-customization-management-editor .embedded-mcp-detail .mcp-detail-fact-value {
+	margin: 0;
+	min-width: 0;
+	font-size: var(--vscode-agents-fontSize-body2);
+	word-break: break-word;
+}
+
+/* A command is something the user may need to copy or compare against a file, so it keeps the
+monospace shape it has everywhere else. */
+.ai-customization-management-editor .embedded-mcp-detail .mcp-detail-fact-value.is-code {
+	font-family: var(--monaco-monospace-font);
+}
+
 /* Models section footer */
 .ai-customization-management-editor .models-content-container .section-footer {
 	flex-shrink: 0;
diff --git a/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts b/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
index cfb4a02dc05955..0b982ca078a794 100644
--- a/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
+++ b/src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts
@@ -1373,9 +1373,9 @@ function renderPluginDisabled(ctx: ComponentFixtureContext, byPolicy: boolean):
 // Embedded compact detail widgets — standalone (no host editor)
 // ============================================================================
 
-function renderEmbeddedMcpDetail(ctx: ComponentFixtureContext, server: IWorkbenchMcpServer | undefined): void {
+function renderEmbeddedMcpDetail(ctx: ComponentFixtureContext, server: IWorkbenchMcpServer | undefined, runtimeServers: readonly unknown[] = []): void {
 	const width = 480;
-	const height = 320;
+	const height = 420;
 	ctx.container.style.width = `${width}px`;
 	ctx.container.style.height = `${height}px`;
 
@@ -1389,6 +1389,16 @@ function renderEmbeddedMcpDetail(ctx: ComponentFixtureContext, server: IWorkbenc
 				override readonly local: IWorkbenchMcpServer[] = server ? [server] : [];
 				override async open() { /* no-op in fixture */ }
 			}());
+			// The pane reads the running server for status and tools, and the agent host for a
+			// session's own view of it, so both have to be present for it to render at all.
+			reg.defineInstance(IMcpService, new class extends mock<IMcpService>() {
+				override readonly servers = constObservable(runtimeServers as never[]);
+				override readonly enablementModel = createFixtureEnablementModel();
+			}());
+			reg.defineInstance(IAgentHostCustomizationService, new class extends mock<IAgentHostCustomizationService>() {
+				override readonly onDidChangeCustomizations = Event.None;
+				override getMcpServers() { return []; }
+			}());
 		},
 	});
 
@@ -1823,13 +1833,41 @@ export default defineThemedFixtureGroup({ path: 'chat/aiCustomizations/' }, {
 	// Workspace-scope server with a description.
 	EmbeddedMcpDetailWorkspace: defineComponentFixture({
 		labels: { kind: 'screenshot' },
-		render: ctx => renderEmbeddedMcpDetail(ctx, makeLocalMcpServer('mcp-postgres', 'PostgreSQL', LocalMcpServerScope.Workspace, 'Database access for the active workspace')),
+		render: ctx => renderEmbeddedMcpDetail(
+			ctx,
+			makeLocalMcpServer('mcp-postgres', 'PostgreSQL', LocalMcpServerScope.Workspace, 'Database access for the active workspace', {
+				type: McpServerType.LOCAL,
+				command: 'npx',
+				args: ['-y', '@modelcontextprotocol/server-postgres'],
+				// Present so the pane can prove it prints only the names of things that carry
+				// secrets, never their values.
+				env: { PGPASSWORD: 'hunter2', PGHOST: 'db.internal' },
+			}),
+			[{
+				definition: { id: 'mcp-postgres', label: 'PostgreSQL' },
+				collection: { id: 'workspace-mcp', label: 'Workspace MCP' },
+				enablement: constObservable(ContributionEnablementState.EnabledProfile),
+				connectionState: constObservable({ state: McpConnectionState.Kind.Stopped }),
+				showOutput() { },
+				cacheState: constObservable(McpServerCacheState.Cached),
+				tools: constObservable([
+					{ referenceName: 'query', definition: { description: 'Run a read-only SQL query against the connected database.' } },
+					{ referenceName: 'list_tables', definition: { description: 'List the tables available in the current schema.' } },
+				]),
+				readDefinitions: () => constObservable({ server: { launch: { type: McpServerTransportType.Stdio } }, collection: undefined }),
+			}]),
 	}),
 
 	// Standalone embedded MCP detail widget — user-scope server.
 	EmbeddedMcpDetailUser: defineComponentFixture({
 		labels: { kind: 'screenshot' },
-		render: ctx => renderEmbeddedMcpDetail(ctx, makeLocalMcpServer('mcp-web-search', 'Web Search', LocalMcpServerScope.User, 'Search the web from any session')),
+		render: ctx => renderEmbeddedMcpDetail(
+			ctx,
+			makeLocalMcpServer('mcp-web-search', 'Web Search', LocalMcpServerScope.User, 'Search the web from any session', {
+				type: McpServerType.REMOTE,
+				url: 'https://mcp.example.com/search',
+				headers: { Authorization: 'Bearer sk-secret' },
+			})),
 	}),
 
 	// Standalone embedded MCP detail widget — empty / no input state.

From 6ea1a348f6594e2b299000e4803b61766df168a6 Mon Sep 17 00:00:00 2001
From: ulugbekna <ulugbekna@gmail.com>
Date: Fri, 14 Aug 2026 22:02:35 +0200
Subject: [PATCH 13/13] mcp: docs: record how the MCP servers list is organized
 and why

Documents the four sections and the question they answer, the status
suppression rules and why the accessible name deliberately differs from
the row, the switch's write rule and the two rows that get no switch, the
claim-before-filter invariant behind both the row join and the sidebar
badge, and the secret-elision rule in the detail pane.

Also records the one thing upstream's enablement model cannot express:
withCustomizationEnablement replaces one kind at a time, so a server held
off at two scopes cannot be turned on everywhere in a single gesture.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 src/vs/sessions/AI_CUSTOMIZATIONS.md | 47 +++++++++++++++++++++++++---
 1 file changed, 42 insertions(+), 5 deletions(-)

diff --git a/src/vs/sessions/AI_CUSTOMIZATIONS.md b/src/vs/sessions/AI_CUSTOMIZATIONS.md
index 626cf7ce2dad29..6394825939544d 100644
--- a/src/vs/sessions/AI_CUSTOMIZATIONS.md
+++ b/src/vs/sessions/AI_CUSTOMIZATIONS.md
@@ -28,7 +28,8 @@ src/vs/workbench/contrib/chat/browser/aiCustomization/
 ├── customizationHarnessService.ts              # Core harness service impl (agent-gated)
 ├── customizationCreatorService.ts              # AI-guided creation flow
 ├── customizationGroupHeaderRenderer.ts         # Collapsible group header renderer
-├── mcpListWidget.ts                            # MCP servers section (Extensions + Built-in groups)
+├── mcpListWidget.ts                            # MCP servers section (grouped by origin)
+├── enablementSwitch.ts                         # Reusable on/off switch for customization rows
 ├── pluginListWidget.ts                         # Agent plugins section
 ├── aiCustomizationIcons.ts                     # Icons
 └── media/
@@ -260,10 +261,24 @@ AHP Remote Server ────────────────────
 
 ### MCP server list active-session controls
 
-The MCP Servers tab merges local/workspace MCP configuration with MCP servers reported by the active agent-host session. When a listed server also exists in the active session, row status follows the session-backed server and lifecycle controls (start/stop) target the agent host. Model-access and sampling-log actions are hidden for session-backed rows because those are not inline session controls. Runtime states render as semantic colored icons rather than text badges: running uses a green check, while stopped has no visual icon. Authentication-required rows expose an inline **Sign In** button, and an actionable error icon opens that server's local or agent-host output.
+The MCP Servers tab merges local/workspace MCP configuration with MCP servers reported by the active agent-host session. When a listed server also exists in the active session, row status follows the session-backed server and lifecycle controls (start/stop) target the agent host. Model-access and sampling-log actions are hidden for session-backed rows because those are not inline session controls. Authentication-required rows expose an inline **Sign In** button, and a failing row exposes an inline **Show Output** button.
+
+Status is a word beside the server's name, with a colour dot so the distinction is never carried by colour alone. It is shown only when it adds something: `Failed`, `Sign-in needed`, `Starting`, and a scope- or plugin-qualified `Disabled (…)`. `Running` and `Idle` are suppressed because MCP servers start lazily — whether one holds a process right now is an implementation detail that flickers and that nobody acts on. A bare `Disabled` is also suppressed on a row that carries a switch, since the switch already says it. The row's **accessible name deliberately keeps** the plain `Disabled`: a screen reader reads the row label without the switch beside it.
 
 For agent-host sessions, the client publishes every known plugin and VS Code-owned MCP server with an explicit global decision derived only from the VS Code profile. The host owns durable workspace and session decisions and resolves their effective enablement. Bundled MCP servers carry their decision by child name because the host discovers them from the synthetic plugin's `.mcp.json`. A session action dispatches only a session decision; the temporary non-session action dispatches a global decision until the full scoped action matrix is available.
 
+#### Row enablement switch
+
+Every row that has an enablement to write carries an on/off switch at its trailing edge, so turning a server off is one predictable target rather than a right-click the user has to guess at. `getEnablementTarget` resolves how a row reads and writes:
+
+- **Which scope is written.** The decisive decision is `enablement[0]`, so the switch replaces *that* kind — this is what actually moves the effective state, and it answers a deliberate workspace or session choice where it was made rather than silently promoting it. When nothing decides the server yet, the switch writes **Global**: an unqualified control means the whole durable answer. Narrower scopes stay explicit, in the context menu. This is deliberately **not** `IAgentHostMcpServer.setEnabled`, which only ever writes the session layer.
+- **Which key is used.** Local enablement is keyed by the *workbench* server's own id — the key `EnableMcpServerGloballyAction` already reads and writes — rather than the matched runtime server's `definition.id`. The runtime match is deliberately conservative and declines whenever two servers answer to one name; a row must not lose its switch, or misreport its status, because of an ambiguity in a lookup it never needed. Built-in rows have no workbench server and use their runtime definition id, which is what their own context menu uses.
+- **Rows held off by two layers** align both, because a switch that leaves a server visibly off after being turned on is a broken switch.
+- **Reads and writes are live.** The render guard cannot cover every decision in an enablement array, so capturing one at render time and writing it back would resurrect a scope the user had since changed.
+- **No switch** on a gallery result (nothing is installed to turn on) or on a server held off by the plugin that owns it (`disabledReason.source === 'plugin'`). The latter cannot be freed by writing its own enablement at all, so it keeps the word `Disabled (Plugin)` and the context menu's **Enable {plugin}** rather than a control that would appear to do nothing.
+
+**Known limitation.** `withCustomizationEnablement` replaces decisions for one kind at a time, so a server held off at both Global and Session cannot be turned "on everywhere" in a single gesture. Writing the deciding kind always moves the *effective* state, but a broader `false` survives and re-asserts itself later — for example in a new session. This matches the context menu's own per-scope semantics; silently deleting a broader durable choice the user made would be worse.
+
 ### Structured Detail Preview
 
 For markdown-backed customizations (`.agent.md`, `SKILL.md`, `.instructions.md`, `.prompt.md`), the management editor opens a **structured preview** by default instead of showing the raw file immediately.
@@ -332,10 +347,24 @@ Provider-supplied customization rows that include an explicit storage origin are
 
 ### MCP Active Session Status
 
-The MCP Servers section combines locally known MCP servers with MCP servers reported by the active agent-host session (`IAgentHostCustomizationService.getMcpServers(activeSessionResource)`). Active-session servers are matched to known workspace, user, extension, plugin, or built-in rows by stable identifiers and display names so the row can show the active session's status, matching `MCP: List Servers`. Active-session servers that do not match any known local/runtime server are appended to the **Workspace** group and counted with the rest of the section.
+The MCP Servers section combines locally known MCP servers with MCP servers reported by the active agent-host session (`IAgentHostCustomizationService.getMcpServers(activeSessionResource)`). Active-session servers are matched to known workspace, user, extension, plugin, or built-in rows by stable identifiers and display names so the row can show the active session's status, matching `MCP: List Servers`.
+
+`getMcpServers` is a plain read rather than an observable, so nothing derived from it re-runs on its own. `ActiveSessionMcpServerReader` folds it into the reactive graph through a signal over `onDidChangeCustomizations`, which is what keeps a row's rendered status — and the accessible name spoken beside it — from describing the past. The row's accessible name is an `IObservable<string>` for the same reason: a row's status changes without the list being spliced.
+
+**Claim before filtering.** `ActiveSessionMcpServerMatcher.take` is consuming, so session servers are claimed against the *unfiltered* server lists and the result is filtered afterwards. Claiming against filtered lists let a row hidden by the search box release its claim for another row to pick up. For the same reason the sidebar badge is computed by `countSessionOnlyMcpServers` over the unfiltered lists in a throwaway matcher: deriving it from the filtered arrays made typing in the search box silently rewrite the tab's badge.
 
 The MCP list uses `WorkbenchList` as its sole scroll owner. Layout uses the widget's rendered content-box dimensions rather than the padded panel's outer dimensions, and the virtual delegate height matches each rendered row variant, including the taller two-line description row. These invariants keep the final row fully reachable at the bottom of the list.
 
+#### Sections
+
+Rows are grouped by one question — *where is this server defined?* — ordered from the user's own choices outwards to the product's: **User**, **Workspace**, **Extensions & Plugins**, **Built-in**. Empty sections are skipped.
+
+Extensions and Plugins share a section because they are one thing as a user experiences them: software they installed. The distinction still matters when acting on a row (a plugin is uninstalled as a whole), so it survives on the row, where the header cannot say it.
+
+Servers only the agent knows about join **Built-in** rather than getting a section of their own: they arrive because you are using that agent, which is the same reason VS Code's own servers are there. The row names which product it was, using `IHarnessDescriptor.agentName` where the harness reports one and falling back to "Agent host" otherwise. `agentName` exists because that name cannot be derived from `label`, which is localized and carries a disambiguating suffix.
+
+Line two of a row is *origin · transport · (error **or** description)*. Origin appears only where the section header does not already answer it, so a row stops repeating what it sits under; a row with nothing else to say falls back to naming its origin anyway, because a gap under the name reads worse than repetition. A failure replaces the description and drops the transport with it.
+
 ### Sidebar Customizations Section
 
 The Agents sidebar `AICustomizationShortcutsWidget` appears as a collapsible, vertically resizable section below the sessions list. Its resize sash is the horizontal separator above the section and uses the same `SplitView` styling as the Checks section in the changes view, with a 4px separator and sash inset on each side. The section's expanded minimum height is 129px, while its initial and maximum height are capped to the rendered content height so the pane does not open with empty space. When collapsed, the section shrinks to its header height and shows the total customization count to the left of the hover-revealed chevron. The collapsed/expanded state is persisted per profile (`StorageScope.PROFILE`) and restored on reload.
@@ -348,9 +377,17 @@ The first sidebar entry is `Overview`, which opens the AI Customization manageme
 
 ### Embedded Detail Editors
 
-The management editor opens inline detail panes for prompt files, MCP servers, and plugins. Prompt-file details use the standard text editor pane. MCP and plugin details render dedicated compact widgets — `EmbeddedMcpServerDetail` and `EmbeddedAgentPluginDetail` — purpose-built for the narrow split-pane host. They show the icon, name, scope/source, and description. Do **not** embed the full extension-editor panes inside the split-pane host: they assume a wide page-level layout and don't shrink cleanly.
+The management editor opens inline detail panes for prompt files, MCP servers, and plugins. Prompt-file details use the standard text editor pane. MCP and plugin details render dedicated compact widgets — `EmbeddedMcpServerDetail` and `EmbeddedAgentPluginDetail` — purpose-built for the narrow split-pane host. Do **not** embed the full extension-editor panes inside the split-pane host: they assume a wide page-level layout and don't shrink cleanly.
+
+`EmbeddedMcpServerDetail` answers the two questions a row has no room for: **what the server can do** (its full tool list with descriptions) and **what it actually runs** (the command or address). Configuration is rendered above the tool list even though tools matter more, because it is short and fixed-height while the tool list is unbounded — the other order pushes it below the fold for any server with more than a handful of tools.
+
+**Environment variable and HTTP header values are never rendered — only their names.** Knowing a server reads `GITHUB_TOKEN` is the useful part; printing the token into a pane that can be screen-shared is not a trade worth making. Configuration is read from the installed configuration rather than the resolved launch, so it is what the user wrote and is available whether or not the server has ever started.
+
+The pane must **not** re-derive which agent-host server a row is showing. `ActiveSessionMcpServerMatcher` is consuming and order-dependent, so matching again here starts from zero claims and can adopt a server the list already gave to a different row. The row's claim travels with the selection instead, via `IMcpServerSelection`.
+
+Unlike a row, this pane has no switch, so it does say `Disabled`. `Running` and `Idle` stay unsaid for the same reason they do on a row.
 
-The MCP detail fixture in `src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts` must open a real server row (not a group header) and use a local server with concrete config so the compact widget's scope/description rendering is covered by screenshots.
+The MCP detail fixture in `src/vs/workbench/test/browser/componentFixtures/sessions/aiCustomizationManagementEditor.fixture.ts` must open a real server row (not a group header) and use a local server with concrete config — including an env var or header, so the name-only rendering of secret-bearing values stays covered by screenshots.
 
 ### Debug Panel