fix(history): prompt on workspace mismatch

src/core/webview/ClineProvider.ts

@@ -98,7 +98,7 @@
 import { fileExistsAtPath } from "../../utils/fs"
 import { setTtsEnabled, setTtsSpeed } from "../../utils/tts"
 import { getWorkspaceGitInfo } from "../../utils/git"
-import { getWorkspacePath } from "../../utils/path"
+import { arePathsEqual, getWorkspacePath } from "../../utils/path"
 import { OrganizationAllowListViolationError } from "../../utils/errors"
 
 import { setPanel } from "../../activate/registerCommands"
@@ -2304,12 +2304,67 @@
 		if (id !== this.getCurrentTask()?.taskId) {
 			// Non-current task.
 			const { historyItem } = await this.getTaskWithId(id)
-			await this.createTaskWithHistoryItem(historyItem) // Clears existing task.
+			const preparedHistoryItem = await this.prepareHistoryItemForResume(historyItem)
+			if (!preparedHistoryItem) {
+				return
+			}
+			await this.createTaskWithHistoryItem(preparedHistoryItem) // Clears existing task.
 		}
 
 		await this.postMessageToWebview({ type: "action", action: "chatButtonClicked" })
 	}
 
+	public async prepareHistoryItemForResume<T extends HistoryItem>(historyItem: T): Promise<T | undefined> {
+		const currentWorkspace = this.cwd
+		const originalWorkspace = historyItem.workspace
+
+		if (!currentWorkspace || !originalWorkspace || arePathsEqual(currentWorkspace, originalWorkspace)) {
+			return historyItem
+		}
+
+		const useCurrentWorkspace = { title: "Use Current Workspace" }
+		const openOriginalWorkspace = { title: "Open Original Workspace" }
+		const selection = await vscode.window.showWarningMessage(
+			`This conversation was created in "${originalWorkspace}", but the current workspace is "${currentWorkspace}". ` +
+				"Choose where to continue. Using the current workspace resets checkpoints created in the original workspace.",
+			{ modal: true },
+			useCurrentWorkspace,
+			openOriginalWorkspace,
+		)
+
+		if (selection?.title === openOriginalWorkspace.title) {
+			await vscode.commands.executeCommand("vscode.openFolder", vscode.Uri.file(originalWorkspace), {
+				forceNewWindow: true,
+			})
+			return undefined
+		}
+
+		if (selection?.title !== useCurrentWorkspace.title) {
+			return undefined
+		}
+
+		await this.resetTaskCheckpointsForWorkspaceChange(historyItem.id)
+		const updatedHistoryItem = { ...historyItem, workspace: currentWorkspace }
+		await this.updateTaskHistory(updatedHistoryItem)
+		return updatedHistoryItem
+	}
+
+	private async resetTaskCheckpointsForWorkspaceChange(taskId: string): Promise<void> {
+		const globalStoragePath = this.contextProxy.globalStorageUri.fsPath
+		const messages = await readTaskMessages({ taskId, globalStoragePath })
+		const messagesWithoutCheckpoints = messages.filter(
+			(message) => !(message.type === "say" && message.say === "checkpoint_saved"),
+		)
+		const { getTaskDirectoryPath } = await import("../../utils/storage")
+		const taskDir = await getTaskDirectoryPath(globalStoragePath, taskId)
+
+		await fs.rm(path.join(taskDir, "checkpoints"), { recursive: true, force: true })
+
+		if (messagesWithoutCheckpoints.length !== messages.length) {
+			await saveTaskMessages({ messages: messagesWithoutCheckpoints, taskId, globalStoragePath })
+		}
+	}
+
 	async exportTaskWithId(id: string) {
 		const { historyItem, apiConversationHistory } = await this.getTaskWithId(id)
 		const fileName = getTaskFileName(historyItem.ts)

src/core/webview/__tests__/ClineProvider.history-workspace.spec.ts

@@ -0,0 +1,134 @@
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import * as vscode from "vscode"
+
+import type { HistoryItem } from "@roo-code/types"
+
+import { ClineProvider } from "../ClineProvider"
+
+const historyItem = (workspace: string): HistoryItem => ({
+	id: "task-1602",
+	number: 1,
+	ts: 1,
+	task: "Continue in another worktree",
+	tokensIn: 0,
+	tokensOut: 0,
+	cacheWrites: 0,
+	cacheReads: 0,
+	totalCost: 0,
+	workspace,
+})
+
+const createProvider = (workspace: string) => {
+	const provider = Object.create(ClineProvider.prototype) as ClineProvider
+	Object.defineProperty(provider, "currentWorkspacePath", { value: workspace, writable: true })
+	return provider
+}
+
+describe("ClineProvider historical workspace selection", () => {
+	afterEach(() => {
+		vi.restoreAllMocks()
+	})
+
+	it("keeps a history item unchanged when it already belongs to the current workspace", async () => {
+		const provider = createProvider("/current/workspace")
+		const prompt = vi.spyOn(vscode.window, "showWarningMessage")
+		const item = historyItem("/current/workspace")
+
+		await expect(provider.prepareHistoryItemForResume(item)).resolves.toBe(item)
+		expect(prompt).not.toHaveBeenCalled()
+	})
+
+	it("cancels restoration without mutating history when the mismatch prompt is dismissed", async () => {
+		const provider = createProvider("/current/workspace")
+		vi.spyOn(vscode.window, "showWarningMessage").mockResolvedValue(undefined)
+		provider["resetTaskCheckpointsForWorkspaceChange"] = vi.fn()
+		provider.updateTaskHistory = vi.fn()
+
+		await expect(provider.prepareHistoryItemForResume(historyItem("/old/worktree"))).resolves.toBeUndefined()
+		expect(provider["resetTaskCheckpointsForWorkspaceChange"]).not.toHaveBeenCalled()
+		expect(provider.updateTaskHistory).not.toHaveBeenCalled()
+	})
+
+	it("opens the original workspace in a new window without restoring the task", async () => {
+		const provider = createProvider("/current/workspace")
+		vi.spyOn(vscode.window, "showWarningMessage").mockResolvedValue({ title: "Open Original Workspace" })
+		const executeCommand = vi.spyOn(vscode.commands, "executeCommand").mockResolvedValue(undefined)
+
+		await expect(provider.prepareHistoryItemForResume(historyItem("/old/worktree"))).resolves.toBeUndefined()
+		expect(executeCommand).toHaveBeenCalledWith(
+			"vscode.openFolder",
+			expect.objectContaining({ fsPath: "/old/worktree" }),
+			{ forceNewWindow: true },
+		)
+	})
+
+	it("moves the task to the current workspace and resets workspace-specific checkpoints", async () => {
+		const provider = createProvider("/current/workspace")
+		vi.spyOn(vscode.window, "showWarningMessage").mockResolvedValue({ title: "Use Current Workspace" })
+		provider["resetTaskCheckpointsForWorkspaceChange"] = vi.fn().mockResolvedValue(undefined)
+		provider.updateTaskHistory = vi.fn().mockResolvedValue([])
+		const item = historyItem("/old/worktree")
+
+		await expect(provider.prepareHistoryItemForResume(item)).resolves.toEqual({
+			...item,
+			workspace: "/current/workspace",
+		})
+		expect(provider["resetTaskCheckpointsForWorkspaceChange"]).toHaveBeenCalledWith(item.id)
+		expect(provider.updateTaskHistory).toHaveBeenCalledWith({ ...item, workspace: "/current/workspace" })
+	})
+
+	it("restores history with the workspace selected by the mismatch prompt", async () => {
+		const provider = createProvider("/current/workspace")
+		const original = historyItem("/old/worktree")
+		const prepared = { ...original, workspace: "/current/workspace" }
+		provider.getCurrentTask = vi.fn().mockReturnValue(undefined)
+		provider.getTaskWithId = vi.fn().mockResolvedValue({ historyItem: original })
+		provider.prepareHistoryItemForResume = vi.fn().mockResolvedValue(prepared)
+		provider.createTaskWithHistoryItem = vi.fn().mockResolvedValue({})
+		provider.postMessageToWebview = vi.fn().mockResolvedValue(true)
+
+		await provider.showTaskWithId(original.id)
+
+		expect(provider.createTaskWithHistoryItem).toHaveBeenCalledWith(prepared)
+		expect(provider.postMessageToWebview).toHaveBeenCalledWith({
+			type: "action",
+			action: "chatButtonClicked",
+		})
+	})
+
+	it("removes the old checkpoint repository and checkpoint-only chat rows", async () => {
+		const storagePath = await fs.mkdtemp(path.join(os.tmpdir(), "zoo-history-workspace-"))
+		const taskDir = path.join(storagePath, "tasks", "task-1602")
+		const checkpointsDir = path.join(taskDir, "checkpoints")
+		await fs.mkdir(checkpointsDir, { recursive: true })
+		await fs.writeFile(path.join(checkpointsDir, "HEAD"), "old checkpoint")
+		await fs.writeFile(
+			path.join(taskDir, "ui_messages.json"),
+			JSON.stringify([
+				{ type: "say", say: "task", ts: 1, text: "Continue" },
+				{ type: "say", say: "checkpoint_saved", ts: 2, text: "old-hash" },
+				{ type: "say", say: "text", ts: 3, text: "Still useful" },
+			]),
+		)
+
+		const provider = createProvider("/current/workspace")
+		Object.defineProperty(provider, "contextProxy", {
+			value: { globalStorageUri: { fsPath: storagePath } },
+		})
+
+		try {
+			await provider["resetTaskCheckpointsForWorkspaceChange"]("task-1602")
+
+			await expect(fs.stat(checkpointsDir)).rejects.toMatchObject({ code: "ENOENT" })
+			const messages = JSON.parse(await fs.readFile(path.join(taskDir, "ui_messages.json"), "utf8"))
+			expect(messages).toMatchObject([
+				{ type: "say", say: "task", text: "Continue" },
+				{ type: "say", say: "text", text: "Still useful" },
+			])
+		} finally {
+			await fs.rm(storagePath, { recursive: true, force: true })
+		}
+	})
+})

src/extension/api.ts

@@ -218,7 +218,11 @@
 		await this.waitForWebviewLaunch(5_000)
 
 		const { historyItem } = await this.sidebarProvider.getTaskWithId(taskId)
-		await this.sidebarProvider.createTaskWithHistoryItem(historyItem)
+		const preparedHistoryItem = await this.sidebarProvider.prepareHistoryItemForResume(historyItem)
+		if (!preparedHistoryItem) {
+			return
+		}
+		await this.sidebarProvider.createTaskWithHistoryItem(preparedHistoryItem)
 
 		if (this.sidebarProvider.viewLaunched) {
 			await this.sidebarProvider.postMessageToWebview({ type: "action", action: "chatButtonClicked" })