fix: restore workspace thinking persistence with project seeding

ammar-agent · ammar-agent · commit 0220fe184d0a · 2025-12-06T15:25:17.000-06:00
diff --git a/src/browser/App.tsx b/src/browser/App.tsx
@@ -34,8 +34,7 @@ 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 { getThinkingLevelKey, getModelKey } from "@/common/constants/storage";
-import { getDefaultModel } from "@/browser/hooks/useModelLRU";
+import { getThinkingLevelKey } from "@/common/constants/storage";
 import type { BranchListResult } from "@/common/orpc/types";
 import { useTelemetry } from "./hooks/useTelemetry";
 import { getRuntimeTypeForTelemetry } from "@/common/telemetry";
@@ -267,63 +266,41 @@ function AppInner() {
     close: closeCommandPalette,
   } = useCommandRegistry();
 
-  const getCurrentModelForWorkspace = useCallback(
-    (workspaceId: string): string => {
-      if (!workspaceId) return getDefaultModel();
-      // Prefer live workspace state; fall back to persisted preference
-      const modelFromStore = workspaceStore.getWorkspaceState(workspaceId)?.currentModel;
-      return (
-        modelFromStore ??
-        readPersistedState<string | null>(getModelKey(workspaceId), null) ??
-        getDefaultModel()
-      );
-    },
-    [workspaceStore]
-  );
-
-  const getThinkingLevelForWorkspace = useCallback(
-    (workspaceId: string): ThinkingLevel => {
-      if (!workspaceId) {
-        return "off";
-      }
+  const getThinkingLevelForWorkspace = useCallback((workspaceId: string): ThinkingLevel => {
+    if (!workspaceId) {
+      return "off";
+    }
 
-      try {
-        const model = getCurrentModelForWorkspace(workspaceId);
-        const storedLevel = readPersistedState<ThinkingLevel>(getThinkingLevelKey(model), "off");
-        return THINKING_LEVELS.includes(storedLevel) ? storedLevel : "off";
-      } catch (error) {
-        console.warn("Failed to read thinking level", error);
-        return "off";
-      }
-    },
-    [getCurrentModelForWorkspace]
-  );
+    try {
+      const storedLevel = readPersistedState<ThinkingLevel>(
+        getThinkingLevelKey(workspaceId),
+        "off"
+      );
+      return THINKING_LEVELS.includes(storedLevel) ? storedLevel : "off";
+    } catch (error) {
+      console.warn("Failed to read thinking level", error);
+      return "off";
+    }
+  }, []);
 
-  const setThinkingLevelFromPalette = useCallback(
-    (workspaceId: string, level: ThinkingLevel) => {
-      if (!workspaceId) {
-        return;
-      }
+  const setThinkingLevelFromPalette = useCallback((workspaceId: string, level: ThinkingLevel) => {
+    if (!workspaceId) {
+      return;
+    }
 
-      const model = getCurrentModelForWorkspace(workspaceId);
-      const normalized = THINKING_LEVELS.includes(level) ? level : "off";
-      const key = getThinkingLevelKey(model);
+    const normalized = THINKING_LEVELS.includes(level) ? level : "off";
+    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, normalized);
 
-      // Dispatch toast notification event for UI feedback
-      if (typeof window !== "undefined") {
-        window.dispatchEvent(
-          new CustomEvent(CUSTOM_EVENTS.THINKING_LEVEL_TOAST, {
-            detail: { workspaceId, level: normalized },
-          })
-        );
-      }
-    },
-    [getCurrentModelForWorkspace]
-  );
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(
+        new CustomEvent(CUSTOM_EVENTS.THINKING_LEVEL_TOAST, {
+          detail: { workspaceId, level: normalized },
+        })
+      );
+    }
+  }, []);
 
   const registerParamsRef = useRef<BuildSourcesParams | null>(null);
 
diff --git a/src/browser/components/ChatInput/useCreationWorkspace.test.tsx b/src/browser/components/ChatInput/useCreationWorkspace.test.tsx
@@ -404,10 +404,8 @@ describe("useCreationWorkspace", () => {
     });
 
     persistedPreferences[getModeKey(getProjectScopeId(TEST_PROJECT_PATH))] = "plan";
-    // Set model preference for the project scope (read by getSendOptionsFromStorage)
     persistedPreferences[getModelKey(getProjectScopeId(TEST_PROJECT_PATH))] = "gpt-4";
-    // Thinking level is now stored per-model, not per-workspace/project
-    persistedPreferences[getThinkingLevelKey("gpt-4")] = "high";
+    persistedPreferences[getThinkingLevelKey(getProjectScopeId(TEST_PROJECT_PATH))] = "high";
 
     draftSettingsState = createDraftSettingsHarness({
       runtimeMode: "ssh",
@@ -461,14 +459,15 @@ describe("useCreationWorkspace", () => {
     expect(onWorkspaceCreated.mock.calls[0][0]).toEqual(TEST_METADATA);
 
     const projectModeKey = getModeKey(getProjectScopeId(TEST_PROJECT_PATH));
+    const projectThinkingKey = getThinkingLevelKey(getProjectScopeId(TEST_PROJECT_PATH));
     expect(readPersistedStateCalls).toContainEqual([projectModeKey, null]);
-    // Thinking level is now read per-model (gpt-4), not per-project
-    expect(readPersistedStateCalls).toContainEqual([getThinkingLevelKey("gpt-4"), "off"]);
+    expect(readPersistedStateCalls).toContainEqual([projectThinkingKey, null]);
 
     const modeKey = getModeKey(TEST_WORKSPACE_ID);
+    const thinkingKey = getThinkingLevelKey(TEST_WORKSPACE_ID);
     const pendingInputKey = getInputKey(getPendingScopeId(TEST_PROJECT_PATH));
     expect(updatePersistedStateCalls).toContainEqual([modeKey, "plan"]);
-    // Note: Thinking level is now per-model, not per-workspace, so no sync to workspace
+    expect(updatePersistedStateCalls).toContainEqual([thinkingKey, "high"]);
     expect(updatePersistedStateCalls).toContainEqual([pendingInputKey, ""]);
   });
 
diff --git a/src/browser/components/ChatInput/useCreationWorkspace.ts b/src/browser/components/ChatInput/useCreationWorkspace.ts
@@ -12,12 +12,14 @@ import {
   getModeKey,
   getPendingScopeId,
   getProjectScopeId,
+  getThinkingLevelKey,
 } from "@/common/constants/storage";
 import type { Toast } from "@/browser/components/ChatInputToast";
 import { createErrorToast } from "@/browser/components/ChatInputToasts";
 import { useAPI } from "@/browser/contexts/API";
 import type { ImagePart } from "@/common/orpc/types";
 import { useWorkspaceName, type WorkspaceNameState } from "@/browser/hooks/useWorkspaceName";
+import type { ThinkingLevel } from "@/common/types/thinking";
 
 interface UseCreationWorkspaceOptions {
   projectPath: string;
@@ -30,7 +32,6 @@ function syncCreationPreferences(projectPath: string, workspaceId: string): void
   const projectScopeId = getProjectScopeId(projectPath);
 
   // Sync model from project scope to workspace scope
-  // This ensures the model used for creation is persisted for future resumes
   const projectModel = readPersistedState<string | null>(getModelKey(projectScopeId), null);
   if (projectModel) {
     updatePersistedState(getModelKey(workspaceId), projectModel);
@@ -41,8 +42,14 @@ function syncCreationPreferences(projectPath: string, workspaceId: string): void
     updatePersistedState(getModeKey(workspaceId), projectMode);
   }
 
-  // Note: Thinking level is now stored per-model, not per-workspace,
-  // so no syncing needed here
+  // Use the project's last thinking level to seed the new workspace
+  const projectThinking = readPersistedState<ThinkingLevel | null>(
+    getThinkingLevelKey(projectScopeId),
+    null
+  );
+  if (projectThinking) {
+    updatePersistedState(getThinkingLevelKey(workspaceId), projectThinking);
+  }
 }
 
 interface UseCreationWorkspaceReturn {
diff --git a/src/browser/contexts/ThinkingContext.tsx b/src/browser/contexts/ThinkingContext.tsx
@@ -1,18 +1,12 @@
 import type { ReactNode } from "react";
-import React, { createContext, useContext, useEffect, useState, useCallback } from "react";
+import React, { createContext, useContext } from "react";
 import type { ThinkingLevel } from "@/common/types/thinking";
-import {
-  usePersistedState,
-  readPersistedState,
-  updatePersistedState,
-} from "@/browser/hooks/usePersistedState";
+import { usePersistedState } from "@/browser/hooks/usePersistedState";
 import {
   getThinkingLevelKey,
   getProjectScopeId,
-  getModelKey,
   GLOBAL_SCOPE_ID,
 } from "@/common/constants/storage";
-import { getDefaultModel } from "@/browser/hooks/useModelLRU";
 
 interface ThinkingContextType {
   thinkingLevel: ThinkingLevel;
@@ -22,73 +16,23 @@ interface ThinkingContextType {
 const ThinkingContext = createContext<ThinkingContextType | undefined>(undefined);
 
 interface ThinkingProviderProps {
-  workspaceId?: string; // Workspace-scoped storage for model selection
-  projectPath?: string; // Project-scoped storage for model selection (fallback)
+  workspaceId?: string; // Workspace-scoped storage (highest priority)
+  projectPath?: string; // Project-scoped storage (fallback if no workspaceId)
   children: ReactNode;
 }
 
-/**
- * ThinkingProvider manages thinking level state per model.
- *
- * The thinking level is stored per model (e.g., "thinkingLevel:claude-sonnet-4-20250514")
- * so users can set different levels for different models and have them remembered.
- *
- * When the selected model changes, the thinking level is loaded from that model's storage.
- */
 export const ThinkingProvider: React.FC<ThinkingProviderProps> = ({
   workspaceId,
   projectPath,
   children,
 }) => {
-  // Derive model storage scope (workspace or project)
-  const modelScopeId =
-    workspaceId ?? (projectPath ? getProjectScopeId(projectPath) : GLOBAL_SCOPE_ID);
-  const modelKey = getModelKey(modelScopeId);
-
-  // Listen for model changes in this scope
-  const [selectedModel] = usePersistedState<string | null>(modelKey, null, { listener: true });
-  const currentModel = selectedModel ?? getDefaultModel();
-
-  // Local state for thinking level (managed per model)
-  const [thinkingLevel, setThinkingLevelState] = useState<ThinkingLevel>(() => {
-    return readPersistedState<ThinkingLevel>(getThinkingLevelKey(currentModel), "off");
+  // Priority: workspace-scoped > project-scoped > global
+  const scopeId = workspaceId ?? (projectPath ? getProjectScopeId(projectPath) : GLOBAL_SCOPE_ID);
+  const key = getThinkingLevelKey(scopeId);
+  const [thinkingLevel, setThinkingLevel] = usePersistedState<ThinkingLevel>(key, "off", {
+    listener: true,
   });
 
-  // When model changes, load that model's thinking level
-  useEffect(() => {
-    const modelThinkingKey = getThinkingLevelKey(currentModel);
-    const modelThinkingLevel = readPersistedState<ThinkingLevel>(modelThinkingKey, "off");
-    setThinkingLevelState(modelThinkingLevel);
-  }, [currentModel]);
-
-  // Listen for storage events (from command palette or other sources)
-  useEffect(() => {
-    const modelThinkingKey = getThinkingLevelKey(currentModel);
-
-    const handleStorage = (e: StorageEvent) => {
-      if (e.key === modelThinkingKey && e.newValue) {
-        try {
-          const parsed = JSON.parse(e.newValue) as ThinkingLevel;
-          setThinkingLevelState(parsed);
-        } catch {
-          // Invalid JSON, ignore
-        }
-      }
-    };
-
-    window.addEventListener("storage", handleStorage);
-    return () => window.removeEventListener("storage", handleStorage);
-  }, [currentModel]);
-
-  // Save thinking level to current model's storage
-  const setThinkingLevel = useCallback(
-    (level: ThinkingLevel) => {
-      setThinkingLevelState(level);
-      updatePersistedState(getThinkingLevelKey(currentModel), level);
-    },
-    [currentModel]
-  );
-
   return (
     <ThinkingContext.Provider value={{ thinkingLevel, setThinkingLevel }}>
       {children}
diff --git a/src/browser/utils/messages/sendOptions.ts b/src/browser/utils/messages/sendOptions.ts
@@ -40,9 +40,9 @@ export function getSendOptionsFromStorage(workspaceId: string): SendMessageOptio
   // Read model preference (workspace-specific), fallback to LRU default
   const model = readPersistedState<string>(getModelKey(workspaceId), getDefaultModel());
 
-  // Read thinking level (per-model)
+  // Read thinking level (workspace-specific)
   const thinkingLevel = readPersistedState<ThinkingLevel>(
-    getThinkingLevelKey(model),
+    getThinkingLevelKey(workspaceId),
     WORKSPACE_DEFAULTS.thinkingLevel
   );
 
diff --git a/src/common/constants/storage.ts b/src/common/constants/storage.ts
@@ -49,15 +49,10 @@ export const SELECTED_WORKSPACE_KEY = "selectedWorkspace";
 export const EXPANDED_PROJECTS_KEY = "expandedProjects";
 
 /**
- * Helper to create a thinking level storage key for a model.
- * Format: "thinkingLevel:{modelName}"
- *
- * Thinking level is now persisted per-model so users can set different
- * levels for different models and have them remembered when switching.
- */
-export function getThinkingLevelKey(modelName: string): string {
-  return `thinkingLevel:${modelName}`;
-}
+ * Helper to create a thinking level storage key for a scope (workspace or project).
+ * Format: "thinkingLevel:{scopeId}"
+ */
+export const getThinkingLevelKey = (scopeId: string): string => `thinkingLevel:${scopeId}`;
 
 /**
  * Get the localStorage key for the user's preferred model for a workspace
@@ -222,14 +217,15 @@ const PERSISTENT_WORKSPACE_KEY_FUNCTIONS: Array<(workspaceId: string) => string>
   getModelKey,
   getInputKey,
   getModeKey,
+  getThinkingLevelKey,
   getAutoRetryKey,
   getRetryStateKey,
   getReviewExpandStateKey,
   getFileTreeExpandStateKey,
   getReviewSearchStateKey,
   getAutoCompactionEnabledKey,
   getStatusUrlKey,
-  // Note: getAutoCompactionThresholdKey and getThinkingLevelKey are per-model, not per-workspace
+  // Note: getAutoCompactionThresholdKey is per-model, not per-workspace
 ];
 
 /**
