Copilot · Sep 29, 2026 · Sep 29, 2026 · Sep 29, 2026 · Sep 29, 2026
diff --git a/src/@types/vscode.proposed.authIssuers.d.ts b/src/@types/vscode.proposed.authIssuers.d.ts
@@ -4,6 +4,9 @@
  *--------------------------------------------------------------------------------------------*/
 
 declare module 'vscode' {
+
+	// https://github.com/microsoft/vscode/issues/248775
+
 	export interface AuthenticationSession {
 		/**
 		 * The authorization server that issued this session, when provided by the authentication provider.

diff --git a/src/@types/vscode.proposed.chatParticipantAdditions.d.ts b/src/@types/vscode.proposed.chatParticipantAdditions.d.ts
@@ -49,10 +49,15 @@ declare module 'vscode' {
 		ranges: Range[];
 	}
 
+	/** The Auto routing tier a request was resolved with. */
+	export type ChatAutoModeTier = 'efficiency' | 'balance' | 'intelligence' | 'fast';
+
 	export class ChatResponseTextEditPart {
 		uri: Uri;
 		edits: TextEdit[];
 		isDone?: boolean;
+		/** The Auto routing tier that produced these edits, for edit attribution. */
+		autoTier?: ChatAutoModeTier;
 		constructor(uri: Uri, done: true);
 		constructor(uri: Uri, edits: TextEdit | TextEdit[]);
 	}
@@ -61,6 +66,8 @@ declare module 'vscode' {
 		uri: Uri;
 		edits: NotebookEdit[];
 		isDone?: boolean;
+		/** The Auto routing tier that produced these edits, for edit attribution. */
+		autoTier?: ChatAutoModeTier;
 		constructor(uri: Uri, done: true);
 		constructor(uri: Uri, edits: NotebookEdit | NotebookEdit[]);
 	}

diff --git a/src/@types/vscode.proposed.chatSessionsProvider.d.ts b/src/@types/vscode.proposed.chatSessionsProvider.d.ts
@@ -722,6 +722,8 @@ declare module 'vscode' {
 		};
 		readonly maxInputTokens?: number;
 		readonly maxOutputTokens?: number;
+		/** The total context window, independent of the input and output token limits. */
+		readonly maxContextWindowTokens?: number;
 		readonly capabilities?: {
 			readonly vision?: boolean;
 			readonly toolCalling?: boolean;

diff --git a/src/github/worktree.ts b/src/github/worktree.ts
@@ -6,6 +6,7 @@
 import * as path from 'path';
 import * as vscode from 'vscode';
 import { FolderRepositoryManager } from './folderRepositoryManager';
+import { PullRequestGitHelper } from './pullRequestGitHelper';
 import { PullRequestModel } from './pullRequestModel';
 import { Repository } from '../api/api';
 import { commands } from '../common/executeCommands';
@@ -46,8 +47,7 @@ export async function checkoutPRInWorktree(
 	const parentDir = path.dirname(repoRootPath);
 	const repoFolderName = path.basename(repoRootPath);
 	const defaultWorktreePath = path.join(parentDir, `${repoFolderName}.worktrees`, `pr-${pullRequestModel.number}`);
-	const branchName = prHead.ref;
-	const remoteName = pullRequestModel.remote.remoteName;
+	const isFork = !prHead.repositoryCloneUrl.equals(pullRequestModel.remote.gitProtocol);
 
 	// Ask user for worktree location first (not in progress)
 	const worktreeUri = await vscode.window.showSaveDialog({
@@ -61,7 +61,6 @@ export async function checkoutPRInWorktree(
 	}
 
 	const worktreePath = worktreeUri.fsPath;
-	const trackedBranchName = `${remoteName}/${branchName}`;
 
 	try {
 		// Check if the createWorktree API is available
@@ -76,8 +75,16 @@ export async function checkoutPRInWorktree(
 				title: vscode.l10n.t('Creating worktree for Pull Request #{0}...', pullRequestModel.number),
 			},
 			async () => {
+				const remoteName = isFork
+					? await PullRequestGitHelper.createRemote(repositoryToUse, pullRequestModel.remote, prHead.repositoryCloneUrl)
+					: pullRequestModel.remote.remoteName;
+				const branchName = isFork
+					? await PullRequestGitHelper.calculateUniqueBranchNameForPR(repositoryToUse, pullRequestModel)
+					: prHead.ref;
+				const trackedBranchName = `${remoteName}/${prHead.ref}`;
+
 				// Fetch the PR branch first
-				await repositoryToUse.fetch({ remote: remoteName, ref: branchName });
+				await repositoryToUse.fetch({ remote: remoteName, ref: prHead.ref });
 
 				// Check if the branch already exists locally
 				let branchExists = false;
@@ -122,7 +129,8 @@ export async function checkoutPRInWorktree(
 			await commands.openFolder(worktreeUri, { forceNewWindow: false });
 		}
 	} catch (e) {
-		const errorMessage = e instanceof Error ? e.message : String(e);
+		const stderr = e && typeof e === 'object' ? Reflect.get(e, 'stderr') : undefined;
+		const errorMessage = (typeof stderr === 'string' && stderr.trim()) || (e instanceof Error ? e.message : String(e));
 		Logger.error(`Failed to create worktree: ${errorMessage}`, logId);
 		vscode.window.showErrorMessage(vscode.l10n.t('Failed to create worktree: {0}', errorMessage));
 	}

diff --git a/src/test/github/worktree.test.ts b/src/test/github/worktree.test.ts
@@ -0,0 +1,201 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { default as assert } from 'assert';
+import { createSandbox, SinonSandbox, SinonStub } from 'sinon';
+import * as vscode from 'vscode';
+import { Repository } from '../../api/api';
+import Logger from '../../common/logger';
+import { Protocol } from '../../common/protocol';
+import { Remote } from '../../common/remote';
+import { FolderRepositoryManager } from '../../github/folderRepositoryManager';
+import { IResolvedPullRequestModel, PullRequestModel } from '../../github/pullRequestModel';
+import { checkoutPRInWorktree } from '../../github/worktree';
+import { MockRepository } from '../mocks/mockRepository';
+import { MockTelemetry } from '../mocks/mockTelemetry';
+
+describe('checkoutPRInWorktree', () => {
+	let sandbox: SinonSandbox;
+	let repository: MockRepository & Pick<Repository, 'createWorktree'>;
+	let pullRequest: PullRequestModel & IResolvedPullRequestModel;
+	let cancellation: vscode.CancellationTokenSource;
+	let fetch: SinonStub;
+	let createWorktree: SinonStub;
+	let showError: SinonStub;
+	const worktreeUri = vscode.Uri.file('/worktrees/pr-42');
+	const baseUrl = 'git@github.com:upstream/repo.git';
+
+	beforeEach(async () => {
+		sandbox = createSandbox();
+		cancellation = new vscode.CancellationTokenSource();
+		createWorktree = sandbox.stub().resolves();
+		repository = Object.assign(new MockRepository(), { createWorktree });
+		await repository.addRemote('origin', baseUrl);
+		pullRequest = {
+			number: 42,
+			author: { login: 'contributor' },
+			head: {
+				ref: 'feature',
+				repositoryCloneUrl: new Protocol('https://github.com/contributor/repo.git'),
+			},
+			remote: new Remote('origin', baseUrl, new Protocol(baseUrl)),
+		} as PullRequestModel & IResolvedPullRequestModel;
+		fetch = sandbox.stub(repository, 'fetch').resolves();
+		sandbox.stub(vscode.window, 'showSaveDialog').resolves(worktreeUri);
+		sandbox.stub(vscode.window, 'withProgress').callsFake((_options, task) =>
+			task({ report: () => undefined }, cancellation.token));
+		sandbox.stub(vscode.window, 'showInformationMessage').resolves();
+		showError = sandbox.stub(vscode.window, 'showErrorMessage').resolves();
+		sandbox.stub(Logger, 'error');
+	});
+
+	afterEach(() => {
+		cancellation.dispose();
+		sandbox.restore();
+	});
+
+	async function checkout(repositoryOverride?: Repository) {
+		await checkoutPRInWorktree(
+			new MockTelemetry(),
+			{ repository } as unknown as FolderRepositoryManager,
+			pullRequest,
+			repositoryOverride,
+		);
+	}
+
+	it('creates a fork remote using the base protocol and checks out its branch', async () => {
+		await checkout();
+
+		assert.ok(fetch.calledOnceWithExactly({ remote: 'contributor', ref: 'feature' }));
+		assert.strictEqual(repository.state.remotes[1].fetchUrl, 'git@github.com:contributor/repo');
+		assert.strictEqual(await repository.getConfig('remote.contributor.github-pr-remote'), 'true');
+		assert.ok(createWorktree.calledOnceWithExactly({
+			path: worktreeUri.fsPath,
+			commitish: 'contributor/feature',
+			branch: 'pr/contributor/42',
+		}));
+		assert.ok(showError.notCalled);
+	});
+
+	it('reuses an existing fork remote regardless of its name or protocol', async () => {
+		await repository.addRemote('existing-fork', 'git@github.com:contributor/repo.git');
+		const addRemote = sandbox.spy(repository, 'addRemote');
+
+		await checkout();
+
+		assert.ok(addRemote.notCalled);
+		assert.ok(fetch.calledOnceWithExactly({ remote: 'existing-fork', ref: 'feature' }));
+		assert.strictEqual(createWorktree.firstCall.args[0].commitish, 'existing-fork/feature');
+		assert.ok(showError.notCalled);
+	});
+
+	it('avoids conflicting remote names', async () => {
+		await repository.addRemote('contributor', 'https://github.com/someone-else/repo.git');
+
+		await checkout();
+
+		assert.ok(fetch.calledOnceWithExactly({ remote: 'contributor1', ref: 'feature' }));
+		assert.strictEqual(createWorktree.firstCall.args[0].commitish, 'contributor1/feature');
+		assert.ok(showError.notCalled);
+	});
+
+	it('does not reuse a local main branch for a fork PR from main', async () => {
+		pullRequest.head.ref = 'main';
+		await repository.createBranch('main', true, 'upstream-commit');
+		await repository.createBranch('pr/contributor/42', false, 'existing-pr-commit');
+		const originalHead = repository.state.HEAD;
+
+		await checkout();
+
+		assert.ok(fetch.calledOnceWithExactly({ remote: 'contributor', ref: 'main' }));
+		assert.ok(createWorktree.calledOnceWithExactly({
+			path: worktreeUri.fsPath,
+			commitish: 'contributor/main',
+			branch: 'pr/contributor/42-1',
+		}));
+		assert.strictEqual(repository.state.HEAD, originalHead);
+		assert.strictEqual((await repository.getBranch('main')).commit, 'upstream-commit');
+		assert.ok(showError.notCalled);
+	});
+
+	it('preserves same-repository checkout behavior for a new branch', async () => {
+		pullRequest.head.repositoryCloneUrl = new Protocol('https://github.com/upstream/repo.git');
+		const addRemote = sandbox.spy(repository, 'addRemote');
+
+		await checkout();
+
+		assert.ok(addRemote.notCalled);
+		assert.ok(fetch.calledOnceWithExactly({ remote: 'origin', ref: 'feature' }));
+		assert.ok(createWorktree.calledOnceWithExactly({
+			path: worktreeUri.fsPath,
+			commitish: 'origin/feature',
+			branch: 'feature',
+		}));
+		assert.ok(showError.notCalled);
+	});
+
+	it('preserves same-repository checkout behavior for an existing branch', async () => {
+		pullRequest.head.repositoryCloneUrl = new Protocol(baseUrl);
+		await repository.createBranch('feature', false, 'local-commit');
+
+		await checkout();
+
+		assert.ok(createWorktree.calledOnceWithExactly({
+			path: worktreeUri.fsPath,
+			commitish: 'feature',
+		}));
+		assert.ok(showError.notCalled);
+	});
+
+	it('resolves the fork remote in the explicitly supplied repository', async () => {
+		const otherCreateWorktree = sandbox.stub().resolves();
+		const otherRepository = Object.assign(new MockRepository(), { createWorktree: otherCreateWorktree });
+		await otherRepository.addRemote('other-fork', 'https://github.com/contributor/repo.git');
+		const otherFetch = sandbox.stub(otherRepository, 'fetch').resolves();
+
+		await checkout(otherRepository);
+
+		assert.ok(otherFetch.calledOnceWithExactly({ remote: 'other-fork', ref: 'feature' }));
+		assert.strictEqual(otherCreateWorktree.firstCall.args[0].commitish, 'other-fork/feature');
+		assert.ok(fetch.notCalled);
+		assert.ok(createWorktree.notCalled);
+		assert.ok(showError.notCalled);
+	});
+
+	it('does not create a remote or fetch when the location dialog is cancelled', async () => {
+		(vscode.window.showSaveDialog as SinonStub).resolves(undefined);
+		const addRemote = sandbox.spy(repository, 'addRemote');
+
+		await checkout();
+
+		assert.ok(addRemote.notCalled);
+		assert.ok(fetch.notCalled);
+		assert.ok(createWorktree.notCalled);
+	});
+
+	for (const error of [
+		Object.assign(new Error('Failed to execute git'), { stderr: 'fatal: could not read from remote repository\n' }),
+		{ message: 'Failed to execute git', stderr: 'fatal: could not read from remote repository\n' },
+	]) {
+		it(`surfaces Git stderr from ${error instanceof Error ? 'Error instances' : 'plain objects'}`, async () => {
+			fetch.callsFake(async () => { throw error; });
+
+			await checkout();
+
+			assert.ok(showError.calledOnceWithExactly('Failed to create worktree: fatal: could not read from remote repository'));
+			assert.ok((Logger.error as SinonStub).calledOnceWithExactly(
+				'Failed to create worktree: fatal: could not read from remote repository', 'Worktree'));
+			assert.ok(createWorktree.notCalled);
+		});
+	}
+
+	it('preserves ordinary error messages when Git stderr is empty', async () => {
+		createWorktree.rejects(Object.assign(new Error('Worktree path already exists'), { stderr: ' \n' }));
+
+		await checkout();
+
+		assert.ok(showError.calledOnceWithExactly('Failed to create worktree: Worktree path already exists'));
+	});
+});