🤖 fix: prevent model selection race condition in creation mode

There were two issues causing the wrong model to be used when creating workspaces:

1. **Stale React state**: The `handleSend` callback in `useCreationWorkspace`
   captured `sendMessageOptions` from `useSendMessageOptions`, but that hook's
   state updates were delayed by `requestAnimationFrame` batching in
   `usePersistedState`. If the user selected a model and clicked send before
   the next animation frame, the old model value would be used.

2. **Effect overwriting selection**: The useEffect that initialized the model
   to the default when entering creation mode could re-run and overwrite the
   user's selection if `defaultModel` changed for any reason.

**Fixes:**
- Read send options fresh from localStorage at send time using
  `getSendOptionsFromStorage` instead of relying on potentially-stale
  React state
- Track initialization state with a ref so the model is only set once
  per entry into creation mode, not on every `defaultModel` change

Also added `mode` field to `getSendOptionsFromStorage` return value for
parity with `useSendMessageOptions`.

_Generated with `mux`_

Author: ibetitsmike

src/browser/components/ChatInput/index.tsx

@@ -182,12 +182,21 @@ export const ChatInput: React.FC<ChatInputProps> = (props) => {
     [storageKeys.modelKey, addModel]
   );
 
-  // When entering creation mode (or when the default model changes), reset the
-  // project-scoped model to the explicit default so manual picks don't bleed
-  // into subsequent creation flows.
+  // When entering creation mode, initialize the project-scoped model to the
+  // default so previous manual picks don't bleed into new creation flows.
+  // Only runs once per creation session (not when defaultModel changes, which
+  // would clobber the user's intentional model selection).
+  const creationModelInitialized = useRef<string | null>(null);
   useEffect(() => {
     if (variant === "creation" && defaultModel) {
-      updatePersistedState(storageKeys.modelKey, defaultModel);
+      // Only initialize once per project scope
+      if (creationModelInitialized.current !== storageKeys.modelKey) {
+        creationModelInitialized.current = storageKeys.modelKey;
+        updatePersistedState(storageKeys.modelKey, defaultModel);
+      }
+    } else if (variant !== "creation") {
+      // Reset when leaving creation mode so re-entering triggers initialization
+      creationModelInitialized.current = null;
     }
   }, [variant, defaultModel, storageKeys.modelKey]);
 

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

@@ -2,12 +2,13 @@ import type { DraftWorkspaceSettings } from "@/browser/hooks/useDraftWorkspaceSe
 import {
   getInputKey,
   getModeKey,
+  getModelKey,
   getPendingScopeId,
   getProjectScopeId,
   getThinkingLevelKey,
 } from "@/common/constants/storage";
 import type { SendMessageError } from "@/common/types/errors";
-import type { BranchListResult, IPCApi, SendMessageOptions } from "@/common/types/ipc";
+import type { BranchListResult, IPCApi } from "@/common/types/ipc";
 import type { RuntimeMode } from "@/common/types/runtime";
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
 import { act, cleanup, render, waitFor } from "@testing-library/react";
@@ -56,14 +57,8 @@ void mock.module("@/browser/hooks/useDraftWorkspaceSettings", () => ({
   useDraftWorkspaceSettings: useDraftWorkspaceSettingsMock,
 }));
 
-let currentSendOptions: SendMessageOptions;
-const useSendMessageOptionsMock = mock(() => currentSendOptions);
-
 type WorkspaceSendMessage = IPCApi["workspace"]["sendMessage"];
 type WorkspaceSendMessageParams = Parameters<WorkspaceSendMessage>;
-void mock.module("@/browser/hooks/useSendMessageOptions", () => ({
-  useSendMessageOptions: useSendMessageOptionsMock,
-}));
 
 const TEST_PROJECT_PATH = "/projects/demo";
 const TEST_WORKSPACE_ID = "ws-created";
@@ -86,11 +81,6 @@ describe("useCreationWorkspace", () => {
     updatePersistedStateCalls.length = 0;
     draftSettingsInvocations = [];
     draftSettingsState = createDraftSettingsHarness();
-    currentSendOptions = {
-      model: "gpt-4",
-      thinkingLevel: "medium",
-      mode: "exec",
-    } satisfies SendMessageOptions;
   });
 
   afterEach(() => {
@@ -180,6 +170,8 @@ describe("useCreationWorkspace", () => {
 
     persistedPreferences[getModeKey(getProjectScopeId(TEST_PROJECT_PATH))] = "plan";
     persistedPreferences[getThinkingLevelKey(getProjectScopeId(TEST_PROJECT_PATH))] = "high";
+    // Set model preference for the project scope (read by getSendOptionsFromStorage)
+    persistedPreferences[getModelKey(getProjectScopeId(TEST_PROJECT_PATH))] = "gpt-4";
 
     draftSettingsState = createDraftSettingsHarness({
       runtimeMode: "ssh",
@@ -207,8 +199,10 @@ describe("useCreationWorkspace", () => {
     expect(options?.projectPath).toBe(TEST_PROJECT_PATH);
     expect(options?.trunkBranch).toBe("dev");
     expect(options?.model).toBe("gpt-4");
-    expect(options?.mode).toBe("exec");
-    expect(options?.thinkingLevel).toBe("medium");
+    // Mode was set to "plan" in persistedPreferences, so that's what we expect
+    expect(options?.mode).toBe("plan");
+    // thinkingLevel was set to "high" in persistedPreferences
+    expect(options?.thinkingLevel).toBe("high");
     expect(options?.runtimeConfig).toEqual({
       type: "ssh",
       host: "example.com",

src/browser/components/ChatInput/useCreationWorkspace.ts

@@ -6,7 +6,7 @@ import type { ThinkingLevel } from "@/common/types/thinking";
 import { parseRuntimeString } from "@/browser/utils/chatCommands";
 import { useDraftWorkspaceSettings } from "@/browser/hooks/useDraftWorkspaceSettings";
 import { readPersistedState, updatePersistedState } from "@/browser/hooks/usePersistedState";
-import { useSendMessageOptions } from "@/browser/hooks/useSendMessageOptions";
+import { getSendOptionsFromStorage } from "@/browser/utils/messages/sendOptions";
 import {
   getInputKey,
   getModeKey,
@@ -72,8 +72,8 @@ export function useCreationWorkspace({
   const { settings, setRuntimeOptions, setTrunkBranch, getRuntimeString } =
     useDraftWorkspaceSettings(projectPath, branches, recommendedTrunk);
 
-  // Get send options from shared hook (uses project-scoped storage key)
-  const sendMessageOptions = useSendMessageOptions(getProjectScopeId(projectPath));
+  // Project scope ID for reading send options at send time
+  const projectScopeId = getProjectScopeId(projectPath);
 
   // Load branches on mount
   useEffect(() => {
@@ -108,6 +108,11 @@ export function useCreationWorkspace({
           ? parseRuntimeString(runtimeString, "")
           : undefined;
 
+        // Read send options fresh from localStorage at send time to avoid
+        // race conditions with React state updates (requestAnimationFrame batching
+        // in usePersistedState can delay state updates after model selection)
+        const sendMessageOptions = getSendOptionsFromStorage(projectScopeId);
+
         // Send message with runtime config and creation-specific params
         const result = await window.api.workspace.sendMessage(null, message, {
           ...sendMessageOptions,
@@ -158,9 +163,9 @@ export function useCreationWorkspace({
     [
       isSending,
       projectPath,
+      projectScopeId,
       onWorkspaceCreated,
       getRuntimeString,
-      sendMessageOptions,
       settings.trunkBranch,
     ]
   );

src/browser/utils/messages/sendOptions.ts

@@ -60,6 +60,7 @@ export function getSendOptionsFromStorage(workspaceId: string): SendMessageOptio
 
   return {
     model,
+    mode: mode === "exec" || mode === "plan" ? mode : "exec", // Only pass exec/plan to backend
     thinkingLevel: effectiveThinkingLevel,
     toolPolicy: modeToToolPolicy(mode),
     additionalSystemInstructions,