test(webview): ClineProvider parallelMode suite with viewStates pruning edges

apps/vscode-e2e/src/suite/restart-persistence.test.ts

@@ -61,6 +61,12 @@ async function runCreate(api: RooCodeAPI): Promise<void> {
 		const createdTaskId: string = taskId
 		await waitFor(() => api.hasTaskUiMessageText(createdTaskId, MARKER))
 
+		// history_item.json is written outside the ui_messages.json flush as well: wait for the
+		// task to appear in history with its completed status stored rather than merely existing.
+		// ClineProvider swallows a failed completed-status write and still reports the task as
+		// completed, so existence alone is not proof the status reached disk.
+		await waitFor(async () => (await api.getTaskHistoryItem(createdTaskId))?.status === "completed")
+
 		const result: PhaseResult = {
 			version: PHASE_RESULT_VERSION,
 			phase: "create",
@@ -103,6 +109,9 @@ async function runVerify(api: RooCodeAPI): Promise<void> {
 		const historyItem = await api.getTaskHistoryItem(taskId)
 		assert.ok(historyItem, "Task history item should be available after restart")
 		assert.ok(historyItem.task.includes("RESTART_PERSISTENCE_SMOKE"), "History title should persist after restart")
+		// The status the create phase waited for must still be the one on disk after the
+		// restart, which is what this smoke test exists to prove.
+		assert.strictEqual(historyItem.status, "completed", "Completed status should persist across restart")
 		await waitForMarkedCompletion(api, taskId)
 
 		await api.resumeTask(taskId)

packages/types/src/__tests__/global-settings.test.ts

@@ -3,6 +3,7 @@ import {
 	DEFAULT_DESTRUCTIVE_COMMAND_GUARD_ENABLED,
 	GLOBAL_SETTINGS_KEYS,
 	globalSettingsSchema,
+	viewStateSchema,
 } from "../global-settings.js"
 
 describe("destructive command guard global setting", () => {
@@ -38,6 +39,35 @@ describe("alwaysDenyUnapprovedCommands global setting", () => {
 		expect(() => globalSettingsSchema.parse({ alwaysDenyUnapprovedCommands: "true" })).toThrow()
 	})
 })
+describe("viewStates global setting", () => {
+	it("accepts a persisted per-view record", () => {
+		const parsed = globalSettingsSchema.parse({
+			viewStates: {
+				"view-1": { mode: "architect", currentApiConfigName: "profile-a", updatedAt: 1_700_000_000_000 },
+			},
+		})
+
+		expect(GLOBAL_SETTINGS_KEYS).toContain("viewStates")
+		expect(parsed.viewStates?.["view-1"]).toEqual({
+			mode: "architect",
+			currentApiConfigName: "profile-a",
+			updatedAt: 1_700_000_000_000,
+		})
+	})
+
+	it("accepts an empty entry because every field is optional", () => {
+		const parsed = globalSettingsSchema.parse({ viewStates: { "view-1": {} } })
+
+		expect(parsed.viewStates?.["view-1"]).toEqual({})
+	})
+
+	it("rejects malformed fields, non-object entries and non-record values", () => {
+		expect(() => globalSettingsSchema.parse({ viewStates: { "view-1": { mode: 7 } } })).toThrow()
+		expect(() => globalSettingsSchema.parse({ viewStates: { "view-1": { updatedAt: "now" } } })).toThrow()
+		expect(() => globalSettingsSchema.parse({ viewStates: { "view-1": "architect" } })).toThrow()
+		expect(() => globalSettingsSchema.parse({ viewStates: "view-1" })).toThrow()
+	})
+})
 
 describe("collapseCommandOutputByDefault global setting", () => {
 	it.each([true, false, undefined])("round-trips %s through the export/import schema", (value) => {
@@ -51,3 +81,69 @@ describe("collapseCommandOutputByDefault global setting", () => {
 		expect(globalSettingsSchema.safeParse({ collapseCommandOutputByDefault: "true" }).success).toBe(false)
 	})
 })
+
+describe("viewStates global setting", () => {
+	it("preserves each webview instance selection through the persisted schema", () => {
+		const parsed = globalSettingsSchema.parse({
+			viewStates: {
+				"session-1": { mode: "code", currentApiConfigName: "default", updatedAt: 1700000000000 },
+				"session-2": { mode: "architect" },
+			},
+		})
+		// Every field has to survive the round trip: a selection the schema drops is
+		// written back as absent, so the next window opens in the default mode.
+		expect(parsed.viewStates).toEqual({
+			"session-1": { mode: "code", currentApiConfigName: "default", updatedAt: 1700000000000 },
+			"session-2": { mode: "architect" },
+		})
+	})
+
+	it("parses a single view state on its own", () => {
+		expect(viewStateSchema.parse({ mode: "ask", currentApiConfigName: "x", updatedAt: 5 })).toEqual({
+			mode: "ask",
+			currentApiConfigName: "x",
+			updatedAt: 5,
+		})
+	})
+
+	it("rejects a numeric mode and names the offending path", () => {
+		// The control first: the same record without the bad field must parse, so a
+		// failure here can only mean the schema rejected that value - not that the record
+		// shape is unsupported or the assertion never ran.
+		expect(globalSettingsSchema.safeParse({ viewStates: { a: { mode: "code" } } }).success).toBe(true)
+
+		const result = globalSettingsSchema.safeParse({ viewStates: { a: { mode: 42 } } })
+
+		expect(result.success).toBe(false)
+		expect(result.error?.issues[0]?.path).toEqual(["viewStates", "a", "mode"])
+	})
+
+	it("rejects a non-string currentApiConfigName and names the offending path", () => {
+		expect(globalSettingsSchema.safeParse({ viewStates: { a: { currentApiConfigName: "x" } } }).success).toBe(true)
+
+		const result = globalSettingsSchema.safeParse({ viewStates: { a: { currentApiConfigName: 7 } } })
+
+		expect(result.success).toBe(false)
+		expect(result.error?.issues[0]?.path).toEqual(["viewStates", "a", "currentApiConfigName"])
+	})
+
+	it("rejects a non-numeric updatedAt and names the offending path", () => {
+		expect(globalSettingsSchema.safeParse({ viewStates: { a: { updatedAt: 1 } } }).success).toBe(true)
+
+		const result = globalSettingsSchema.safeParse({ viewStates: { a: { updatedAt: "1" } } })
+
+		expect(result.success).toBe(false)
+		expect(result.error?.issues[0]?.path).toEqual(["viewStates", "a", "updatedAt"])
+	})
+
+	it("rejects a view state that is not an object", () => {
+		// A bare string under a session id is what a half-migrated store looks like;
+		// accepting it defers the crash to whoever reads the selection back.
+		expect(globalSettingsSchema.safeParse({ viewStates: { a: { mode: "code" } } }).success).toBe(true)
+
+		const result = globalSettingsSchema.safeParse({ viewStates: { a: "code" } })
+
+		expect(result.success).toBe(false)
+		expect(result.error?.issues[0]?.path).toEqual(["viewStates", "a"])
+	})
+})

packages/types/src/__tests__/index.test.ts

@@ -3,6 +3,10 @@
 import { GLOBAL_STATE_KEYS } from "../index.js"
 
 describe("GLOBAL_STATE_KEYS", () => {
+	it("should contain registered durable per-view state", () => {
+		expect(GLOBAL_STATE_KEYS).toContain("viewStates")
+	})
+
 	it("should contain provider settings keys", () => {
 		expect(GLOBAL_STATE_KEYS).toContain("autoApprovalEnabled")
 	})
@@ -13,6 +17,7 @@ describe("GLOBAL_STATE_KEYS", () => {
 
 	it("should not contain secret state keys", () => {
 		expect(GLOBAL_STATE_KEYS).not.toContain("openRouterApiKey")
+		expect(GLOBAL_STATE_KEYS).not.toContain("apiKey")
 	})
 
 	it("should contain OpenAI Compatible base URL setting", () => {

packages/types/src/global-settings.ts

@@ -114,6 +114,15 @@ export const MAX_CHECKPOINT_TIMEOUT_SECONDS = 60
  */
 export const DEFAULT_CHECKPOINT_TIMEOUT_SECONDS = 15
 
+/**
+ * Persisted non-secret selections for a stable webview instance.
+ */
+export const viewStateSchema = z.object({
+	mode: z.string().optional(),
+	currentApiConfigName: z.string().optional(),
+	updatedAt: z.number().optional(),
+})
+
 /**
  * GlobalSettings
  */
@@ -122,6 +131,7 @@ export const globalSettingsSchema = z.object({
 	currentApiConfigName: z.string().optional(),
 	listApiConfigMeta: z.array(providerSettingsEntrySchema).optional(),
 	pinnedApiConfigs: z.record(z.string(), z.boolean()).optional(),
+	viewStates: z.record(z.string(), viewStateSchema).optional(),
 
 	lastShownAnnouncementId: z.string().optional(),
 	customInstructions: z.string().optional(),

packages/types/src/vscode-extension-host.ts

@@ -712,6 +712,7 @@ export interface WebviewMessage {
 		| "themeFixtureProbeResponse"
 		| "diagnosticsResponse"
 	text?: string
+	viewStateId?: string
 	taskId?: string
 	editedMessageContent?: string
 	tab?: "settings" | "history" | "mcp" | "modes" | "chat" | "marketplace" | "cloud"

packages/types/src/vscode.ts

@@ -35,6 +35,14 @@ export const commandIds = [
 	"popoutButtonClicked",
 	"settingsButtonClicked",
 
+	// Editor-tab (popped-out) surface variants of the title-bar buttons. The
+	// shared ids above target the sidebar click origin, so the tab surface
+	// needs its own ids (see registerCommands.ts getTabProvider).
+	"plusButtonClickedInTab",
+	"settingsButtonClickedInTab",
+	"marketplaceButtonClickedInTab",
+	"historyButtonClickedInTab",
+
 	"openInNewTab",
 
 	"newTask",

src/__tests__/extension.spec.ts

@@ -170,7 +170,7 @@ vi.mock("../extension/api", () => ({
 	}),
 }))
 
-vi.mock("../activate/registerCommands", () => ({ openClineInNewTab: vi.fn() }))
+vi.mock("../activate/registerCommands", () => ({ openClineInNewTabForApi: vi.fn() }))
 
 vi.mock("../activate", () => ({
 	handleUri: vi.fn(),
@@ -316,7 +316,7 @@ describe("extension.ts", () => {
 	test("injects a factory instance with this activation's dependencies without reading the sidebar tracker", async () => {
 		vi.resetModules()
 		const { API } = await import("../extension/api")
-		const { openClineInNewTab } = await import("../activate/registerCommands")
+		const { openClineInNewTabForApi } = await import("../activate/registerCommands")
 		const { ClineProviderFactory } = await import("../core/webview/ClineProviderFactory")
 		const { WebviewFocusTracker } = await import("../core/webview/WebviewFocusTracker")
 		const { ClineProvider } = await import("../core/webview/ClineProvider")
@@ -330,14 +330,15 @@ describe("extension.ts", () => {
 		const providerFactory = vi.mocked(API).mock.calls[0][2]
 		expect(providerFactory).toBeInstanceOf(ClineProviderFactory)
 		expect(sidebar.webviewFocusTracker).toBeUndefined()
-		expect(openClineInNewTab).not.toHaveBeenCalled()
-		vi.mocked(openClineInNewTab).mockResolvedValueOnce(sidebar)
+		expect(openClineInNewTabForApi).not.toHaveBeenCalled()
+		vi.mocked(openClineInNewTabForApi).mockResolvedValueOnce(sidebar)
 
 		await expect(providerFactory.createInNewTab()).resolves.toBe(sidebar)
-		expect(openClineInNewTab).toHaveBeenCalledExactlyOnceWith({
+		expect(openClineInNewTabForApi).toHaveBeenCalledExactlyOnceWith({
 			context: mockContext,
 			outputChannel,
 			webviewFocusTracker: tracker,
+			forceNew: true,
 		})
 		tracker?.dispose()
 	})