agentHost: Preserve workspace transition boundaries (#334534)

* Skip workspace trust prompts in Allow All mode

Reuse the effective auto-approval configuration when converting workspace-less sessions so Allow All and global auto-approve bypass trust prompts consistently, including isolated worktree creation. Preserve trust checks for default, assisted, and autopilot modes.

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

* Inline workspace trust bypass checks

Keep the workspace-conversion helper minimal while preserving the SessionPermissionManager public methods and their existing effective configuration behavior.

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

* Localize workspace trust bypass checks

Keep the one-off effective approval decision in workspace conversion and restore session permissions to its prior shape.

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

* agentHost: Preserve workspace transition boundaries

Keep workspace transitions visible across collapsed progress and Agent Host restarts while hiding the internal continuation request. Persist transition state atomically and serialize database mutations so rollback cannot absorb unrelated writes.\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* agentHost: Address workspace transition review feedback

Serialize transition restoration behind earlier turn mapping writes, and preserve access to truncated transition labels with the standard hover service. Avoid the global class-substring selector while retaining compact icon styling.

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

---------

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

Author: sandy081

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

@@ -108,6 +108,8 @@ export type IncomingRequestDisposition =
 export interface IHydrationContext {
 	readonly session: ProtocolURI;
 	readonly chat: ProtocolURI;
+	/** Authoritative value from already-loaded host session metadata, when available. */
+	readonly hasWorkspaceTransitions?: boolean;
 }
 
 /**

src/vs/platform/agentHost/common/meta/agentSystemNotificationMeta.ts

@@ -5,6 +5,8 @@
 
 export const enum AgentSystemNotificationKind {
 	WorktreeCreationFailure = 'worktreeCreationFailure',
+	/** The session successfully changed to a requested workspace. */
+	WorkspaceTransition = 'workspaceTransition',
 	/** An automatic approval review did not finish before its deadline. */
 	AutomaticApprovalReviewTimedOut = 'automaticApprovalReviewTimedOut',
 	/** An automatic approval review stopped before reaching a decision. */
@@ -21,12 +23,18 @@ export const enum AgentSystemNotificationKind {
 	AgentMergePullRequestMerged = 'agentMergePullRequestMerged',
 }
 
+export const enum AgentSystemNotificationWorkspaceKind {
+	Folder = 'folder',
+	Worktree = 'worktree',
+}
+
 export const enum AgentSystemNotificationSeverity {
 	Warning = 'warning',
 }
 
 const knownKinds: ReadonlySet<string> = new Set<string>([
 	AgentSystemNotificationKind.WorktreeCreationFailure,
+	AgentSystemNotificationKind.WorkspaceTransition,
 	AgentSystemNotificationKind.AutomaticApprovalReviewTimedOut,
 	AgentSystemNotificationKind.AutomaticApprovalReviewAborted,
 	AgentSystemNotificationKind.AutomaticApprovalReviewInterrupted,
@@ -43,6 +51,14 @@ interface IHasSystemNotificationMeta {
 export interface IAgentSystemNotificationMeta {
 	readonly kind?: AgentSystemNotificationKind;
 	readonly severity?: AgentSystemNotificationSeverity;
+	readonly workspaceKind?: AgentSystemNotificationWorkspaceKind;
+	readonly workspaceName?: string;
+}
+
+export interface IAgentWorkspaceTransitionRecord {
+	readonly content: string;
+	readonly workspaceKind: AgentSystemNotificationWorkspaceKind;
+	readonly workspaceName: string;
 }
 
 /** Reads recognized Agent Host system-notification metadata. */
@@ -52,13 +68,46 @@ export function readAgentSystemNotificationMeta(source: IHasSystemNotificationMe
 		return {};
 	}
 	const kind = meta['kind'];
+	const workspaceKind = meta['workspaceKind'];
 	return {
 		kind: typeof kind === 'string' && knownKinds.has(kind) ? kind as AgentSystemNotificationKind : undefined,
 		severity: meta['severity'] === AgentSystemNotificationSeverity.Warning ? meta['severity'] : undefined,
+		workspaceKind: workspaceKind === AgentSystemNotificationWorkspaceKind.Folder || workspaceKind === AgentSystemNotificationWorkspaceKind.Worktree ? workspaceKind : undefined,
+		workspaceName: typeof meta['workspaceName'] === 'string' ? meta['workspaceName'] : undefined,
 	};
 }
 
 /** Serializes Agent Host system-notification metadata for the open protocol bag. */
 export function toAgentSystemNotificationMeta(meta: IAgentSystemNotificationMeta): Record<string, unknown> {
 	return { ...meta };
 }
+
+/** Serializes a durable workspace-transition boundary. */
+export function serializeAgentWorkspaceTransition(record: IAgentWorkspaceTransitionRecord): string {
+	return JSON.stringify(record);
+}
+
+/** Parses and validates a durable workspace-transition boundary. */
+export function parseAgentWorkspaceTransition(value: string): IAgentWorkspaceTransitionRecord | undefined {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		return undefined;
+	}
+	if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+		return undefined;
+	}
+	const candidate = parsed as Partial<IAgentWorkspaceTransitionRecord>;
+	if (typeof candidate.content !== 'string'
+		|| typeof candidate.workspaceName !== 'string'
+		|| (candidate.workspaceKind !== AgentSystemNotificationWorkspaceKind.Folder && candidate.workspaceKind !== AgentSystemNotificationWorkspaceKind.Worktree)
+	) {
+		return undefined;
+	}
+	return {
+		content: candidate.content,
+		workspaceKind: candidate.workspaceKind,
+		workspaceName: candidate.workspaceName,
+	};
+}

src/vs/platform/agentHost/common/meta/agentWorkspaceContinuationMeta.ts

@@ -0,0 +1,21 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const AGENT_WORKSPACE_CONTINUATION_META_KEY = 'vscode.chat.workspaceContinuation';
+
+interface IHasAgentWorkspaceContinuationMeta {
+	readonly _meta?: Record<string, unknown>;
+}
+
+/** Whether the message is the internal request that resumes a turn after workspace conversion. */
+export function isAgentWorkspaceContinuationMessage(source: IHasAgentWorkspaceContinuationMeta): boolean {
+	// eslint-disable-next-line local/code-no-untyped-meta-access -- sanctioned first hop into the namespaced workspace-continuation slot; validated here.
+	return source._meta?.[AGENT_WORKSPACE_CONTINUATION_META_KEY] === true;
+}
+
+/** Serializes the workspace-continuation marker for the open protocol bag. */
+export function toAgentWorkspaceContinuationMessageMeta(): Record<string, unknown> {
+	return { [AGENT_WORKSPACE_CONTINUATION_META_KEY]: true };
+}

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

@@ -180,6 +180,27 @@ export interface ISessionDatabase extends IDisposable {
 	 */
 	getTurnDelegations(): Promise<Map<string, string>>;
 
+	/**
+	 * Persists the JSON-serialized successful workspace transition for a turn.
+	 * Idempotent — last writer wins per turn.
+	 */
+	setTurnWorkspaceTransition(turnId: string, transition: string): Promise<void>;
+
+	/**
+	 * Atomically persists converted session metadata and the workspace
+	 * transition associated with its deferred continuation turn.
+	 */
+	setWorkspaceConversion(turnId: string, transition: string, metadata: Readonly<Record<string, string>>): Promise<void>;
+
+	/** Deletes a persisted workspace transition without deleting its owning turn. */
+	deleteTurnWorkspaceTransition(turnId: string): Promise<void>;
+
+	/**
+	 * Returns every persisted workspace transition, keyed by both the turn's
+	 * own id and its provider event id when one has been recorded.
+	 */
+	getTurnWorkspaceTransitions(): Promise<Map<string, string>>;
+
 	/**
 	 * Associates a git checkpoint ref (e.g. `refs/agents/<sid>/checkpoints/turn/N`)
 	 * with a turn. Idempotent — last writer wins per turn.

src/vs/platform/agentHost/common/state/sessionState.ts

@@ -15,6 +15,7 @@ import { decodeBase64, encodeBase64, VSBuffer } from '../../../../base/common/bu
 import { hasKey, type Mutable } from '../../../../base/common/types.js';
 import { URI as ResourceURI } from '../../../../base/common/uri.js';
 import type { IProductService } from '../../../product/common/productService.js';
+import { isAgentWorkspaceContinuationMessage } from '../meta/agentWorkspaceContinuationMeta.js';
 import { readToolCallMeta } from '../meta/agentToolCallMeta.js';
 import { readLegacyTurnError } from './legacyProtocolCompatibility.js';
 import {
@@ -357,10 +358,12 @@ export function withMessageSystemInitiatedLabel(message: Message, label: string)
  *
  * A *visible* system notification (a background-agent completion, an Agent
  * Merge repair prompt) is a real turn and is deliberately not matched.
+ * A hidden workspace-continuation request is also a real provider turn.
  */
 export function isHostNoticeTurn(turn: { readonly message: Message }): boolean {
 	return turn.message.origin.kind === MessageKind.SystemNotification
-		&& (isMessageHiddenFromTranscript(turn.message) || isMessageRequestHiddenFromTranscript(turn.message));
+		&& (isMessageHiddenFromTranscript(turn.message) || isMessageRequestHiddenFromTranscript(turn.message))
+		&& !isAgentWorkspaceContinuationMessage(turn.message);
 }
 
 /** Returns the last turn id that can own file changes, or `undefined` if there is none. */
@@ -2012,6 +2015,12 @@ export const SESSION_META_WORKSPACELESS_KEY = 'workspaceless';
  */
 export const AH_META_WORKSPACELESS_DB_KEY = 'agentHost.workspaceless';
 
+/** Session-database marker indicating that retained turns include workspace-transition boundaries. */
+export const AH_META_HAS_WORKSPACE_TRANSITIONS_DB_KEY = 'agentHost.hasWorkspaceTransitions';
+
+/** Summary metadata mirror of {@link AH_META_HAS_WORKSPACE_TRANSITIONS_DB_KEY}. */
+export const SESSION_META_HAS_WORKSPACE_TRANSITIONS_KEY = 'hasWorkspaceTransitions';
+
 /** Blocks turns for a session whose provider could not be detached from an untrusted working directory. */
 export const AH_META_WORKSPACE_CONVERSION_QUARANTINED_DB_KEY = 'agentHost.workspaceConversionQuarantined';
 
@@ -2073,6 +2082,22 @@ export function withSessionWorkspaceless(meta: SessionSummaryMeta | undefined, w
 	return Object.keys(next).length > 0 ? next : undefined;
 }
 
+/** Whether retained turns in this session include host-owned workspace transitions. */
+export function readSessionHasWorkspaceTransitions(meta: SessionSummaryMeta | undefined): boolean {
+	return meta?.[SESSION_META_HAS_WORKSPACE_TRANSITIONS_KEY] === true;
+}
+
+/** Returns summary metadata with the workspace-transition history marker updated. */
+export function withSessionHasWorkspaceTransitions(meta: SessionSummaryMeta | undefined, hasTransitions: boolean): SessionSummaryMeta | undefined {
+	const next: { [key: string]: unknown } = { ...meta };
+	if (hasTransitions) {
+		next[SESSION_META_HAS_WORKSPACE_TRANSITIONS_KEY] = true;
+	} else {
+		delete next[SESSION_META_HAS_WORKSPACE_TRANSITIONS_KEY];
+	}
+	return Object.keys(next).length > 0 ? next : undefined;
+}
+
 /** Whether the session was first discovered in a provider-native catalog. */
 export function readSessionExternal(meta: SessionSummaryMeta | undefined): boolean {
 	return meta?.[SESSION_META_EXTERNAL_KEY] === true;