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

src/browser/App.tsx

@@ -88,6 +88,7 @@ import {
   clearPendingWorkspaceAiSettings,
   markPendingWorkspaceAiSettings,
   resolveEffectiveComposerModel,
+  serializeWorkspaceAiSettingsWrite,
 } from "@/browser/utils/workspaceAiSettingsSync";
 import { AuthTokenModal } from "@/browser/components/AuthTokenModal/AuthTokenModal";
 
@@ -580,12 +581,13 @@ function AppInner() {
           reasoningMode,
         });
 
-        api.workspace
-          .updateAgentAISettings({
+        serializeWorkspaceAiSettingsWrite(workspaceId, () =>
+          api.workspace.updateAgentAISettings({
             workspaceId,
             agentId: normalizedAgentId,
             aiSettings: { model, thinkingLevel: normalized, reasoningMode },
           })
+        )
           .then((result) => {
             if (!result.success) {
               clearPendingWorkspaceAiSettings(workspaceId, normalizedAgentId);
@@ -661,12 +663,13 @@ function AppInner() {
           reasoningMode: next,
         });
 
-        api.workspace
-          .updateAgentAISettings({
+        serializeWorkspaceAiSettingsWrite(workspaceId, () =>
+          api.workspace.updateAgentAISettings({
             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,19 @@ const noop = () => {
   // intentional noop for tests
 };
 
-function SyncHarness(props: { workspaceId: string; agentId: string }) {
+function SyncHarness(props: {
+  workspaceId: string;
+  agentId: string;
+  agents?: AgentDefinitionDescriptor[];
+}) {
+  const agents = props.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 +54,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", () => {
@@ -121,10 +133,105 @@ describe("WorkspaceModeAISync", () => {
     });
   });
 
+  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 });
+
+    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("ignores workspace-by-agent values when settings are inherit", async () => {
     const workspaceId = nextWorkspaceId();
 
-    const existingModel = "some-legacy-model";
+    const existingModel = "anthropic:claude-sonnet-4-5";
     const existingThinking = "off";
 
     // Inherit in Settings removes explicit per-agent defaults from AGENT_AI_DEFAULTS_KEY.
@@ -182,7 +289,7 @@ describe("WorkspaceModeAISync", () => {
   test("ignores same-agent workspace overrides when agent defaults are missing", async () => {
     const workspaceId = nextWorkspaceId();
 
-    const existingModel = "some-legacy-model";
+    const existingModel = "anthropic:claude-sonnet-4-5";
     const existingThinking = "high";
 
     updatePersistedState(AGENT_AI_DEFAULTS_KEY, {

src/browser/components/WorkspaceModeAISync/WorkspaceModeAISync.tsx

@@ -80,7 +80,12 @@ export function WorkspaceModeAISync(props: { workspaceId: string }): null {
         existingModel,
         existingThinking,
         existingReasoningMode: existingReasoning,
-        agentBaseById: new Map(agents.map((agent) => [agent.id, agent.base])),
+        agentDescriptorById: new Map(
+          agents.map((agent) => [
+            agent.id,
+            { base: agent.base, definitionAiDefaults: agent.ownAiDefaults },
+          ])
+        ),
       });
 
     if (existingModel !== resolvedModel) {