🤖 feat: add fetch-latest option for workspace creation

src/browser/api.ts

@@ -211,8 +211,15 @@ const webApi: IPCApi = {
   },
   workspace: {
     list: () => invokeIPC(IPC_CHANNELS.WORKSPACE_LIST),
-    create: (projectPath, branchName, trunkBranch) =>
-      invokeIPC(IPC_CHANNELS.WORKSPACE_CREATE, projectPath, branchName, trunkBranch),
+    create: (projectPath, branchName, trunkBranch, runtimeConfig, options) =>
+      invokeIPC(
+        IPC_CHANNELS.WORKSPACE_CREATE,
+        projectPath,
+        branchName,
+        trunkBranch,
+        runtimeConfig,
+        options
+      ),
     remove: (workspaceId, options) =>
       invokeIPC(IPC_CHANNELS.WORKSPACE_REMOVE, workspaceId, options),
     rename: (workspaceId, newName) =>

src/browser/components/ChatInput/CreationControls.tsx

@@ -7,6 +7,8 @@ interface CreationControlsProps {
   branches: string[];
   trunkBranch: string;
   onTrunkBranchChange: (branch: string) => void;
+  fetchLatest: boolean;
+  onFetchLatestChange: (value: boolean) => void;
   runtimeMode: RuntimeMode;
   sshHost: string;
   onRuntimeChange: (mode: RuntimeMode, host: string) => void;
@@ -74,6 +76,30 @@ export function CreationControls(props: CreationControlsProps) {
           </Tooltip>
         </TooltipWrapper>
       </div>
+
+      {/* Fetch latest option */}
+      <div className="flex items-center gap-1" data-component="FetchLatestGroup">
+        <label className="text-muted flex items-center gap-1 text-xs" htmlFor="fetch-latest">
+          <input
+            id="fetch-latest"
+            type="checkbox"
+            className="accent-accent h-3.5 w-3.5"
+            checked={props.fetchLatest}
+            onChange={(event) => props.onFetchLatestChange(event.target.checked)}
+            disabled={props.disabled}
+          />
+          Fetch latest
+        </label>
+        <TooltipWrapper inline>
+          <span className="text-muted cursor-help text-xs">?</span>
+          <Tooltip className="tooltip" align="center" width="wide">
+            <strong>Fetch latest:</strong>
+            <br />
+            Runs <code>git fetch origin --prune</code> before branching so new workspaces start from
+            the freshest remote state.
+          </Tooltip>
+        </TooltipWrapper>
+      </div>
     </div>
   );
 }

src/browser/components/ChatInput/index.tsx

@@ -993,6 +993,8 @@ export const ChatInput: React.FC<ChatInputProps> = (props) => {
                 branches={creationState.branches}
                 trunkBranch={creationState.trunkBranch}
                 onTrunkBranchChange={creationState.setTrunkBranch}
+                fetchLatest={creationState.fetchLatest}
+                onFetchLatestChange={creationState.setFetchLatest}
                 runtimeMode={creationState.runtimeMode}
                 sshHost={creationState.sshHost}
                 onRuntimeChange={creationState.setRuntimeOptions}

src/browser/components/ChatInput/useCreationWorkspace.ts

@@ -36,6 +36,8 @@ interface UseCreationWorkspaceReturn {
   branches: string[];
   trunkBranch: string;
   setTrunkBranch: (branch: string) => void;
+  fetchLatest: boolean;
+  setFetchLatest: (value: boolean) => void;
   runtimeMode: RuntimeMode;
   sshHost: string;
   setRuntimeOptions: (mode: RuntimeMode, host: string) => void;
@@ -62,7 +64,7 @@ export function useCreationWorkspace({
   const [isSending, setIsSending] = useState(false);
 
   // Centralized draft workspace settings with automatic persistence
-  const { settings, setRuntimeOptions, setTrunkBranch, getRuntimeString } =
+  const { settings, setRuntimeOptions, setTrunkBranch, setFetchLatest, getRuntimeString } =
     useDraftWorkspaceSettings(projectPath, branches, recommendedTrunk);
 
   // Get send options from shared hook (uses project-scoped storage key)
@@ -107,6 +109,7 @@ export function useCreationWorkspace({
           runtimeConfig,
           projectPath, // Pass projectPath when workspaceId is null
           trunkBranch: settings.trunkBranch, // Pass selected trunk branch from settings
+          fetchLatest: settings.fetchLatest, // Fetch remote updates before branching when requested
         });
 
         if (!result.success) {
@@ -139,13 +142,16 @@ export function useCreationWorkspace({
       getRuntimeString,
       sendMessageOptions,
       settings.trunkBranch,
+      settings.fetchLatest,
     ]
   );
 
   return {
     branches,
     trunkBranch: settings.trunkBranch,
     setTrunkBranch,
+    fetchLatest: settings.fetchLatest,
+    setFetchLatest,
     runtimeMode: settings.runtimeMode,
     sshHost: settings.sshHost,
     setRuntimeOptions,

src/browser/contexts/WorkspaceContext.test.tsx

@@ -163,7 +163,13 @@ describe("WorkspaceContext", () => {
       result = await ctx().createWorkspace("/gamma", "feature", "main");
     });
 
-    expect(workspaceApi.create).toHaveBeenCalledWith("/gamma", "feature", "main", undefined);
+    expect(workspaceApi.create).toHaveBeenCalledWith(
+      "/gamma",
+      "feature",
+      "main",
+      undefined,
+      undefined
+    );
     expect(projectsApi.list).toHaveBeenCalled();
     expect(result!.workspaceId).toBe("ws-new");
     expect(result!.projectPath).toBe("/gamma");

src/browser/contexts/WorkspaceContext.tsx

@@ -222,7 +222,8 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
       projectPath: string,
       branchName: string,
       trunkBranch: string,
-      runtimeConfig?: RuntimeConfig
+      runtimeConfig?: RuntimeConfig,
+      options?: { fetchLatest?: boolean }
     ) => {
       console.assert(
         typeof trunkBranch === "string" && trunkBranch.trim().length > 0,
@@ -232,7 +233,8 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
         projectPath,
         branchName,
         trunkBranch,
-        runtimeConfig
+        runtimeConfig,
+        options
       );
       if (result.success) {
         // Backend has already updated the config - reload projects to get updated state

src/browser/hooks/useDraftWorkspaceSettings.ts

@@ -13,6 +13,7 @@ import {
   getModelKey,
   getRuntimeKey,
   getTrunkBranchKey,
+  getFetchLatestKey,
   getProjectScopeId,
 } from "@/common/constants/storage";
 import type { UIMode } from "@/common/types/mode";
@@ -33,6 +34,7 @@ export interface DraftWorkspaceSettings {
   runtimeMode: RuntimeMode;
   sshHost: string;
   trunkBranch: string;
+  fetchLatest: boolean;
 }
 
 /**
@@ -52,6 +54,7 @@ export function useDraftWorkspaceSettings(
   settings: DraftWorkspaceSettings;
   setRuntimeOptions: (mode: RuntimeMode, host: string) => void;
   setTrunkBranch: (branch: string) => void;
+  setFetchLatest: (value: boolean) => void;
   getRuntimeString: () => string | undefined;
 } {
   // Global AI settings (read-only from global state)
@@ -74,7 +77,13 @@ export function useDraftWorkspaceSettings(
     { listener: true }
   );
 
-  // Project-scoped trunk branch preference (persisted per project)
+  // Project-scoped workspace creation preferences (persisted per project)
+  const [fetchLatest, setFetchLatest] = usePersistedState<boolean>(
+    getFetchLatestKey(projectPath),
+    false,
+    { listener: true }
+  );
+
   const [trunkBranch, setTrunkBranch] = usePersistedState<string>(
     getTrunkBranchKey(projectPath),
     "",
@@ -112,9 +121,11 @@ export function useDraftWorkspaceSettings(
       runtimeMode,
       sshHost,
       trunkBranch,
+      fetchLatest,
     },
     setRuntimeOptions,
     setTrunkBranch,
+    setFetchLatest,
     getRuntimeString,
   };
 }

src/browser/utils/chatCommands.ts

@@ -71,6 +71,7 @@ export interface CreateWorkspaceOptions {
   runtime?: string;
   startMessage?: string;
   sendMessageOptions?: SendMessageOptions;
+  fetchLatest?: boolean;
 }
 
 export interface CreateWorkspaceResult {
@@ -107,12 +108,15 @@ export async function createNewWorkspace(
 
   // Parse runtime config if provided
   const runtimeConfig = parseRuntimeString(effectiveRuntime, options.workspaceName);
+  const creationOptions =
+    options.fetchLatest !== undefined ? { fetchLatest: options.fetchLatest } : undefined;
 
   const result = await window.api.workspace.create(
     options.projectPath,
     options.workspaceName,
     effectiveTrunk,
-    runtimeConfig
+    runtimeConfig,
+    creationOptions
   );
 
   if (!result.success) {

src/common/constants/storage.ts

@@ -108,6 +108,15 @@ export function getTrunkBranchKey(projectPath: string): string {
   return `trunkBranch:${projectPath}`;
 }
 
+/**
+ * Get the localStorage key for the fetch-latest preference for a project
+ * Stores the last fetch option state when creating a workspace
+ * Format: "fetchLatest:{projectPath}"
+ */
+export function getFetchLatestKey(projectPath: string): string {
+  return `fetchLatest:${projectPath}`;
+}
+
 /**
  * Get the localStorage key for the 1M context preference (global)
  * Format: "use1MContext"

src/common/types/ipc.ts

@@ -188,6 +188,7 @@ export interface SendMessageOptions {
   maxOutputTokens?: number;
   providerOptions?: MuxProviderOptions;
   mode?: string; // Mode name - frontend narrows to specific values, backend accepts any string
+  fetchLatest?: boolean;
   muxMetadata?: MuxFrontendMetadata; // Frontend-defined metadata, backend treats as black-box
 }
 
@@ -233,7 +234,8 @@ export interface IPCApi {
       projectPath: string,
       branchName: string,
       trunkBranch: string,
-      runtimeConfig?: RuntimeConfig
+      runtimeConfig?: RuntimeConfig,
+      options?: { fetchLatest?: boolean }
     ): Promise<
       { success: true; metadata: FrontendWorkspaceMetadata } | { success: false; error: string }
     >;
@@ -260,6 +262,7 @@ export interface IPCApi {
         runtimeConfig?: RuntimeConfig;
         projectPath?: string; // Required when workspaceId is null
         trunkBranch?: string; // Optional - trunk branch to branch from (when workspaceId is null)
+        fetchLatest?: boolean; // Optional - fetch origin before branching (when workspaceId is null)
       }
     ): Promise<
       | Result<void, SendMessageError>

src/desktop/preload.ts

@@ -54,13 +54,14 @@ const api: IPCApi = {
   },
   workspace: {
     list: () => ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_LIST),
-    create: (projectPath, branchName, trunkBranch: string, runtimeConfig?) =>
+    create: (projectPath, branchName, trunkBranch: string, runtimeConfig?, options?) =>
       ipcRenderer.invoke(
         IPC_CHANNELS.WORKSPACE_CREATE,
         projectPath,
         branchName,
         trunkBranch,
-        runtimeConfig
+        runtimeConfig,
+        options
       ),
     remove: (workspaceId: string, options?: { force?: boolean }) =>
       ipcRenderer.invoke(IPC_CHANNELS.WORKSPACE_REMOVE, workspaceId, options),

src/node/runtime/LocalRuntime.ts

@@ -318,7 +318,7 @@ export class LocalRuntime implements Runtime {
   }
 
   async createWorkspace(params: WorkspaceCreationParams): Promise<WorkspaceCreationResult> {
-    const { projectPath, branchName, trunkBranch, initLogger } = params;
+    const { projectPath, branchName, trunkBranch, initLogger, fetchLatest = false } = params;
 
     try {
       // Compute workspace path using the canonical method
@@ -344,6 +344,34 @@ export class LocalRuntime implements Runtime {
         // Workspace doesn't exist, proceed with creation
       }
 
+      if (fetchLatest) {
+        initLogger.logStep("Fetching latest from origin...");
+        try {
+          using proc = execAsync(`git -C "${projectPath}" fetch origin --prune`);
+          await proc.result;
+          initLogger.logStep("Origin fetch complete");
+        } catch (error) {
+          const errorMessage = getErrorMessage(error);
+          return {
+            success: false,
+            error: `Failed to fetch origin: ${errorMessage}`,
+          };
+        }
+      }
+
+      let baseRef = trunkBranch;
+      if (fetchLatest) {
+        try {
+          using proc = execAsync(
+            `git -C "${projectPath}" rev-parse --verify "origin/${trunkBranch}"`
+          );
+          await proc.result;
+          baseRef = `origin/${trunkBranch}`;
+        } catch {
+          // Remote branch missing - fall back to local trunk branch
+        }
+      }
+
       // Check if branch exists locally
       const localBranches = await listLocalBranches(projectPath);
       const branchExists = localBranches.includes(branchName);
@@ -358,7 +386,7 @@ export class LocalRuntime implements Runtime {
       } else {
         // Branch doesn't exist, create it from trunk
         using proc = execAsync(
-          `git -C "${projectPath}" worktree add -b "${branchName}" "${workspacePath}" "${trunkBranch}"`
+          `git -C "${projectPath}" worktree add -b "${branchName}" "${workspacePath}" "${baseRef}"`
         );
         await proc.result;
       }

src/node/runtime/Runtime.ts

@@ -121,6 +121,8 @@ export interface WorkspaceCreationParams {
   directoryName: string;
   /** Logger for streaming creation progress and init hook output */
   initLogger: InitLogger;
+  /** Whether to fetch remote updates before branching */
+  fetchLatest?: boolean;
   /** Optional abort signal for cancellation */
   abortSignal?: AbortSignal;
 }
@@ -149,6 +151,8 @@ export interface WorkspaceInitParams {
   workspacePath: string;
   /** Logger for streaming initialization progress and output */
   initLogger: InitLogger;
+  /** Whether to fetch remote updates before branching */
+  fetchLatest?: boolean;
   /** Optional abort signal for cancellation */
   abortSignal?: AbortSignal;
 }