Merge main into agents/workspace-preselection-telemetry

Preserve upstream archive-nudge and Dev Container changes alongside workspace preselection provenance, acknowledgement, and draft protections. Cover combined Dev Container mode and selection-origin behavior in regression tests.

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

Author: benibenj

src/vs/editor/browser/widget/multiDiffEditor/style.css

@@ -138,7 +138,7 @@
 	&.multiDiffEditor-standard {
 		.multiDiffEntry {
 			.collapse-button {
-				margin: 0 5px;
+				margin: 0 var(--vscode-spacing-size60);
 
 				a {
 					display: block;
@@ -154,7 +154,7 @@
 
 				.header-content {
 					margin: var(--vscode-spacing-size80) 0 0;
-					padding: var(--vscode-spacing-size40) 5px;
+					padding: var(--vscode-spacing-size40) var(--vscode-spacing-size60);
 					border-top: var(--vscode-strokeThickness) solid var(--vscode-multiDiffEditor-border);
 					background: var(--vscode-multiDiffEditor-headerBackground);
 

src/vs/platform/actionWidget/browser/actionList.ts

@@ -1446,15 +1446,14 @@ export class ActionListWidget<T> extends Disposable {
 						if ((el.item as { id?: string })?.id === focusedItemId) {
 							this._list.setFocus([i]);
 							this._list.reveal(i);
-							// Move DOM focus back to the list when the list had it: the splice
-							// above destroyed the previously focused row, leaving DOM focus on
-							// the body.
-							if (listHasFocus) {
-								this._list.domFocus();
-							}
 							break;
 						}
 					}
+					if (listHasFocus) {
+						// The focused row or its toolbar may have been removed by the update.
+						this._focusCheckedOrFirst();
+						this._list.domFocus();
+					}
 				}
 			}
 		}

src/vs/platform/actionWidget/test/browser/actionList.test.ts

@@ -1242,6 +1242,26 @@ suite('ActionListWidget', () => {
 		);
 	});
 
+	test('removing the focused row toolbar restores focus inside the remaining list', () => {
+		const widget = createActionListWidget(disposables, {
+			items: [
+				{ ...action('one'), toolbarActions: [toAction({ id: 'remove', label: 'Remove', run: () => { } })] },
+				action('two'),
+				action('three'),
+			],
+			listOptions: { showFilter: false },
+		});
+		widget.focus();
+		widget.domNode.querySelector<HTMLElement>('.action-list-item-toolbar .action-label')!.focus();
+		widget.updateItems([action('two'), action('three')]);
+
+		assert.deepStrictEqual({
+			focusInside: widget.domNode.contains(document.activeElement),
+			focusedItem: widget.getFocusedElement()?.item?.id,
+			rows: getVisibleRowText(widget),
+		}, { focusInside: true, focusedItem: 'two', rows: ['two', 'three'] });
+	});
+
 	test('refreshing the initial selection stays quiet until hover or keyboard navigation', () => runWithFakedTimers({ useFakeTimers: true }, async () => {
 		const items = [
 			{ ...action('selected'), item: { id: 'selected', checked: true }, hover: { content: 'Selected details' } },

src/vs/platform/actionWidget/test/browser/tabbedActionListWidget.test.ts

@@ -346,6 +346,50 @@ suite('TabbedActionListWidget', () => {
 		widget.hide();
 	});
 
+	for (const focusPanel of [false, true]) {
+		test(`Escape from a detail ${focusPanel ? 'panel' : 'button'} returns to the list before dismissing the picker`, async () => {
+			const { widget, contextView } = createWidget(disposables);
+			const anchor = document.createElement('div');
+			document.body.appendChild(anchor);
+			disposables.add({ dispose: () => anchor.remove() });
+			const button = document.createElement('button');
+			button.textContent = 'Pin Model';
+			widget.show<ITestItem>({
+				user: 'test',
+				anchor,
+				tabs: [{ id: 'Models' }],
+				initialTab: 'Models',
+				showCheckedItemHover: true,
+				createActionList: () => ({
+					items: [{
+						...action('model'),
+						item: { id: 'model', checked: true },
+						hover: { content: button, expandable: true },
+					}],
+					listOptions: { persistentHover: true },
+				}),
+				delegate: { onSelect: () => { }, onHide: () => { } },
+			});
+			const popup = contextView.getContextViewElement();
+			const panel = popup.querySelector<HTMLElement>('.action-list-submenu-panel')!;
+			const focusTarget = focusPanel ? panel : button;
+			focusTarget.focus();
+			focusTarget.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', keyCode: 27, bubbles: true, cancelable: true }));
+			await new Promise<void>(resolve => setTimeout(resolve, 0));
+			const afterFirstEscape = {
+				visible: widget.isVisible,
+				panelHidden: panel.style.display === 'none',
+				listFocused: popup.querySelector('.monaco-list') === document.activeElement,
+			};
+			document.activeElement?.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', keyCode: 27, bubbles: true, cancelable: true }));
+
+			assert.deepStrictEqual({ afterFirstEscape, visibleAfterSecondEscape: widget.isVisible }, {
+				afterFirstEscape: { visible: true, panelHidden: true, listFocused: true },
+				visibleAfterSecondEscape: false,
+			});
+		});
+	}
+
 	for (const motionReduced of [false, true]) {
 		test(`refresh preserves the focused detail control and moves its row with reduced motion ${motionReduced}`, async () => {
 			const { widget, contextView } = createWidget(disposables, motionReduced);

src/vs/platform/agentHost/AGENTS.md

@@ -95,6 +95,10 @@ Agents do **not** maintain the chat catalog, persist membership, know whether a
 
 ### Orchestrator layer
 
+Artifact removal uses the VS Code-only `vscode/removeSessionArtifact` extension RPC with `{ session: string, artifactId: string }` and a void result. Clients gate the optional `removeSessionArtifact(URI, string)` connection method with `supportsAgentHostArtifactRemoval(initializeResult)` (`_meta['vscode.removeSessionArtifact'] === true`). This does not extend the generated AHP protocol.
+
+The shared `node/shared/sessionArtifacts.ts` path serializes artifact mutations per session across tools and direct user requests. Each mutation reads the latest collection, awaits the existing `sessionArtifacts` database metadata write, then publishes `SessionMetaChanged` merged with the latest independent metadata. Failed deletion leaves the artifact visible and retryable; failures are logged and propagated without blocking queued additions. Independent GitHub associations and unrelated artifacts/references are preserved. No model turn or tool invocation is involved in direct user removal.
+
 **`AgentService` (`node/agentService.ts`):**
 - Resolves the `(session, chat)` → `(agent, session URI, chat URI)` mapping for orchestration.
 - Uses `IAgentHostProviderService` for provider ownership and session routing. Its `getProviderForSession` path falls back through the session URI's scheme when a restored session was not associated in this process lifetime.

src/vs/platform/agentHost/browser/agentHostProtocolClient.ts

@@ -19,7 +19,7 @@ import { FileSystemProviderErrorCode, toFileSystemProviderErrorCode } from '../.
 import { ConfigurationTarget, ConfigurationTargetToString, IConfigurationService } from '../../configuration/common/configuration.js';
 import { AgentSession, IAgentCreateChatRequestOptions, IAgentCreateSessionConfig, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IAgentSessionMetadata, AuthenticateParams, AuthenticateResult, IMcpNotification } from '../common/agent.js';
 import { AGENT_HOST_DEBUG_LOGS_CHUNK_BYTES, AGENT_HOST_DEBUG_LOGS_MAX_ENTRIES, IAgentConnection, IAgentHostManagedSettingsDiagnostics, IAgentHostNetworkDiagnosticsInfo, IAgentHostNetworkFetchResult, type AgentHostDebugLogsArtifactKind, type IAgentHostDebugLogsArtifact, type IAgentHostDebugLogsChunk } from '../common/agentService.js';
-import { ClaimAgentHostDetachedWorktreeExtensionMethod, CollectAgentHostDebugLogsExtensionMethod, CreateAgentHostDetachedWorktreeExtensionMethod, DeleteAgentHostDetachedWorktreeExtensionMethod, GetAgentHostSessionStateFileExtensionMethod, ReadAgentHostDebugLogsChunkExtensionMethod, ReconcileAgentHostDetachedWorktreesExtensionMethod, RequestAgentHostWorkspaceTrustExtensionMethod, SetAgentHostDetachedWorktreeArchivedExtensionMethod, supportsAgentHostChatStateFile, type IAgentHostExtensionCommandMap, type IAgentHostExtensionInitializeResult, type IAgentHostExtensionServerCommandMap } from '../common/agentHostExtensionProtocol.js';
+import { ClaimAgentHostDetachedWorktreeExtensionMethod, CollectAgentHostDebugLogsExtensionMethod, CreateAgentHostDetachedWorktreeExtensionMethod, DeleteAgentHostDetachedWorktreeExtensionMethod, GetAgentHostSessionStateFileExtensionMethod, ReadAgentHostDebugLogsChunkExtensionMethod, ReconcileAgentHostDetachedWorktreesExtensionMethod, RemoveSessionArtifactExtensionMethod, RequestAgentHostWorkspaceTrustExtensionMethod, SetAgentHostDetachedWorktreeArchivedExtensionMethod, supportsAgentHostChatStateFile, type IAgentHostExtensionCommandMap, type IAgentHostExtensionInitializeResult, type IAgentHostExtensionServerCommandMap } from '../common/agentHostExtensionProtocol.js';
 import { AMBIENT_AGENT_HOST_AUTHORITY } from '../common/agentHostConnectionsService.js';
 import { createRemoteWatchHandle, type IRemoteWatchHandle } from '../common/agentHostFileSystemProvider.js';
 import { AgentSubscriptionManager, type IActiveSubscriptionInfo, type IAgentSubscription } from '../common/state/agentSubscription.js';
@@ -1320,6 +1320,10 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 		return promise;
 	}
 
+	async removeSessionArtifact(session: URI, artifactId: string): Promise<void> {
+		await this._sendExtensionRequest(RemoveSessionArtifactExtensionMethod, { session: session.toString(), artifactId });
+	}
+
 	async createDetachedWorktree(session: URI, prompt: string): Promise<{ handle: string; worktree: URI }> {
 		const result = await this._sendExtensionRequest(CreateAgentHostDetachedWorktreeExtensionMethod, {
 			session: session.toString(),

src/vs/platform/agentHost/browser/nullAgentHostService.ts

@@ -61,6 +61,7 @@ export class NullAgentHostService implements IAgentHostService {
 	async readDebugLogsChunk(_resource: URI, _position: number): Promise<IAgentHostDebugLogsChunk> { return notSupported(); }
 	async listSessions(): Promise<IAgentSessionMetadata[]> { return []; }
 	async createSession(_config?: IAgentCreateSessionConfig): Promise<URI> { return notSupported(); }
+	async removeSessionArtifact(_session: URI, _artifactId: string): Promise<void> { return notSupported(); }
 	async createDetachedWorktree(_session: URI, _prompt: string): Promise<{ handle: string; worktree: URI }> { return notSupported(); }
 	async claimDetachedWorktree(_handle: string): Promise<void> { return notSupported(); }
 	async setDetachedWorktreeArchived(_handle: string, _archived: boolean): Promise<void> { return notSupported(); }

src/vs/platform/agentHost/common/agent.ts

@@ -860,6 +860,7 @@ export interface IAgentModelInfo {
 export type AgentSignal =
 	| IAgentActionSignal
 	| IAgentModelCallCompletedSignal
+	| IAgentModelCallFinishedSignal
 	| IAgentToolPendingConfirmationSignal
 	| IAgentSubagentStartedSignal
 	| IAgentSubagentResumedSignal
@@ -897,6 +898,27 @@ export interface IAgentModelCallCompletedSignal {
 	readonly parentToolCallId?: string;
 }
 
+export type AgentModelCallFinishedOutcome = 'success' | 'error' | 'cancelled' | 'rejected';
+
+/** Reports the final lifecycle outcome of one dispatched model-call attempt. */
+export interface IAgentModelCallFinishedSignal {
+	readonly kind: 'model_call_finished';
+	/** Target chat channel URI. For inner subagent calls this is the parent chat channel. */
+	readonly resource: URI;
+	/** Host turn identifier owning this model-call attempt. */
+	readonly turnId: string;
+	/** Stable SDK event identifier used to suppress duplicate notifications. */
+	readonly modelCallId: string;
+	/** Monotonic provider-dispatch duration in milliseconds. */
+	readonly dispatchDurationMs: number;
+	readonly outcome: AgentModelCallFinishedOutcome;
+	/** Present only for accepted successful responses. */
+	readonly containsBuiltInFileEditRequest?: boolean;
+	readonly editClassifierVersion: number;
+	/** If set, route the model call to the subagent session belonging to this tool call. */
+	readonly parentToolCallId?: string;
+}
+
 /**
  * A tool has finished collecting parameters and needs the host to decide
  * whether it should run (or, mid-execution, re-confirm). The host applies

src/vs/platform/agentHost/common/agentHostChangesetOperationService.ts

@@ -143,9 +143,8 @@ export interface IAgentHostChangesetOperationService extends IDisposable {
 	 */
 	registerContribution(contribution: IChangesetOperationContribution): IDisposable;
 	/**
-	 * Recomputes and publishes operations for the changesets for a given
-	 * session. If `gitState` is not provided, the current git state will
-	 * be used.
+	 * Recomputes operations using the provided or current Git state.
+	 * Without Git state, clears cached operations but defers initial publication.
 	 */
 	updateOperations(sessionKey: string, changeset?: string, gitState?: ISessionGitState, gitHubState?: ISessionGitHubState): void;
 

src/vs/platform/agentHost/common/agentHostChangesetService.ts

@@ -20,7 +20,7 @@ export const META_CHANGESET_SESSION = 'agentHost.changeset.session';
  */
 export const META_LEGACY_DIFFS = 'diffs';
 
-/** Cached aggregate from Session Changes for every session. */
+/** Cached aggregate from Branch Changes for worktree sessions, otherwise Session Changes. */
 export const META_CHANGES_SUMMARY = 'agentHost.changes';
 
 /**
@@ -39,10 +39,8 @@ export const CHANGESET_DB_METADATA_KEYS: Record<string, true> = {
 };
 
 /**
- * The minimal key set that carries only the small persisted
- * {@link META_CHANGES_SUMMARY} aggregate (no large diff blobs). Requested when a
- * session changeset is ready, so the caller can preserve previously cached
- * counts without loading the diff blobs.
+ * Reads the small persisted aggregate without diff blobs.
+ * Used when both possible summary changesets are ready.
  */
 export const CHANGES_SUMMARY_METADATA_KEYS: Record<string, true> = {
 	[META_CHANGES_SUMMARY]: true,
@@ -176,8 +174,8 @@ export interface IAgentHostChangesetService {
 	 * aggregate should be advertised (loaded session whose `summary.changes`
 	 * the caller already projected, or no live/persisted source).
 	 *
-	 * Prefers live or persisted summary counts, falling back to Session Changes diffs.
-	 * Existing caches are refreshed from Session Changes when opened.
+	 * Prefers live or persisted summary counts, falling back to the isolation-selected changeset.
+	 * Existing caches are refreshed from that changeset when opened.
 	 */
 	computeListEntryChanges(sessionUri: ProtocolURI, metadata: Record<string, string | undefined>): ChangesSummary | undefined;