🤖 feat: add 'Pull latest' checkbox to workspace creation

Add checkbox after the From: dropdown that fetches and rebases the
workspace on the latest version of the trunk branch from origin.

UI Changes:
- Add checkbox to CreationControls.tsx with persisted state
- Expose pullLatest setting via useDraftWorkspaceSettings hook
- Wire through useCreationWorkspace to sendMessage options

Backend Changes:
- Add pullLatest param to WorkspaceCreationParams and WorkspaceInitParams
- LocalRuntime: fetch origin/trunk and rebase after worktree creation
- SSHRuntime: fetch and rebase after branch checkout during init

Error Handling:
- Network errors during fetch: log warning, continue without pull
- Rebase conflicts: abort rebase, log warning, continue with original state
- Best-effort operation that never fails workspace creation

_Generated with mux_

Author: ibetitsmike

src/browser/components/ChatInput/CreationControls.tsx

@@ -2,11 +2,14 @@ import React from "react";
 import { RUNTIME_MODE, type RuntimeMode } from "@/common/types/runtime";
 import { TooltipWrapper, Tooltip } from "../Tooltip";
 import { Select } from "../Select";
+import { Checkbox } from "../ui/checkbox";
 
 interface CreationControlsProps {
   branches: string[];
   trunkBranch: string;
   onTrunkBranchChange: (branch: string) => void;
+  pullLatest: boolean;
+  onPullLatestChange: (checked: boolean) => void;
   runtimeMode: RuntimeMode;
   sshHost: string;
   onRuntimeChange: (mode: RuntimeMode, host: string) => void;
@@ -35,6 +38,18 @@ export function CreationControls(props: CreationControlsProps) {
             disabled={props.disabled}
             className="max-w-[120px]"
           />
+          <div className="flex items-center gap-1">
+            <Checkbox
+              id="pull-latest"
+              checked={props.pullLatest}
+              onCheckedChange={(checked) => props.onPullLatestChange(checked === true)}
+              disabled={props.disabled}
+              className="h-3.5 w-3.5"
+            />
+            <label htmlFor="pull-latest" className="text-muted cursor-pointer text-xs select-none">
+              Pull latest
+            </label>
+          </div>
         </div>
       )}
 

src/browser/components/ChatInput/index.tsx

@@ -989,6 +989,8 @@ export const ChatInput: React.FC<ChatInputProps> = (props) => {
                 branches={creationState.branches}
                 trunkBranch={creationState.trunkBranch}
                 onTrunkBranchChange={creationState.setTrunkBranch}
+                pullLatest={creationState.pullLatest}
+                onPullLatestChange={creationState.setPullLatest}
                 runtimeMode={creationState.runtimeMode}
                 sshHost={creationState.sshHost}
                 onRuntimeChange={creationState.setRuntimeOptions}

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

@@ -266,18 +266,21 @@ function createDraftSettingsHarness(
     runtimeMode: RuntimeMode;
     sshHost: string;
     trunkBranch: string;
+    pullLatest: boolean;
     runtimeString?: string | undefined;
   }>
 ) {
   const state = {
     runtimeMode: initial?.runtimeMode ?? ("local" as RuntimeMode),
     sshHost: initial?.sshHost ?? "",
     trunkBranch: initial?.trunkBranch ?? "main",
+    pullLatest: initial?.pullLatest ?? true,
     runtimeString: initial?.runtimeString,
   } satisfies {
     runtimeMode: RuntimeMode;
     sshHost: string;
     trunkBranch: string;
+    pullLatest: boolean;
     runtimeString: string | undefined;
   };
 
@@ -292,17 +295,23 @@ function createDraftSettingsHarness(
     state.trunkBranch = branch;
   });
 
+  const setPullLatest = mock((enabled: boolean) => {
+    state.pullLatest = enabled;
+  });
+
   const getRuntimeString = mock(() => state.runtimeString);
 
   return {
     state,
     setRuntimeOptions,
     setTrunkBranch,
+    setPullLatest,
     getRuntimeString,
     snapshot(): {
       settings: DraftWorkspaceSettings;
       setRuntimeOptions: typeof setRuntimeOptions;
       setTrunkBranch: typeof setTrunkBranch;
+      setPullLatest: typeof setPullLatest;
       getRuntimeString: typeof getRuntimeString;
     } {
       const settings: DraftWorkspaceSettings = {
@@ -312,11 +321,13 @@ function createDraftSettingsHarness(
         runtimeMode: state.runtimeMode,
         sshHost: state.sshHost,
         trunkBranch: state.trunkBranch,
+        pullLatest: state.pullLatest,
       };
       return {
         settings,
         setRuntimeOptions,
         setTrunkBranch,
+        setPullLatest,
         getRuntimeString,
       };
     },

src/browser/components/ChatInput/useCreationWorkspace.ts

@@ -43,6 +43,8 @@ interface UseCreationWorkspaceReturn {
   branches: string[];
   trunkBranch: string;
   setTrunkBranch: (branch: string) => void;
+  pullLatest: boolean;
+  setPullLatest: (enabled: boolean) => void;
   runtimeMode: RuntimeMode;
   sshHost: string;
   setRuntimeOptions: (mode: RuntimeMode, host: string) => void;
@@ -69,7 +71,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, setPullLatest, getRuntimeString } =
     useDraftWorkspaceSettings(projectPath, branches, recommendedTrunk);
 
   // Get send options from shared hook (uses project-scoped storage key)
@@ -114,6 +116,7 @@ export function useCreationWorkspace({
           runtimeConfig,
           projectPath, // Pass projectPath when workspaceId is null
           trunkBranch: settings.trunkBranch, // Pass selected trunk branch from settings
+          pullLatest: settings.pullLatest, // Pass pull latest preference
         });
 
         if (!result.success) {
@@ -162,13 +165,16 @@ export function useCreationWorkspace({
       getRuntimeString,
       sendMessageOptions,
       settings.trunkBranch,
+      settings.pullLatest,
     ]
   );
 
   return {
     branches,
     trunkBranch: settings.trunkBranch,
     setTrunkBranch,
+    pullLatest: settings.pullLatest,
+    setPullLatest,
     runtimeMode: settings.runtimeMode,
     sshHost: settings.sshHost,
     setRuntimeOptions,

src/browser/hooks/useDraftWorkspaceSettings.ts

@@ -12,6 +12,7 @@ import {
   getModelKey,
   getRuntimeKey,
   getTrunkBranchKey,
+  getPullLatestKey,
   getProjectScopeId,
 } from "@/common/constants/storage";
 import type { UIMode } from "@/common/types/mode";
@@ -31,6 +32,7 @@ export interface DraftWorkspaceSettings {
   runtimeMode: RuntimeMode;
   sshHost: string;
   trunkBranch: string;
+  pullLatest: boolean;
 }
 
 /**
@@ -50,6 +52,7 @@ export function useDraftWorkspaceSettings(
   settings: DraftWorkspaceSettings;
   setRuntimeOptions: (mode: RuntimeMode, host: string) => void;
   setTrunkBranch: (branch: string) => void;
+  setPullLatest: (enabled: boolean) => void;
   getRuntimeString: () => string | undefined;
 } {
   // Global AI settings (read-only from global state)
@@ -78,6 +81,13 @@ export function useDraftWorkspaceSettings(
     { listener: true }
   );
 
+  // Project-scoped pull latest preference (persisted per project, default true)
+  const [pullLatest, setPullLatest] = usePersistedState<boolean>(
+    getPullLatestKey(projectPath),
+    true,
+    { listener: true }
+  );
+
   // Parse runtime string into mode and host
   const { mode: runtimeMode, host: sshHost } = parseRuntimeModeAndHost(runtimeString);
 
@@ -108,9 +118,11 @@ export function useDraftWorkspaceSettings(
       runtimeMode,
       sshHost,
       trunkBranch,
+      pullLatest,
     },
     setRuntimeOptions,
     setTrunkBranch,
+    setPullLatest,
     getRuntimeString,
   };
 }

src/common/constants/storage.ts

@@ -114,6 +114,15 @@ export function getTrunkBranchKey(projectPath: string): string {
   return `trunkBranch:${projectPath}`;
 }
 
+/**
+ * Get the localStorage key for pull latest preference for a project
+ * Stores whether to fetch and rebase on latest origin/<trunk> when creating a workspace
+ * Format: "pullLatest:{projectPath}"
+ */
+export function getPullLatestKey(projectPath: string): string {
+  return `pullLatest:${projectPath}`;
+}
+
 /**
  * Get the localStorage key for the preferred compaction model (global)
  * Format: "preferredCompactionModel"

src/common/types/ipc.ts

@@ -309,6 +309,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)
+        pullLatest?: boolean; // Optional - fetch and rebase on origin/<trunk> (when workspaceId is null)
       }
     ): Promise<
       | Result<void, SendMessageError>

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, pullLatest } = params;
 
     try {
       // Compute workspace path using the canonical method
@@ -365,6 +365,11 @@ export class LocalRuntime implements Runtime {
 
       initLogger.logStep("Worktree created successfully");
 
+      // Pull latest from origin if requested (best-effort, non-blocking on failure)
+      if (pullLatest) {
+        await this.pullLatestFromOrigin(workspacePath, trunkBranch, initLogger);
+      }
+
       return { success: true, workspacePath };
     } catch (error) {
       return {
@@ -374,6 +379,45 @@ export class LocalRuntime implements Runtime {
     }
   }
 
+  /**
+   * Fetch and rebase on latest origin/<trunkBranch>
+   * Best-effort operation - logs warnings but doesn't fail workspace creation
+   */
+  private async pullLatestFromOrigin(
+    workspacePath: string,
+    trunkBranch: string,
+    initLogger: InitLogger
+  ): Promise<void> {
+    try {
+      initLogger.logStep("Fetching latest from origin...");
+
+      // Fetch the trunk branch from origin
+      using fetchProc = execAsync(`git -C "${workspacePath}" fetch origin "${trunkBranch}"`);
+      await fetchProc.result;
+
+      initLogger.logStep("Rebasing on latest...");
+
+      // Attempt rebase on origin/<trunkBranch>
+      using rebaseProc = execAsync(`git -C "${workspacePath}" rebase "origin/${trunkBranch}"`);
+      const rebaseResult = await rebaseProc.result;
+
+      if (rebaseResult.stderr?.includes("CONFLICT")) {
+        // Rebase has conflicts - abort and warn
+        using abortProc = execAsync(`git -C "${workspacePath}" rebase --abort`);
+        await abortProc.result;
+        initLogger.logStderr(
+          "Warning: Rebase failed due to conflicts, continuing with current state"
+        );
+      } else {
+        initLogger.logStep("Rebased on latest successfully");
+      }
+    } catch (error) {
+      // Non-fatal: log warning and continue
+      const errorMsg = getErrorMessage(error);
+      initLogger.logStderr(`Warning: Failed to pull latest (${errorMsg}), continuing anyway`);
+    }
+  }
+
   async initWorkspace(params: WorkspaceInitParams): Promise<WorkspaceInitResult> {
     const { projectPath, workspacePath, initLogger } = params;
 

src/node/runtime/Runtime.ts

@@ -123,6 +123,8 @@ export interface WorkspaceCreationParams {
   initLogger: InitLogger;
   /** Optional abort signal for cancellation */
   abortSignal?: AbortSignal;
+  /** Whether to fetch and rebase on origin/<trunkBranch> after creation */
+  pullLatest?: boolean;
 }
 
 /**
@@ -151,6 +153,8 @@ export interface WorkspaceInitParams {
   initLogger: InitLogger;
   /** Optional abort signal for cancellation */
   abortSignal?: AbortSignal;
+  /** Whether to fetch and rebase on origin/<trunkBranch> after init */
+  pullLatest?: boolean;
 }
 
 /**