🤖 feat: remember last used model and mode per workspace across clients

src/browser/App.tsx

@@ -88,6 +88,7 @@ import {
   clearPendingWorkspaceAiSettings,
   markPendingWorkspaceAiSettings,
   resolveEffectiveComposerModel,
+  updateWorkspaceAgentAISettings,
 } from "@/browser/utils/workspaceAiSettingsSync";
 import { AuthTokenModal } from "@/browser/components/AuthTokenModal/AuthTokenModal";
 
@@ -580,12 +581,11 @@ function AppInner() {
           reasoningMode,
         });
 
-        api.workspace
-          .updateAgentAISettings({
-            workspaceId,
-            agentId: normalizedAgentId,
-            aiSettings: { model, thinkingLevel: normalized, reasoningMode },
-          })
+        updateWorkspaceAgentAISettings(api, {
+          workspaceId,
+          agentId: normalizedAgentId,
+          aiSettings: { model, thinkingLevel: normalized, reasoningMode },
+        })
           .then((result) => {
             if (!result.success) {
               clearPendingWorkspaceAiSettings(workspaceId, normalizedAgentId);
@@ -661,12 +661,11 @@ function AppInner() {
           reasoningMode: next,
         });
 
-        api.workspace
-          .updateAgentAISettings({
-            workspaceId,
-            agentId: normalizedAgentId,
-            aiSettings: { model, thinkingLevel, reasoningMode: next },
-          })
+        updateWorkspaceAgentAISettings(api, {
+          workspaceId,
+          agentId: normalizedAgentId,
+          aiSettings: { model, thinkingLevel, reasoningMode: next },
+        })
           .then((result) => {
             if (!result.success) {
               clearPendingWorkspaceAiSettings(workspaceId, normalizedAgentId);

src/browser/components/WorkspaceModeAISync/WorkspaceModeAISync.test.tsx

@@ -3,6 +3,7 @@ import { act, cleanup, render, waitFor } from "@testing-library/react";
 import { installDom } from "../../../../tests/ui/dom";
 
 import { AgentProvider } from "@/browser/contexts/AgentContext";
+import type { AgentDefinitionDescriptor } from "@/common/types/agentDefinition";
 import { consumeWorkspaceModelChange } from "@/browser/utils/modelChange";
 import { readPersistedState, updatePersistedState } from "@/browser/hooks/usePersistedState";
 import {
@@ -27,14 +28,43 @@ const noop = () => {
   // intentional noop for tests
 };
 
-function SyncHarness(props: { workspaceId: string; agentId: string }) {
+const DEFAULT_AGENTS: AgentDefinitionDescriptor[] = [
+  {
+    id: "exec",
+    scope: "built-in",
+    name: "Exec",
+    uiSelectable: true,
+    subagentRunnable: false,
+  },
+  {
+    id: "plan",
+    scope: "built-in",
+    name: "Plan",
+    uiSelectable: true,
+    subagentRunnable: false,
+  },
+  {
+    id: "auto",
+    scope: "built-in",
+    name: "Auto",
+    uiSelectable: true,
+    subagentRunnable: false,
+  },
+];
+
+function SyncHarness(props: {
+  workspaceId: string;
+  agentId: string;
+  agents?: AgentDefinitionDescriptor[];
+}) {
+  const agents = props.agents ?? DEFAULT_AGENTS;
   return (
     <AgentProvider
       value={{
         agentId: props.agentId,
         setAgentId: noop,
-        currentAgent: undefined,
-        agents: [],
+        currentAgent: agents.find((agent) => agent.id === props.agentId),
+        agents,
         loaded: true,
         loadFailed: false,
         refresh: () => Promise.resolve(),
@@ -48,8 +78,14 @@ function SyncHarness(props: { workspaceId: string; agentId: string }) {
   );
 }
 
-function renderSync(props: { workspaceId: string; agentId: string }) {
-  return render(<SyncHarness workspaceId={props.workspaceId} agentId={props.agentId} />);
+function renderSync(props: {
+  workspaceId: string;
+  agentId: string;
+  agents?: AgentDefinitionDescriptor[];
+}) {
+  return render(
+    <SyncHarness workspaceId={props.workspaceId} agentId={props.agentId} agents={props.agents} />
+  );
 }
 
 describe("WorkspaceModeAISync", () => {
@@ -95,7 +131,7 @@ describe("WorkspaceModeAISync", () => {
     expect(consumeWorkspaceModelChange(workspaceId, planModel)).toBe("agent");
   });
 
-  test("prefers configured agent defaults over workspace-by-agent overrides", async () => {
+  test("prefers a hydrated workspace bucket over configured agent defaults", async () => {
     const workspaceId = nextWorkspaceId();
 
     const configuredModel = "anthropic:claude-haiku-4-5";
@@ -116,15 +152,145 @@ describe("WorkspaceModeAISync", () => {
     renderSync({ workspaceId, agentId: "exec" });
 
     await waitFor(() => {
-      expect(readPersistedState(getModelKey(workspaceId), "")).toBe(configuredModel);
-      expect(readPersistedState(getThinkingLevelKey(workspaceId), "high")).toBe(configuredThinking);
+      expect(readPersistedState(getModelKey(workspaceId), "")).toBe(workspaceModel);
+      expect(readPersistedState(getThinkingLevelKey(workspaceId), "off")).toBe(workspaceThinking);
     });
   });
 
-  test("ignores workspace-by-agent values when settings are inherit", async () => {
+  test("preserves a hydrated workspace bucket when descriptors arrive", async () => {
+    const workspaceId = nextWorkspaceId();
+    const hydratedModel = "anthropic:claude-sonnet-4-6";
+    const hydratedThinking = "high";
+    const definitionModel = "openai:gpt-5.6-sol";
+    const agents: AgentDefinitionDescriptor[] = [
+      {
+        id: "exec",
+        scope: "built-in",
+        name: "Exec",
+        uiSelectable: true,
+        subagentRunnable: false,
+        ownAiDefaults: { model: definitionModel, thinkingLevel: "low" },
+      },
+    ];
+
+    updatePersistedState(AGENT_AI_DEFAULTS_KEY, {});
+    updatePersistedState(getWorkspaceAISettingsByAgentKey(workspaceId), {
+      exec: { model: hydratedModel, thinkingLevel: hydratedThinking },
+    });
+    updatePersistedState(getModelKey(workspaceId), hydratedModel);
+    updatePersistedState(getThinkingLevelKey(workspaceId), hydratedThinking);
+
+    const { rerender } = renderSync({ workspaceId, agentId: "exec", agents: [] });
+    await waitFor(() => {
+      expect(readPersistedState(getModelKey(workspaceId), "")).toBe(hydratedModel);
+    });
+
+    rerender(<SyncHarness workspaceId={workspaceId} agentId="exec" agents={agents} />);
+
+    await waitFor(() => {
+      expect(readPersistedState(getModelKey(workspaceId), "")).toBe(hydratedModel);
+      expect(readPersistedState(getThinkingLevelKey(workspaceId), "off")).toBe(hydratedThinking);
+    });
+  });
+  test("applies custom agent definition defaults on an explicit switch", async () => {
     const workspaceId = nextWorkspaceId();
+    const existingModel = "anthropic:claude-sonnet-4-5";
+    const definitionModel = "openai:gpt-5.6-sol";
+    const agents: AgentDefinitionDescriptor[] = [
+      {
+        id: "plan",
+        scope: "built-in",
+        name: "Plan",
+        uiSelectable: true,
+        subagentRunnable: false,
+      },
+      {
+        id: "researcher",
+        scope: "project",
+        name: "Researcher",
+        uiSelectable: true,
+        subagentRunnable: false,
+        base: "exec",
+        aiDefaults: { model: definitionModel, thinkingLevel: "high" },
+        ownAiDefaults: { model: definitionModel, thinkingLevel: "high" },
+      },
+    ];
+
+    updatePersistedState(AGENT_AI_DEFAULTS_KEY, {});
+    updatePersistedState(getModelKey(workspaceId), existingModel);
+    updatePersistedState(getThinkingLevelKey(workspaceId), "off");
+
+    const { rerender } = renderSync({ workspaceId, agentId: "plan", agents });
 
-    const existingModel = "some-legacy-model";
+    await waitFor(() => {
+      expect(readPersistedState(getModelKey(workspaceId), "")).toBe(existingModel);
+    });
+
+    rerender(<SyncHarness workspaceId={workspaceId} agentId="researcher" agents={agents} />);
+
+    await waitFor(() => {
+      expect(readPersistedState(getModelKey(workspaceId), "")).toBe(definitionModel);
+      expect(readPersistedState(getThinkingLevelKey(workspaceId), "off")).toBe("high");
+    });
+    expect(consumeWorkspaceModelChange(workspaceId, definitionModel)).toBe("agent");
+  });
+
+  test("configured base defaults outrank inherited definition defaults", async () => {
+    const workspaceId = nextWorkspaceId();
+    const existingModel = "anthropic:claude-sonnet-4-5";
+    const agents: AgentDefinitionDescriptor[] = [
+      {
+        id: "plan",
+        scope: "built-in",
+        name: "Plan",
+        uiSelectable: true,
+        subagentRunnable: false,
+      },
+      {
+        id: "exec",
+        scope: "built-in",
+        name: "Exec",
+        uiSelectable: true,
+        subagentRunnable: false,
+        aiDefaults: { thinkingLevel: "low" },
+        ownAiDefaults: { thinkingLevel: "low" },
+      },
+      {
+        id: "researcher",
+        scope: "project",
+        name: "Researcher",
+        uiSelectable: true,
+        subagentRunnable: false,
+        base: "exec",
+        // Effective UI defaults include exec's inherited definition value, but
+        // the child has no definition default of its own.
+        aiDefaults: { thinkingLevel: "low" },
+      },
+    ];
+
+    updatePersistedState(AGENT_AI_DEFAULTS_KEY, {
+      exec: { thinkingLevel: "high" },
+    });
+    updatePersistedState(getModelKey(workspaceId), existingModel);
+    updatePersistedState(getThinkingLevelKey(workspaceId), "off");
+
+    const { rerender } = renderSync({ workspaceId, agentId: "plan", agents });
+    await waitFor(() => {
+      expect(readPersistedState(getThinkingLevelKey(workspaceId), "off")).toBe("off");
+    });
+
+    rerender(<SyncHarness workspaceId={workspaceId} agentId="researcher" agents={agents} />);
+
+    await waitFor(() => {
+      expect(readPersistedState(getModelKey(workspaceId), "")).toBe(existingModel);
+      expect(readPersistedState(getThinkingLevelKey(workspaceId), "off")).toBe("high");
+    });
+  });
+
+  test("restores a hydrated workspace bucket when settings inherit", async () => {
+    const workspaceId = nextWorkspaceId();
+
+    const existingModel = "anthropic:claude-sonnet-4-5";
     const existingThinking = "off";
 
     // Inherit in Settings removes explicit per-agent defaults from AGENT_AI_DEFAULTS_KEY.
@@ -139,8 +305,8 @@ describe("WorkspaceModeAISync", () => {
     renderSync({ workspaceId, agentId: "exec" });
 
     await waitFor(() => {
-      expect(readPersistedState(getModelKey(workspaceId), "")).toBe(existingModel);
-      expect(readPersistedState(getThinkingLevelKey(workspaceId), "off")).toBe(existingThinking);
+      expect(readPersistedState(getModelKey(workspaceId), "")).toBe("openai:gpt-5.2");
+      expect(readPersistedState(getThinkingLevelKey(workspaceId), "off")).toBe("medium");
     });
   });
 
@@ -179,10 +345,10 @@ describe("WorkspaceModeAISync", () => {
     expect(consumeWorkspaceModelChange(workspaceId, execWorkspaceModel)).toBe("agent");
   });
 
-  test("ignores same-agent workspace overrides when agent defaults are missing", async () => {
+  test("restores a hydrated custom-agent bucket during background sync", async () => {
     const workspaceId = nextWorkspaceId();
 
-    const existingModel = "some-legacy-model";
+    const existingModel = "anthropic:claude-sonnet-4-5";
     const existingThinking = "high";
 
     updatePersistedState(AGENT_AI_DEFAULTS_KEY, {
@@ -198,8 +364,8 @@ describe("WorkspaceModeAISync", () => {
     renderSync({ workspaceId, agentId: "custom" });
 
     await waitFor(() => {
-      expect(readPersistedState(getModelKey(workspaceId), "")).toBe(existingModel);
-      expect(readPersistedState(getThinkingLevelKey(workspaceId), "off")).toBe(existingThinking);
+      expect(readPersistedState(getModelKey(workspaceId), "")).toBe("openai:gpt-5.2-pro");
+      expect(readPersistedState(getThinkingLevelKey(workspaceId), "off")).toBe("medium");
     });
   });
 

src/browser/components/WorkspaceModeAISync/WorkspaceModeAISync.tsx

@@ -54,9 +54,8 @@ export function WorkspaceModeAISync(props: { workspaceId: string }): null {
     prevAgentIdRef.current = normalizedAgentId;
     prevWorkspaceIdRef.current = workspaceId;
 
-    // Read at call time rather than subscribing: this cache only feeds explicit agent
-    // switches, yet every model/thinking/pro-mode change rewrites it, so a subscription
-    // would re-run this effect and re-apply the mode default over the user's own pick.
+    // Read at call time rather than subscribing: every model/thinking/pro-mode change
+    // rewrites this cache, so a subscription would re-run the effect on its own updates.
     const workspaceByAgent = readPersistedState<WorkspaceAISettingsCache>(
       getWorkspaceAISettingsByAgentKey(workspaceId),
       {}
@@ -67,21 +66,19 @@ export function WorkspaceModeAISync(props: { workspaceId: string }): null {
     const reasoningKey = getReasoningModeKey(workspaceId);
     const existingReasoning = readPersistedState<OpenAIReasoningMode>(reasoningKey, "standard");
 
-    const { resolvedModel, resolvedThinking, resolvedReasoningMode } =
-      resolveWorkspaceAiSettingsForAgent({
-        agentId: normalizedAgentId,
-        agentAiDefaults,
-        // Keep deterministic handoff behavior: background sync should trust the
-        // currently active workspace model, but explicit mode switches should
-        // restore the selected agent's per-workspace override (if any).
-        workspaceByAgent,
-        useWorkspaceByAgentFallback: isExplicitAgentSwitch,
-        fallbackModel,
-        existingModel,
-        existingThinking,
-        existingReasoningMode: existingReasoning,
-        agentBaseById: new Map(agents.map((agent) => [agent.id, agent.base])),
-      });
+    const resolvedSettings = resolveWorkspaceAiSettingsForAgent({
+      agentId: normalizedAgentId,
+      agentAiDefaults,
+      workspaceByAgent,
+      fallbackModel,
+      existingModel,
+      existingThinking,
+      existingReasoningMode: existingReasoning,
+      agents,
+      mode: isExplicitAgentSwitch ? "explicit-switch" : "background-sync",
+    });
+    if (!resolvedSettings) return;
+    const { resolvedModel, resolvedThinking, resolvedReasoningMode } = resolvedSettings;
 
     if (existingModel !== resolvedModel) {
       setWorkspaceModelWithOrigin(