🤖 feat: mode-scoped AI defaults + per-mode overrides

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

Author: ThomasK33

src/browser/App.tsx

@@ -26,13 +26,16 @@ import { ThemeProvider, useTheme, type ThemeMode } from "./contexts/ThemeContext
 import { CommandPalette } from "./components/CommandPalette";
 import { buildCoreSources, type BuildSourcesParams } from "./utils/commands/sources";
 
+import type { UIMode } from "@/common/types/mode";
 import type { ThinkingLevel } from "@/common/types/thinking";
 import { CUSTOM_EVENTS } from "@/common/constants/events";
 import { isWorkspaceForkSwitchEvent } from "./utils/workspaceEvents";
 import {
+  getModeKey,
+  getModelKey,
   getThinkingLevelByModelKey,
   getThinkingLevelKey,
-  getModelKey,
+  getWorkspaceAISettingsByModeKey,
 } from "@/common/constants/storage";
 import { migrateGatewayModel } from "@/browser/hooks/useGatewayModels";
 import { enforceThinkingPolicy } from "@/common/utils/thinking/policy";
@@ -319,10 +322,33 @@ function AppInner() {
       // ThinkingProvider will pick this up via its listener
       updatePersistedState(key, effective);
 
+      type WorkspaceAISettingsByModeCache = Partial<
+        Record<UIMode, { model: string; thinkingLevel: ThinkingLevel }>
+      >;
+
+      const mode = readPersistedState<UIMode>(getModeKey(workspaceId), "exec");
+
+      updatePersistedState<WorkspaceAISettingsByModeCache>(
+        getWorkspaceAISettingsByModeKey(workspaceId),
+        (prev) => {
+          const record: WorkspaceAISettingsByModeCache =
+            prev && typeof prev === "object" ? prev : {};
+          return {
+            ...record,
+            [mode]: { model, thinkingLevel: effective },
+          };
+        },
+        {}
+      );
+
       // Persist to backend so the palette change follows the workspace across devices.
       if (api) {
         api.workspace
-          .updateAISettings({ workspaceId, aiSettings: { model, thinkingLevel: effective } })
+          .updateModeAISettings({
+            workspaceId,
+            mode,
+            aiSettings: { model, thinkingLevel: effective },
+          })
           .catch(() => {
             // Best-effort only.
           });

src/browser/components/AIView.tsx

@@ -34,6 +34,7 @@ import {
 import { BashOutputCollapsedIndicator } from "./tools/BashOutputCollapsedIndicator";
 import { hasInterruptedStream } from "@/browser/utils/messages/retryEligibility";
 import { ThinkingProvider } from "@/browser/contexts/ThinkingContext";
+import { WorkspaceModeAISync } from "@/browser/components/WorkspaceModeAISync";
 import { ModeProvider } from "@/browser/contexts/ModeContext";
 import { ProviderOptionsProvider } from "@/browser/contexts/ProviderOptionsContext";
 
@@ -838,6 +839,7 @@ export const AIView: React.FC<AIViewProps> = (props) => {
 
   return (
     <ModeProvider workspaceId={props.workspaceId}>
+      <WorkspaceModeAISync workspaceId={props.workspaceId} />
       <ProviderOptionsProvider>
         <ThinkingProvider workspaceId={props.workspaceId}>
           <AIViewInner {...props} />

src/browser/components/ChatInput/index.tsx

@@ -26,6 +26,7 @@ import { enforceThinkingPolicy } from "@/common/utils/thinking/policy";
 import { useSendMessageOptions } from "@/browser/hooks/useSendMessageOptions";
 import {
   getModelKey,
+  getWorkspaceAISettingsByModeKey,
   getInputKey,
   getInputImagesKey,
   VIM_ENABLED_KEY,
@@ -339,26 +340,49 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
 
   const setPreferredModel = useCallback(
     (model: string) => {
+      type WorkspaceAISettingsByModeCache = Partial<
+        Record<"plan" | "exec", { model: string; thinkingLevel: ThinkingLevel }>
+      >;
+
       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) {
+      if (variant !== "workspace" || !workspaceId) {
         return;
       }
 
       const effectiveThinkingLevel = enforceThinkingPolicy(canonicalModel, thinkingLevel);
+
+      updatePersistedState<WorkspaceAISettingsByModeCache>(
+        getWorkspaceAISettingsByModeKey(workspaceId),
+        (prev) => {
+          const record: WorkspaceAISettingsByModeCache =
+            prev && typeof prev === "object" ? prev : {};
+          return {
+            ...record,
+            [mode]: { model: canonicalModel, thinkingLevel: effectiveThinkingLevel },
+          };
+        },
+        {}
+      );
+
+      // Workspace variant: persist to backend for cross-device consistency.
+      if (!api) {
+        return;
+      }
+
       api.workspace
-        .updateAISettings({
+        .updateModeAISettings({
           workspaceId,
+          mode,
           aiSettings: { model: canonicalModel, thinkingLevel: effectiveThinkingLevel },
         })
         .catch(() => {
           // Best-effort only. If offline or backend is old, sendMessage will persist.
         });
     },
-    [api, storageKeys.modelKey, ensureModelInSettings, thinkingLevel, variant, workspaceId]
+    [api, mode, storageKeys.modelKey, ensureModelInSettings, thinkingLevel, variant, workspaceId]
   );
   const deferredModel = useDeferredValue(preferredModel);
   const deferredInput = useDeferredValue(input);

src/browser/components/ChatInput/useCreationWorkspace.ts

@@ -13,6 +13,7 @@ import {
   getModelKey,
   getModeKey,
   getThinkingLevelKey,
+  getWorkspaceAISettingsByModeKey,
   getPendingScopeId,
   getProjectScopeId,
 } from "@/common/constants/storage";
@@ -54,6 +55,27 @@ function syncCreationPreferences(projectPath: string, workspaceId: string): void
   if (projectThinkingLevel !== null) {
     updatePersistedState(getThinkingLevelKey(workspaceId), projectThinkingLevel);
   }
+
+  if (projectModel) {
+    const effectiveMode: UIMode = projectMode ?? "exec";
+    const effectiveThinking: ThinkingLevel = projectThinkingLevel ?? "off";
+
+    updatePersistedState<
+      Partial<Record<"plan" | "exec", { model: string; thinkingLevel: ThinkingLevel }>>
+    >(
+      getWorkspaceAISettingsByModeKey(workspaceId),
+      (prev) => {
+        const record = prev && typeof prev === "object" ? prev : {};
+        return {
+          ...(record as Partial<
+            Record<"plan" | "exec", { model: string; thinkingLevel: ThinkingLevel }>
+          >),
+          [effectiveMode]: { model: projectModel, thinkingLevel: effectiveThinking },
+        };
+      },
+      {}
+    );
+  }
 }
 
 interface UseCreationWorkspaceReturn {
@@ -205,17 +227,32 @@ export function useCreationWorkspace({
 
         // 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.
-          });
+        try {
+          api.workspace
+            .updateModeAISettings({
+              workspaceId: metadata.id,
+              mode: settings.mode,
+              aiSettings: {
+                model: settings.model,
+                thinkingLevel: settings.thinkingLevel,
+              },
+            })
+            .catch(() => {
+              // Ignore (offline / older backend). sendMessage will persist as a fallback.
+            });
+        } catch {
+          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) {
@@ -259,6 +296,7 @@ export function useCreationWorkspace({
       projectScopeId,
       onWorkspaceCreated,
       getRuntimeString,
+      settings.mode,
       settings.model,
       settings.thinkingLevel,
       settings.trunkBranch,

src/browser/components/Settings/SettingsModal.tsx

@@ -1,10 +1,11 @@
 import React from "react";
-import { Settings, Key, Cpu, X, Briefcase, FlaskConical, Bot } from "lucide-react";
+import { Settings, Key, Cpu, X, Briefcase, FlaskConical, Bot, Layers } from "lucide-react";
 import { useSettings } from "@/browser/contexts/SettingsContext";
 import { Dialog, DialogContent, DialogTitle, VisuallyHidden } from "@/browser/components/ui/dialog";
 import { GeneralSection } from "./sections/GeneralSection";
 import { TasksSection } from "./sections/TasksSection";
 import { ProvidersSection } from "./sections/ProvidersSection";
+import { ModesSection } from "./sections/ModesSection";
 import { ModelsSection } from "./sections/ModelsSection";
 import { Button } from "@/browser/components/ui/button";
 import { ProjectSettingsSection } from "./sections/ProjectSettingsSection";
@@ -36,6 +37,12 @@ const SECTIONS: SettingsSection[] = [
     icon: <Briefcase className="h-4 w-4" />,
     component: ProjectSettingsSection,
   },
+  {
+    id: "modes",
+    label: "Modes",
+    icon: <Layers className="h-4 w-4" />,
+    component: ModesSection,
+  },
   {
     id: "models",
     label: "Models",