🤖 feat: persist per-workspace model + thinking (#1203)

Persist per-workspace model and thinking/reasoning level on the backend
so that opening the same workspace from another browser/device restores
the same AI configuration.

### Changes

- **New shared schema** `WorkspaceAISettings` (`model`, `thinkingLevel`)
added to workspace config and metadata schemas.
- **New ORPC endpoint** `workspace.updateAISettings` to explicitly
persist settings changes.
- **Backend safety net**: `sendMessage` and `resumeStream` also persist
"last used" settings for older/CLI clients.
- **Frontend thinking is now workspace-scoped**
(`thinkingLevel:{workspaceId}`) with migration from legacy per-model
keys.
- **LocalStorage seeding from backend metadata** ensures cross-device
convergence.
- **UI changes back-persist** model and thinking to backend immediately.
- **Creation flow** copies project-scoped preferences and best-effort
persists to backend.

### Testing

- Updated `ThinkingContext.test.tsx` for workspace-scoped thinking +
migration.
- Added `WorkspaceContext.test.tsx` test for backend metadata seeding
localStorage.
- Added IPC test `tests/ipc/workspaceAISettings.test.ts` verifying
persistence + list/getInfo.

---

<details>
<summary>📋 Implementation Plan</summary>

# Persist per-workspace model + reasoning (thinking) on the backend

## Goal
Make **model selection** and **thinking/reasoning level**:
- **Workspace-scoped** (not per-model, not global)
- **Persisted server-side** so opening the same workspace from another
browser/device restores the same configuration

Non-goals (for this change): persisting provider options (e.g.
truncation), global default model, or draft input.

---

## Recommended approach (net +250–400 LoC product)
### 1) Define a single workspace AI settings shape (shared types)
**Why:** avoid ad-hoc keys and keep the IPC/API boundary strongly typed.

- Add a reusable schema/type (common):
  - `WorkspaceAISettings`:
- `model: string` (canonical `provider:model`, *not*
`mux-gateway:provider/model`)
    - `thinkingLevel: ThinkingLevel` (`off|low|medium|high|xhigh`)

- Extend persisted config shape:
- `WorkspaceConfigSchema` (in `src/common/orpc/schemas/project.ts`): add
optional `aiSettings?: WorkspaceAISettings`

- Extend workspace metadata returned to clients:
- `WorkspaceMetadataSchema` (in `src/common/orpc/schemas/workspace.ts`):
add optional `aiSettings?: WorkspaceAISettings`
- (Frontend schema automatically inherits via
`FrontendWorkspaceMetadataSchema.extend(...)`)

### 2) Backend: persist + serve workspace AI settings
**Persistence location:** `~/.mux/config.json` under each workspace
entry (alongside `runtimeConfig`, `mcp`, etc.)

#### 2.1 Add an API to update settings explicitly
- Add a new ORPC endpoint:
  - `workspace.updateAISettings` (name bikesheddable)
  - Input: `{ workspaceId: string, aiSettings: WorkspaceAISettings }`
  - Output: `Result<void, string>`

- Node implementation (`WorkspaceService`):
  - Validate workspace exists via `config.findWorkspace(workspaceId)`.
- `config.editConfig(...)` to locate the workspace entry and set
`workspaceEntry.aiSettings = normalizedSettings`.
  - **Normalize defensively**:
- `model = normalizeGatewayModel(model)` (from
`src/common/utils/ai/models.ts`)
- `thinkingLevel = enforceThinkingPolicy(model, thinkingLevel)` (single
source of truth)
- After save, re-fetch via `config.getAllWorkspaceMetadata()` and emit
`onMetadata` update *only if the value changed* (avoid spam).

#### 2.2 Also persist “last used” settings on message send (safety net)
Even if a client forgets to call `updateAISettings` (CLI/extension/old
client), the backend should learn the last used values.

- In `WorkspaceService.sendMessage(...)` and `resumeStream(...)`:
- Extract `options.model` + `options.thinkingLevel` and write to
`workspaceEntry.aiSettings` (same normalization as above).
  - Only write when different.

> This makes “chatted with it earlier” reliably populate the backend
state.

### 3) Frontend: treat backend as source of truth, but keep localStorage
as a fast cache
#### 3.1 Change thinking persistence to be **workspace-scoped**
- Add a new storage helper:
- `getThinkingLevelKey(scopeId: string): string` →
`thinkingLevel:${scopeId}`
- Update `PERSISTENT_WORKSPACE_KEY_FUNCTIONS` to include it (so fork
copies it, delete removes it).

- Update `ThinkingProvider` to use **scope-based keying**:
  - Scope priority similar to `ModeProvider`:
    - workspace: `thinkingLevel:{workspaceId}`
    - creation: `thinkingLevel:__project__/{projectPath}`
  - Remove the current “key depends on selected model” behavior.

- Update non-React send option reader:
- `getSendOptionsFromStorage(...)` should read thinking via
`getThinkingLevelKey(scopeId)`.

- Update UI copy:
- Thinking slider tooltip text from “Saved per model” → “Saved per
workspace”.

#### 3.2 Seed localStorage from backend workspace metadata
**Where:** `WorkspaceContext.loadWorkspaceMetadata()` + the
`workspace.onMetadata` subscription handler.

- When metadata arrives for a workspace:
- If `metadata.aiSettings?.model` exists → write it to `localStorage`
key `model:{workspaceId}`.
- If `metadata.aiSettings?.thinkingLevel` exists → write it to
`thinkingLevel:{workspaceId}`.
- Only write when the value differs (avoid unnecessary re-renders from
`updatePersistedState`).

This ensures:
- new device with empty localStorage adopts backend settings
- existing device with stale localStorage is corrected to backend

#### 3.3 Persist changes back to the backend when the user changes the
UI
- Model changes:
  - In `ChatInput`’s `setPreferredModel(...)` (workspace variant only):
    - Update localStorage as today
- Call `api.workspace.updateAISettings({ workspaceId, aiSettings: {
model, thinkingLevel: currentThinking } })`

- Thinking changes:
- Wrap `setThinkingLevel` in `ThinkingProvider` (workspace variant
only):
    - Update localStorage
- Call `api.workspace.updateAISettings(...)` with `{ model:
currentModel, thinkingLevel: newLevel }`

Notes:
- Use `enforceThinkingPolicy` client-side too (keep UI/BE consistent)
but backend remains final authority.
- If `api` is unavailable, keep localStorage update (offline-friendly)
and rely on sendMessage persistence later.

#### 3.4 Creation flow
- Keep project-scoped model + thinking in localStorage while creating.
- When a workspace is created:
- Continue copying project-scoped values into the new workspace-scoped
keys (update `syncCreationPreferences` to include thinking).
- Optionally call `workspace.updateAISettings(...)` right after creation
(best effort) so the workspace is immediately portable even before the
first message sends.

### 4) Migration + compatibility
- **Config.json:** new `aiSettings` fields are optional → old configs
load fine; old mux versions should ignore unknown fields.
- **localStorage:** migrate legacy per-model thinking into the new
per-workspace key:
  - On workspace open, if `thinkingLevel:{workspaceId}` is missing:
    - read `model:{workspaceId}` (or default)
    - read old `thinkingLevel:model:{model}`
    - set `thinkingLevel:{workspaceId}` to that value

Put this migration in a single place (e.g., the same “seed from
metadata” helper) so it runs once.

---

## Validation / tests
- Update unit tests that assert per-model thinking:
- `src/browser/contexts/ThinkingContext.test.tsx` should instead verify
thinking is stable across model changes (except clamping).
- Add a backend test that `workspace.updateAISettings`:
  - persists into config
  - is returned by `workspace.list/getInfo`
- Add a lightweight frontend test that WorkspaceContext seeding writes
the expected localStorage keys when metadata contains `aiSettings`.

---

<details>
<summary>Alternatives considered</summary>

### A) Persist only on sendMessage (no new endpoint) (net +120–200 LoC)
- Backend writes `aiSettings` from `sendMessage/resumeStream` options.
- Frontend only seeds localStorage from metadata when local keys are
missing.

Pros: less surface area.
Cons: doesn’t sync if user changes model/thinking but hasn’t sent yet;
stale localStorage on an existing device may never converge.

### B) Remove localStorage for model/thinking entirely (net +500–900
LoC)
- Replace `usePersistedState(getModelKey(...))` usage with a workspace
settings store sourced from backend.

Pros: true single source of truth.
Cons: much bigger refactor; riskier.

</details>

</details>

---
_Generated with `mux` • Model: `openai:gpt-5.2` • Thinking: `high`_

Signed-off-by: Thomas Kosiewski <tk@coder.com>

Author: ThomasK33

src/browser/App.tsx

@@ -34,8 +34,13 @@ import { buildCoreSources, type BuildSourcesParams } from "./utils/commands/sour
 import type { ThinkingLevel } from "@/common/types/thinking";
 import { CUSTOM_EVENTS } from "@/common/constants/events";
 import { isWorkspaceForkSwitchEvent } from "./utils/workspaceEvents";
-import { getThinkingLevelByModelKey, getModelKey } from "@/common/constants/storage";
+import {
+  getThinkingLevelByModelKey,
+  getThinkingLevelKey,
+  getModelKey,
+} from "@/common/constants/storage";
 import { migrateGatewayModel } from "@/browser/hooks/useGatewayModels";
+import { enforceThinkingPolicy } from "@/browser/utils/thinking/policy";
 import { getDefaultModel } from "@/browser/hooks/useModelsFromSettings";
 import type { BranchListResult } from "@/common/orpc/types";
 import { useTelemetry } from "./hooks/useTelemetry";
@@ -52,7 +57,7 @@ import { TooltipProvider } from "./components/ui/tooltip";
 import { ExperimentsProvider } from "./contexts/ExperimentsContext";
 import { getWorkspaceSidebarKey } from "./utils/workspace";
 
-const THINKING_LEVELS: ThinkingLevel[] = ["off", "low", "medium", "high"];
+const THINKING_LEVELS: ThinkingLevel[] = ["off", "low", "medium", "high", "xhigh"];
 
 function isStorybookIframe(): boolean {
   return typeof window !== "undefined" && window.location.pathname.endsWith("iframe.html");
@@ -293,9 +298,25 @@ function AppInner() {
       if (!workspaceId) {
         return "off";
       }
+
+      const scopedKey = getThinkingLevelKey(workspaceId);
+      const scoped = readPersistedState<ThinkingLevel | undefined>(scopedKey, undefined);
+      if (scoped !== undefined) {
+        return THINKING_LEVELS.includes(scoped) ? scoped : "off";
+      }
+
+      // Migration: fall back to legacy per-model thinking and seed the workspace-scoped key.
       const model = getModelForWorkspace(workspaceId);
-      const level = readPersistedState<ThinkingLevel>(getThinkingLevelByModelKey(model), "off");
-      return THINKING_LEVELS.includes(level) ? level : "off";
+      const legacy = readPersistedState<ThinkingLevel | undefined>(
+        getThinkingLevelByModelKey(model),
+        undefined
+      );
+      if (legacy !== undefined && THINKING_LEVELS.includes(legacy)) {
+        updatePersistedState(scopedKey, legacy);
+        return legacy;
+      }
+
+      return "off";
     },
     [getModelForWorkspace]
   );
@@ -308,22 +329,32 @@ function AppInner() {
 
       const normalized = THINKING_LEVELS.includes(level) ? level : "off";
       const model = getModelForWorkspace(workspaceId);
-      const key = getThinkingLevelByModelKey(model);
+      const effective = enforceThinkingPolicy(model, normalized);
+      const key = getThinkingLevelKey(workspaceId);
 
       // Use the utility function which handles localStorage and event dispatch
       // ThinkingProvider will pick this up via its listener
-      updatePersistedState(key, normalized);
+      updatePersistedState(key, effective);
+
+      // Persist to backend so the palette change follows the workspace across devices.
+      if (api) {
+        api.workspace
+          .updateAISettings({ workspaceId, aiSettings: { model, thinkingLevel: effective } })
+          .catch(() => {
+            // Best-effort only.
+          });
+      }
 
       // Dispatch toast notification event for UI feedback
       if (typeof window !== "undefined") {
         window.dispatchEvent(
           new CustomEvent(CUSTOM_EVENTS.THINKING_LEVEL_TOAST, {
-            detail: { workspaceId, level: normalized },
+            detail: { workspaceId, level: effective },
           })
         );
       }
     },
-    [getModelForWorkspace]
+    [api, getModelForWorkspace]
   );
 
   const registerParamsRef = useRef<BuildSourcesParams | null>(null);

src/browser/components/ChatInput/index.tsx

@@ -20,6 +20,9 @@ import { useMode } from "@/browser/contexts/ModeContext";
 import { ThinkingSliderComponent } from "../ThinkingSlider";
 import { ModelSettings } from "../ModelSettings";
 import { useAPI } from "@/browser/contexts/API";
+import { useThinkingLevel } from "@/browser/hooks/useThinkingLevel";
+import { migrateGatewayModel } from "@/browser/hooks/useGatewayModels";
+import { enforceThinkingPolicy } from "@/browser/utils/thinking/policy";
 import { useSendMessageOptions } from "@/browser/hooks/useSendMessageOptions";
 import {
   getModelKey,
@@ -133,6 +136,8 @@ export type { ChatInputProps, ChatInputAPI };
 const ChatInputInner: React.FC<ChatInputProps> = (props) => {
   const { api } = useAPI();
   const { variant } = props;
+  const [thinkingLevel] = useThinkingLevel();
+  const workspaceId = variant === "workspace" ? props.workspaceId : null;
 
   // Extract workspace-specific props with defaults
   const disabled = props.disabled ?? false;
@@ -333,10 +338,26 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
 
   const setPreferredModel = useCallback(
     (model: string) => {
-      ensureModelInSettings(model); // Ensure model exists in Settings
-      updatePersistedState(storageKeys.modelKey, model); // Update workspace or project-specific
+      const canonicalModel = migrateGatewayModel(model);
+      ensureModelInSettings(canonicalModel); // Ensure model exists in Settings
+      updatePersistedState(storageKeys.modelKey, canonicalModel); // Update workspace or project-specific
+
+      // Workspace variant: persist to backend for cross-device consistency.
+      if (!api || variant !== "workspace" || !workspaceId) {
+        return;
+      }
+
+      const effectiveThinkingLevel = enforceThinkingPolicy(canonicalModel, thinkingLevel);
+      api.workspace
+        .updateAISettings({
+          workspaceId,
+          aiSettings: { model: canonicalModel, thinkingLevel: effectiveThinkingLevel },
+        })
+        .catch(() => {
+          // Best-effort only. If offline or backend is old, sendMessage will persist.
+        });
     },
-    [storageKeys.modelKey, ensureModelInSettings]
+    [api, storageKeys.modelKey, ensureModelInSettings, thinkingLevel, variant, workspaceId]
   );
   const deferredModel = useDeferredValue(preferredModel);
   const deferredInput = useDeferredValue(input);

src/browser/components/ChatInput/useCreationWorkspace.test.tsx

@@ -7,6 +7,7 @@ import {
   getModeKey,
   getPendingScopeId,
   getProjectScopeId,
+  getThinkingLevelKey,
 } from "@/common/constants/storage";
 import type { SendMessageError as _SendMessageError } from "@/common/types/errors";
 import type { WorkspaceChatMessage } from "@/common/orpc/types";
@@ -83,11 +84,18 @@ type ListBranchesArgs = Parameters<APIClient["projects"]["listBranches"]>[0];
 type WorkspaceSendMessageArgs = Parameters<APIClient["workspace"]["sendMessage"]>[0];
 type WorkspaceSendMessageResult = Awaited<ReturnType<APIClient["workspace"]["sendMessage"]>>;
 type WorkspaceCreateArgs = Parameters<APIClient["workspace"]["create"]>[0];
+type WorkspaceUpdateAISettingsArgs = Parameters<APIClient["workspace"]["updateAISettings"]>[0];
+type WorkspaceUpdateAISettingsResult = Awaited<
+  ReturnType<APIClient["workspace"]["updateAISettings"]>
+>;
 type WorkspaceCreateResult = Awaited<ReturnType<APIClient["workspace"]["create"]>>;
 type NameGenerationArgs = Parameters<APIClient["nameGeneration"]["generate"]>[0];
 type NameGenerationResult = Awaited<ReturnType<APIClient["nameGeneration"]["generate"]>>;
 type MockOrpcProjectsClient = Pick<APIClient["projects"], "listBranches">;
-type MockOrpcWorkspaceClient = Pick<APIClient["workspace"], "sendMessage" | "create">;
+type MockOrpcWorkspaceClient = Pick<
+  APIClient["workspace"],
+  "sendMessage" | "create" | "updateAISettings"
+>;
 type MockOrpcNameGenerationClient = Pick<APIClient["nameGeneration"], "generate">;
 type WindowWithApi = Window & typeof globalThis;
 type WindowApi = WindowWithApi["api"];
@@ -114,6 +122,9 @@ interface SetupWindowOptions {
   sendMessage?: ReturnType<
     typeof mock<(args: WorkspaceSendMessageArgs) => Promise<WorkspaceSendMessageResult>>
   >;
+  updateAISettings?: ReturnType<
+    typeof mock<(args: WorkspaceUpdateAISettingsArgs) => Promise<WorkspaceUpdateAISettingsResult>>
+  >;
   create?: ReturnType<typeof mock<(args: WorkspaceCreateArgs) => Promise<WorkspaceCreateResult>>>;
   nameGeneration?: ReturnType<
     typeof mock<(args: NameGenerationArgs) => Promise<NameGenerationResult>>
@@ -124,6 +135,7 @@ const setupWindow = ({
   listBranches,
   sendMessage,
   create,
+  updateAISettings,
   nameGeneration,
 }: SetupWindowOptions = {}) => {
   const listBranchesMock =
@@ -157,6 +169,15 @@ const setupWindow = ({
       } as WorkspaceCreateResult);
     });
 
+  const updateAISettingsMock =
+    updateAISettings ??
+    mock<(args: WorkspaceUpdateAISettingsArgs) => Promise<WorkspaceUpdateAISettingsResult>>(() => {
+      return Promise.resolve({
+        success: true,
+        data: undefined,
+      } as WorkspaceUpdateAISettingsResult);
+    });
+
   const nameGenerationMock =
     nameGeneration ??
     mock<(args: NameGenerationArgs) => Promise<NameGenerationResult>>(() => {
@@ -176,6 +197,7 @@ const setupWindow = ({
     workspace: {
       sendMessage: (input: WorkspaceSendMessageArgs) => sendMessageMock(input),
       create: (input: WorkspaceCreateArgs) => createMock(input),
+      updateAISettings: (input: WorkspaceUpdateAISettingsArgs) => updateAISettingsMock(input),
     },
     nameGeneration: {
       generate: (input: NameGenerationArgs) => nameGenerationMock(input),
@@ -213,6 +235,7 @@ const setupWindow = ({
     workspace: {
       list: rejectNotImplemented("workspace.list"),
       create: (args: WorkspaceCreateArgs) => createMock(args),
+      updateAISettings: (args: WorkspaceUpdateAISettingsArgs) => updateAISettingsMock(args),
       remove: rejectNotImplemented("workspace.remove"),
       rename: rejectNotImplemented("workspace.rename"),
       fork: rejectNotImplemented("workspace.fork"),
@@ -278,7 +301,11 @@ const setupWindow = ({
 
   return {
     projectsApi: { listBranches: listBranchesMock },
-    workspaceApi: { sendMessage: sendMessageMock, create: createMock },
+    workspaceApi: {
+      sendMessage: sendMessageMock,
+      create: createMock,
+      updateAISettings: updateAISettingsMock,
+    },
     nameGenerationApi: { generate: nameGenerationMock },
   };
 };
@@ -466,7 +493,7 @@ describe("useCreationWorkspace", () => {
     const pendingInputKey = getInputKey(pendingScopeId);
     const pendingImagesKey = getInputImagesKey(pendingScopeId);
     expect(updatePersistedStateCalls).toContainEqual([modeKey, "plan"]);
-    // Note: thinking level is no longer synced per-workspace, it's stored per-model globally
+    // Thinking is workspace-scoped, but this test doesn't set a project-scoped thinking preference.
     expect(updatePersistedStateCalls).toContainEqual([pendingInputKey, ""]);
     expect(updatePersistedStateCalls).toContainEqual([pendingImagesKey, undefined]);
   });
@@ -510,7 +537,10 @@ describe("useCreationWorkspace", () => {
     expect(onWorkspaceCreated.mock.calls.length).toBe(0);
     await waitFor(() => expect(getHook().toast?.message).toBe("backend exploded"));
     await waitFor(() => expect(getHook().isSending).toBe(false));
-    expect(updatePersistedStateCalls).toEqual([]);
+
+    // Side effect: send-options reader may migrate thinking level into the project scope.
+    const thinkingKey = getThinkingLevelKey(getProjectScopeId(TEST_PROJECT_PATH));
+    expect(updatePersistedStateCalls).toEqual([[thinkingKey, "off"]]);
   });
 });
 

src/browser/components/ChatInput/useCreationWorkspace.ts

@@ -1,6 +1,7 @@
 import { useState, useEffect, useCallback } from "react";
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
 import type { RuntimeConfig, RuntimeMode } from "@/common/types/runtime";
+import type { ThinkingLevel } from "@/common/types/thinking";
 import type { UIMode } from "@/common/types/mode";
 import { parseRuntimeString } from "@/browser/utils/chatCommands";
 import { useDraftWorkspaceSettings } from "@/browser/hooks/useDraftWorkspaceSettings";
@@ -11,6 +12,7 @@ import {
   getInputImagesKey,
   getModelKey,
   getModeKey,
+  getThinkingLevelKey,
   getPendingScopeId,
   getProjectScopeId,
 } from "@/common/constants/storage";
@@ -45,8 +47,13 @@ function syncCreationPreferences(projectPath: string, workspaceId: string): void
     updatePersistedState(getModeKey(workspaceId), projectMode);
   }
 
-  // Note: thinking level is stored per-model globally, not per-workspace,
-  // so no sync is needed here
+  const projectThinkingLevel = readPersistedState<ThinkingLevel | null>(
+    getThinkingLevelKey(projectScopeId),
+    null
+  );
+  if (projectThinkingLevel !== null) {
+    updatePersistedState(getThinkingLevelKey(workspaceId), projectThinkingLevel);
+  }
 }
 
 interface UseCreationWorkspaceReturn {
@@ -196,6 +203,19 @@ export function useCreationWorkspace({
 
         const { metadata } = createResult;
 
+        // Best-effort: persist the initial AI settings to the backend immediately so this workspace
+        // is portable across devices even before the first stream starts.
+        api.workspace
+          .updateAISettings({
+            workspaceId: metadata.id,
+            aiSettings: {
+              model: settings.model,
+              thinkingLevel: settings.thinkingLevel,
+            },
+          })
+          .catch(() => {
+            // Ignore (offline / older backend). sendMessage will persist as a fallback.
+          });
         // Sync preferences immediately (before switching)
         syncCreationPreferences(projectPath, metadata.id);
         if (projectPath) {
@@ -239,6 +259,8 @@ export function useCreationWorkspace({
       projectScopeId,
       onWorkspaceCreated,
       getRuntimeString,
+      settings.model,
+      settings.thinkingLevel,
       settings.trunkBranch,
       waitForGeneration,
     ]

src/browser/components/ThinkingSlider.tsx

@@ -199,7 +199,7 @@ export const ThinkingSliderComponent: React.FC<ThinkingControlProps> = ({ modelS
         </div>
       </TooltipTrigger>
       <TooltipContent align="center">
-        Thinking: {formatKeybind(KEYBINDS.TOGGLE_THINKING)} to cycle. Saved per model.
+        Thinking: {formatKeybind(KEYBINDS.TOGGLE_THINKING)} to cycle. Saved per workspace.
       </TooltipContent>
     </Tooltip>
   );

src/browser/contexts/ThinkingContext.test.tsx

@@ -4,7 +4,11 @@ import { act, cleanup, render, waitFor } from "@testing-library/react";
 import React from "react";
 import { ThinkingProvider } from "./ThinkingContext";
 import { useThinkingLevel } from "@/browser/hooks/useThinkingLevel";
-import { getModelKey, getThinkingLevelByModelKey } from "@/common/constants/storage";
+import {
+  getModelKey,
+  getThinkingLevelByModelKey,
+  getThinkingLevelKey,
+} from "@/common/constants/storage";
 import { updatePersistedState } from "@/browser/hooks/usePersistedState";
 
 // Setup basic DOM environment for testing-library
@@ -49,8 +53,7 @@ describe("ThinkingContext", () => {
     const workspaceId = "ws-1";
 
     updatePersistedState(getModelKey(workspaceId), "openai:gpt-5.2");
-    updatePersistedState(getThinkingLevelByModelKey("openai:gpt-5.2"), "high");
-    updatePersistedState(getThinkingLevelByModelKey("anthropic:claude-3.5"), "low");
+    updatePersistedState(getThinkingLevelKey(workspaceId), "high");
 
     let unmounts = 0;
 
@@ -79,21 +82,18 @@ describe("ThinkingContext", () => {
       updatePersistedState(getModelKey(workspaceId), "anthropic:claude-3.5");
     });
 
+    // Thinking is workspace-scoped (not per-model), so switching models should not change it.
     await waitFor(() => {
-      expect(view.getByTestId("child").textContent).toBe("low");
+      expect(view.getByTestId("child").textContent).toBe("high");
     });
 
     expect(unmounts).toBe(0);
   });
-  test("switching models restores the per-model thinking level", async () => {
+  test("migrates legacy per-model thinking to the workspace-scoped key", async () => {
     const workspaceId = "ws-1";
 
-    // Model A
     updatePersistedState(getModelKey(workspaceId), "openai:gpt-5.2");
-    updatePersistedState(getThinkingLevelByModelKey("openai:gpt-5.2"), "high");
-
-    // Model B
-    updatePersistedState(getThinkingLevelByModelKey("anthropic:claude-3.5"), "low");
+    updatePersistedState(getThinkingLevelByModelKey("openai:gpt-5.2"), "low");
 
     const view = render(
       <ThinkingProvider workspaceId={workspaceId}>
@@ -102,10 +102,15 @@ describe("ThinkingContext", () => {
     );
 
     await waitFor(() => {
-      expect(view.getByTestId("thinking").textContent).toBe("high:ws-1");
+      expect(view.getByTestId("thinking").textContent).toBe("low:ws-1");
     });
 
-    // Change model -> should restore that model's stored thinking level
+    // Migration should have populated the new workspace-scoped key.
+    const persisted = window.localStorage.getItem(getThinkingLevelKey(workspaceId));
+    expect(persisted).toBeTruthy();
+    expect(JSON.parse(persisted!)).toBe("low");
+
+    // Switching models should not change the workspace-scoped value.
     act(() => {
       updatePersistedState(getModelKey(workspaceId), "anthropic:claude-3.5");
     });