feat(settings): dynamic thinking effort experimental toggle (DTE-1)

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

@@ -0,0 +1,19 @@
+import { experimentIds, experimentIdsSchema, experimentsSchema } from "../experiment.js"
+
+describe("dynamicThinkingEffort experiment", () => {
+	it("is part of the experiment id enum", () => {
+		expect(experimentIds).toContain("dynamicThinkingEffort")
+		expect(experimentIdsSchema.safeParse("dynamicThinkingEffort").success).toBe(true)
+	})
+
+	it("parses enabled and disabled states", () => {
+		expect(experimentsSchema.parse({ dynamicThinkingEffort: true })).toEqual({ dynamicThinkingEffort: true })
+		expect(experimentsSchema.parse({ dynamicThinkingEffort: false })).toEqual({ dynamicThinkingEffort: false })
+		expect(experimentsSchema.parse({})).toEqual({})
+	})
+
+	it("rejects non-boolean values", () => {
+		expect(experimentsSchema.safeParse({ dynamicThinkingEffort: "yes" }).success).toBe(false)
+		expect(experimentIdsSchema.safeParse("dynamic-thinking-effort").success).toBe(false)
+	})
+})

packages/types/src/experiment.ts

@@ -12,6 +12,7 @@ export const experimentIds = [
 	"runSlashCommand",
 	"customTools",
 	"parallelToolExecution",
+	"dynamicThinkingEffort",
 ] as const
 
 export const experimentIdsSchema = z.enum(experimentIds)
@@ -28,6 +29,7 @@ export const experimentsSchema = z.object({
 	runSlashCommand: z.boolean().optional(),
 	customTools: z.boolean().optional(),
 	parallelToolExecution: z.boolean().optional(),
+	dynamicThinkingEffort: z.boolean().optional(),
 })
 
 export type Experiments = z.infer<typeof experimentsSchema>

scripts/stryker-diff.mjs

@@ -51,8 +51,14 @@ export const PACKAGE_CONFIGS = [
 		root: "src",
 		sourceRoot: "src/",
 		vitestConfig: "vitest.config.ts",
-		vitestRelated: false,
-		discoverRelatedTests: true,
+		// Use plugin-side related-test discovery: with an explicit STRYKER_TEST_FILES
+		// list, stryker-js 10.0.0 plans static mutants with runtime activation
+		// (stryker-mutator/stryker-js#6144, #6209), which the vitest plugin can only
+		// apply after top-level code has run, producing false Survived results.
+		// Revert to vitestRelated: false / discoverRelatedTests: true once the
+		// upstream planner fix lands.
+		vitestRelated: true,
+		discoverRelatedTests: false,
 		excludedPaths: ["src/esbuild.mjs", "src/eslint.config.mjs", "src/utils/vitest-verbosity.ts"],
 	},
 ]

scripts/stryker-diff.test.mjs

@@ -129,8 +129,11 @@ describe("buildManifest", () => {
 		assert.equal(webview.runRoot, ".")
 		assert.equal(webview.discoverRelatedTests, true)
 		assert.equal(webview.vitestRelated, false)
-		assert.equal(extension.discoverRelatedTests, true)
-		assert.equal(extension.vitestRelated, false)
+		// The extension entry uses plugin-side related discovery while stryker-js 10.0.0
+		// plans static mutants with runtime activation when given explicit test files
+		// (stryker-mutator/stryker-js#6144, #6209); see the entry comment in stryker-diff.mjs.
+		assert.equal(extension.discoverRelatedTests, false)
+		assert.equal(extension.vitestRelated, true)
 	})
 
 	it("returns no packages for tests, barrels, unsupported packages, and type-only changes", () => {

src/core/webview/__tests__/ClineProvider.spec.ts

@@ -1566,6 +1566,38 @@ describe("ClineProvider", () => {
 		expect(state.destructiveCommandGuardEnabled).toBe(false)
 	})
 
+	test("getStateToPostToWebview returns the saved dynamicThinkingEffort experiment when enabled", async () => {
+		await provider.resolveWebviewView(mockWebviewView)
+		await provider.contextProxy.setValue("experiments", {
+			...experimentDefault,
+			dynamicThinkingEffort: true,
+		})
+
+		const state = await provider.getStateToPostToWebview()
+
+		expect(state.experiments).toEqual({ ...experimentDefault, dynamicThinkingEffort: true })
+	})
+
+	test("getStateToPostToWebview returns the saved dynamicThinkingEffort experiment when explicitly disabled", async () => {
+		await provider.resolveWebviewView(mockWebviewView)
+		await provider.contextProxy.setValue("experiments", {
+			...experimentDefault,
+			dynamicThinkingEffort: false,
+		})
+
+		const state = await provider.getStateToPostToWebview()
+
+		expect(state.experiments).toEqual({ ...experimentDefault, dynamicThinkingEffort: false })
+	})
+
+	test("getStateToPostToWebview defaults dynamicThinkingEffort to false when experiments are unset", async () => {
+		await provider.resolveWebviewView(mockWebviewView)
+
+		const state = await provider.getStateToPostToWebview()
+
+		expect(state.experiments).toEqual({ ...experimentDefault, dynamicThinkingEffort: false })
+	})
+
 	test("language is set to VSCode language", async () => {
 		// Mock VSCode language as Spanish
 		;(vscode.env as any).language = "pt-BR"

src/core/webview/__tests__/webviewMessageHandler.spec.ts

@@ -73,6 +73,7 @@ import type { ModelRecord } from "@roo-code/types"
 
 import { webviewMessageHandler } from "../webviewMessageHandler"
 import type { ClineProvider } from "../ClineProvider"
+import { experimentDefault } from "../../../shared/experiments"
 import { flushModels, getModels } from "../../../api/providers/fetchers/modelCache"
 import { getLMStudioModels } from "../../../api/providers/fetchers/lmstudio"
 import { getCommands } from "../../../services/command/commands"
@@ -2273,3 +2274,57 @@ describe("webviewMessageHandler - telemetrySetting", () => {
 		expect(TelemetryService.instance.updateTelemetryState).not.toHaveBeenCalled()
 	})
 })
+
+describe("webviewMessageHandler - experiments", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("persists dynamicThinkingEffort true merged with the saved experiments", async () => {
+		vi.mocked(mockClineProvider.contextProxy.getValue).mockImplementation((key: string) =>
+			key === "experiments" ? { preventFocusDisruption: true } : undefined,
+		)
+
+		await webviewMessageHandler(mockClineProvider, {
+			type: "updateSettings",
+			updatedSettings: { experiments: { dynamicThinkingEffort: true } },
+		})
+
+		expect(mockClineProvider.contextProxy.setValue).toHaveBeenCalledWith("experiments", {
+			preventFocusDisruption: true,
+			dynamicThinkingEffort: true,
+		})
+		expect(mockClineProvider.postStateToWebview).toHaveBeenCalledTimes(1)
+	})
+
+	it("persists dynamicThinkingEffort false over a previously enabled value", async () => {
+		vi.mocked(mockClineProvider.contextProxy.getValue).mockImplementation((key: string) =>
+			key === "experiments" ? { dynamicThinkingEffort: true } : undefined,
+		)
+
+		await webviewMessageHandler(mockClineProvider, {
+			type: "updateSettings",
+			updatedSettings: { experiments: { dynamicThinkingEffort: false } },
+		})
+
+		expect(mockClineProvider.contextProxy.setValue).toHaveBeenCalledWith("experiments", {
+			dynamicThinkingEffort: false,
+		})
+		expect(mockClineProvider.postStateToWebview).toHaveBeenCalledTimes(1)
+	})
+
+	it("persists the experiment defaults when no experiments are saved yet", async () => {
+		vi.mocked(mockClineProvider.contextProxy.getValue).mockReturnValue(undefined)
+
+		await webviewMessageHandler(mockClineProvider, {
+			type: "updateSettings",
+			updatedSettings: { experiments: {} },
+		})
+
+		expect(mockClineProvider.contextProxy.setValue).toHaveBeenCalledWith("experiments", {
+			...experimentDefault,
+			dynamicThinkingEffort: false,
+		})
+		expect(mockClineProvider.postStateToWebview).toHaveBeenCalledTimes(1)
+	})
+})

src/shared/__tests__/experiments.spec.ts

@@ -2,7 +2,7 @@
 
 import type { ExperimentId } from "@roo-code/types"
 
-import { EXPERIMENT_IDS, experimentConfigsMap, experiments as Experiments } from "../experiments"
+import { EXPERIMENT_IDS, experimentConfigsMap, experimentDefault, experiments as Experiments } from "../experiments"
 
 describe("experiments", () => {
 	describe("PREVENT_FOCUS_DISRUPTION", () => {
@@ -22,6 +22,7 @@ describe("experiments", () => {
 				runSlashCommand: false,
 				customTools: false,
 				parallelToolExecution: false,
+				dynamicThinkingEffort: false,
 			}
 			expect(Experiments.isEnabled(experiments, EXPERIMENT_IDS.PREVENT_FOCUS_DISRUPTION)).toBe(false)
 		})
@@ -33,6 +34,7 @@ describe("experiments", () => {
 				runSlashCommand: false,
 				customTools: false,
 				parallelToolExecution: false,
+				dynamicThinkingEffort: false,
 			}
 			expect(Experiments.isEnabled(experiments, EXPERIMENT_IDS.PREVENT_FOCUS_DISRUPTION)).toBe(true)
 		})
@@ -44,6 +46,7 @@ describe("experiments", () => {
 				runSlashCommand: false,
 				customTools: false,
 				parallelToolExecution: false,
+				dynamicThinkingEffort: false,
 			}
 			expect(Experiments.isEnabled(experiments, EXPERIMENT_IDS.PREVENT_FOCUS_DISRUPTION)).toBe(false)
 		})
@@ -66,4 +69,28 @@ describe("experiments", () => {
 			expect(Experiments.isEnabled({ parallelToolExecution: true }, "parallelToolExecution")).toBe(true)
 		})
 	})
+
+	describe("DYNAMIC_THINKING_EFFORT", () => {
+		it("is configured correctly", () => {
+			expect(EXPERIMENT_IDS.DYNAMIC_THINKING_EFFORT).toBe("dynamicThinkingEffort")
+			expect(experimentConfigsMap.DYNAMIC_THINKING_EFFORT).toMatchObject({
+				enabled: false,
+			})
+			// Visible in the Settings panel (showInSettings defaults to true).
+			expect(experimentConfigsMap.DYNAMIC_THINKING_EFFORT.showInSettings).toBeUndefined()
+		})
+
+		it("is disabled by default", () => {
+			expect(experimentDefault.dynamicThinkingEffort).toBe(false)
+			expect(Experiments.isEnabled({}, "dynamicThinkingEffort")).toBe(false)
+		})
+
+		it("returns true when enabled", () => {
+			expect(Experiments.isEnabled({ dynamicThinkingEffort: true }, "dynamicThinkingEffort")).toBe(true)
+		})
+
+		it("returns false when explicitly disabled", () => {
+			expect(Experiments.isEnabled({ dynamicThinkingEffort: false }, "dynamicThinkingEffort")).toBe(false)
+		})
+	})
 })

src/shared/experiments.ts

@@ -6,6 +6,7 @@ export const EXPERIMENT_IDS = {
 	RUN_SLASH_COMMAND: "runSlashCommand",
 	CUSTOM_TOOLS: "customTools",
 	PARALLEL_TOOL_EXECUTION: "parallelToolExecution",
+	DYNAMIC_THINKING_EFFORT: "dynamicThinkingEffort",
 } as const satisfies Record<string, ExperimentId>
 
 type _AssertExperimentIds = AssertEqual<Equals<ExperimentId, Values<typeof EXPERIMENT_IDS>>>
@@ -25,6 +26,7 @@ export const experimentConfigsMap: Record<ExperimentKey, ExperimentConfig> = {
 	CUSTOM_TOOLS: { enabled: false },
 	// TODO: add i18n keys (settings:experimental.PARALLEL_TOOL_EXECUTION.name/.description) in the same PR that sets showInSettings: true
 	PARALLEL_TOOL_EXECUTION: { enabled: false, showInSettings: false },
+	DYNAMIC_THINKING_EFFORT: { enabled: false },
 }
 
 export const experimentDefault = Object.fromEntries(

webview-ui/playwright/gallery/stories.tsx

@@ -185,6 +185,11 @@ export const stories: Record<string, Story> = {
 		const { UISettingsStory } = await import("@/components/settings/__tests__/UISettings.visual.fixture")
 		return <UISettingsStory />
 	},
+	"experimental-settings": async () => {
+		const { ExperimentalSettingsStory } =
+			await import("@/components/settings/__tests__/ExperimentalSettings.visual.fixture")
+		return <ExperimentalSettingsStory />
+	},
 	"ui-settings-long-locale": async () => {
 		const [{ UISettingsStory }, { default: i18next }] = await Promise.all([
 			import("@/components/settings/__tests__/UISettings.visual.fixture"),

webview-ui/src/components/settings/__tests__/ExperimentalSettings.spec.tsx

@@ -1,4 +1,4 @@
-import { render, screen } from "@testing-library/react"
+import { fireEvent, render, screen } from "@testing-library/react"
 
 import { experimentDefault } from "@roo/experiments"
 
@@ -32,4 +32,78 @@ describe("ExperimentalSettings", () => {
 		expect(screen.getByText("settings:experimental.CUSTOM_TOOLS.name")).toBeInTheDocument()
 		expect(screen.queryByText("settings:experimental.PARALLEL_TOOL_EXECUTION.name")).not.toBeInTheDocument()
 	})
+
+	it("renders the dynamic thinking effort toggle", () => {
+		render(<ExperimentalSettings {...defaultProps} />)
+
+		expect(screen.getByText("settings:experimental.DYNAMIC_THINKING_EFFORT.name")).toBeInTheDocument()
+	})
+
+	it("leaves the dynamic thinking effort toggle unchecked when the value is false or omitted", () => {
+		const getCheckbox = () => {
+			const label = screen.getByText("settings:experimental.DYNAMIC_THINKING_EFFORT.name").closest("label")
+			return label?.querySelector("input[type='checkbox']")
+		}
+
+		// Explicit false
+		let result = render(
+			<ExperimentalSettings
+				{...defaultProps}
+				experiments={{ ...experimentDefault, dynamicThinkingEffort: false }}
+			/>,
+		)
+		expect(getCheckbox()).not.toBeNull()
+		expect(getCheckbox()).not.toBeChecked()
+		result.unmount()
+
+		// Omitted (absent from the persisted config)
+		const omitted: Record<string, boolean> = { ...experimentDefault }
+		delete omitted.dynamicThinkingEffort
+		result = render(<ExperimentalSettings {...defaultProps} experiments={omitted} />)
+		expect(getCheckbox()).not.toBeNull()
+		expect(getCheckbox()).not.toBeChecked()
+		result.unmount()
+	})
+
+	it("binds the dynamic thinking effort toggle to setExperimentEnabled", () => {
+		const setExperimentEnabled = vi.fn()
+		render(
+			<ExperimentalSettings
+				{...defaultProps}
+				experiments={{ ...experimentDefault, dynamicThinkingEffort: true }}
+				setExperimentEnabled={setExperimentEnabled}
+			/>,
+		)
+
+		const label = screen.getByText("settings:experimental.DYNAMIC_THINKING_EFFORT.name").closest("label")
+		const checkbox = label?.querySelector("input[type='checkbox']")
+		expect(checkbox).not.toBeNull()
+		expect(checkbox).toBeChecked()
+
+		fireEvent.click(checkbox!)
+
+		expect(setExperimentEnabled).toHaveBeenCalledTimes(1)
+		expect(setExperimentEnabled).toHaveBeenCalledWith("dynamicThinkingEffort", false)
+	})
+
+	it("toggles the dynamic thinking effort on when clicked from the unchecked state", () => {
+		const setExperimentEnabled = vi.fn()
+		render(
+			<ExperimentalSettings
+				{...defaultProps}
+				experiments={{ ...experimentDefault, dynamicThinkingEffort: false }}
+				setExperimentEnabled={setExperimentEnabled}
+			/>,
+		)
+
+		const label = screen.getByText("settings:experimental.DYNAMIC_THINKING_EFFORT.name").closest("label")
+		const checkbox = label?.querySelector("input[type='checkbox']")
+		expect(checkbox).not.toBeNull()
+		expect(checkbox).not.toBeChecked()
+
+		fireEvent.click(checkbox!)
+
+		expect(setExperimentEnabled).toHaveBeenCalledTimes(1)
+		expect(setExperimentEnabled).toHaveBeenCalledWith("dynamicThinkingEffort", true)
+	})
 })

webview-ui/src/components/settings/__tests__/ExperimentalSettings.visual.fixture.tsx

@@ -0,0 +1,28 @@
+import { useState } from "react"
+
+import type { Experiments } from "@roo-code/types"
+
+import { EXPERIMENT_IDS, experimentDefault } from "@roo/experiments"
+
+import { ExperimentalSettings } from "../ExperimentalSettings"
+import { AppProviders } from "../../../../playwright/AppProviders"
+
+export function ExperimentalSettingsStory() {
+	const [experiments, setExperiments] = useState<Experiments>({
+		...experimentDefault,
+		[EXPERIMENT_IDS.DYNAMIC_THINKING_EFFORT]: true,
+	})
+
+	return (
+		<AppProviders>
+			<div
+				data-testid="experimental-settings-story"
+				className="w-[488px] max-w-full rounded-lg border border-vscode-panel-border bg-vscode-editor-background p-4 text-vscode-editor-foreground">
+				<ExperimentalSettings
+					experiments={experiments}
+					setExperimentEnabled={(id, enabled) => setExperiments((current) => ({ ...current, [id]: enabled }))}
+				/>
+			</div>
+		</AppProviders>
+	)
+}

webview-ui/src/components/settings/__tests__/ExperimentalSettings.visual.tsx

@@ -0,0 +1,12 @@
+import { expect, test } from "../../../../playwright/coverage-fixture"
+import { mountedStory } from "../../../../playwright/mounted-story"
+import { applyVisualTheme, visualThemes } from "../../../../playwright/themes"
+
+for (const theme of visualThemes) {
+	test(`renders the experimental settings section in the VS Code ${theme.name} theme`, async ({ mount, page }) => {
+		const component = mountedStory(await mount("experimental-settings"))
+		await applyVisualTheme(page, theme)
+		const story = component.getByTestId("experimental-settings-story")
+		await expect(story).toHaveScreenshot(`experimental-settings-${theme.name}.png`)
+	})
+}