🤖 feat: add pull latest setting to workspace creation

Add a global setting in Settings > General to fetch and rebase on the
latest origin branch when creating new workspaces.

Backend:
- LocalRuntime: fetch origin/trunk and rebase after worktree creation
- SSHRuntime: fetch and rebase after branch checkout during init
- Properly abort failed rebases to avoid stuck state

Error handling is best-effort - network/rebase failures log warnings
but never fail workspace creation.

_Generated with `mux`_

Author: ibetitsmike

src/browser/components/ChatInput/useCreationWorkspace.ts

@@ -13,6 +13,7 @@ import {
   getPendingScopeId,
   getProjectScopeId,
   getThinkingLevelKey,
+  PULL_LATEST_ENABLED_KEY,
 } from "@/common/constants/storage";
 import type { Toast } from "@/browser/components/ChatInputToast";
 import { createErrorToast } from "@/browser/components/ChatInputToasts";
@@ -109,12 +110,16 @@ export function useCreationWorkspace({
           ? parseRuntimeString(runtimeString, "")
           : undefined;
 
+        // Read global pull latest setting (default true = enabled)
+        const pullLatest = readPersistedState<boolean>(PULL_LATEST_ENABLED_KEY, true);
+
         // Send message with runtime config and creation-specific params
         const result = await window.api.workspace.sendMessage(null, message, {
           ...sendMessageOptions,
           runtimeConfig,
           projectPath, // Pass projectPath when workspaceId is null
           trunkBranch: settings.trunkBranch, // Pass selected trunk branch from settings
+          pullLatest, // Pass global pull latest preference
           imageParts: imageParts && imageParts.length > 0 ? imageParts : undefined,
         });
 

src/browser/components/Settings/sections/GeneralSection.tsx

@@ -1,9 +1,15 @@
 import React from "react";
 import { MoonStar, SunMedium } from "lucide-react";
 import { useTheme } from "@/browser/contexts/ThemeContext";
+import { usePersistedState } from "@/browser/hooks/usePersistedState";
+import { PULL_LATEST_ENABLED_KEY } from "@/common/constants/storage";
 
 export function GeneralSection() {
   const { theme, toggleTheme } = useTheme();
+  const [pullLatestEnabled, setPullLatestEnabled] = usePersistedState<boolean>(
+    PULL_LATEST_ENABLED_KEY,
+    true
+  );
 
   return (
     <div className="space-y-6">
@@ -33,6 +39,24 @@ export function GeneralSection() {
           </button>
         </div>
       </div>
+
+      <div>
+        <h3 className="text-foreground mb-4 text-sm font-medium">Workspace Creation</h3>
+        <label className="flex cursor-pointer items-center justify-between">
+          <div>
+            <div className="text-foreground text-sm">Pull latest on creation</div>
+            <div className="text-muted text-xs">
+              Fetch and rebase on the latest origin branch when creating new workspaces
+            </div>
+          </div>
+          <input
+            type="checkbox"
+            checked={pullLatestEnabled}
+            onChange={(e) => setPullLatestEnabled(e.target.checked)}
+            className="h-4 w-4 cursor-pointer"
+          />
+        </label>
+      </div>
     </div>
   );
 }

src/common/constants/storage.ts

@@ -114,6 +114,13 @@ export function getTrunkBranchKey(projectPath: string): string {
   return `trunkBranch:${projectPath}`;
 }
 
+/**
+ * Get the localStorage key for pull latest preference (global)
+ * When enabled, new workspaces fetch and rebase on latest origin/<trunk>
+ * Format: "pullLatestEnabled"
+ */
+export const PULL_LATEST_ENABLED_KEY = "pullLatestEnabled";
+
 /**
  * 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,48 @@ 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>
+      // execAsync throws on non-zero exit, so we catch rebase failures separately
+      try {
+        using rebaseProc = execAsync(`git -C "${workspacePath}" rebase "origin/${trunkBranch}"`);
+        await rebaseProc.result;
+        initLogger.logStep("Rebased on latest successfully");
+      } catch (rebaseError) {
+        // Rebase failed (conflicts or other error) - abort and warn
+        try {
+          using abortProc = execAsync(`git -C "${workspacePath}" rebase --abort`);
+          await abortProc.result;
+        } catch {
+          // Abort may fail if rebase wasn't in progress; ignore
+        }
+        const errorMsg = getErrorMessage(rebaseError);
+        initLogger.logStderr(`Warning: Rebase failed (${errorMsg}), continuing with current state`);
+      }
+    } catch (error) {
+      // Non-fatal: log warning and continue (fetch failed)
+      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;
 }
 
 /**

src/node/runtime/SSHRuntime.ts

@@ -856,7 +856,15 @@ export class SSHRuntime implements Runtime {
   }
 
   async initWorkspace(params: WorkspaceInitParams): Promise<WorkspaceInitResult> {
-    const { projectPath, branchName, trunkBranch, workspacePath, initLogger, abortSignal } = params;
+    const {
+      projectPath,
+      branchName,
+      trunkBranch,
+      workspacePath,
+      initLogger,
+      abortSignal,
+      pullLatest,
+    } = params;
 
     try {
       // 1. Sync project to remote (opportunistic rsync with scp fallback)
@@ -906,7 +914,12 @@ export class SSHRuntime implements Runtime {
       }
       initLogger.logStep("Branch checked out successfully");
 
-      // 3. Run .mux/init hook if it exists
+      // 3. Pull latest from origin if requested (best-effort, non-blocking on failure)
+      if (pullLatest) {
+        await this.pullLatestFromOrigin(workspacePath, trunkBranch, initLogger, abortSignal);
+      }
+
+      // 4. Run .mux/init hook if it exists
       // Note: runInitHook calls logComplete() internally if hook exists
       const hookExists = await checkInitHookExists(projectPath);
       if (hookExists) {
@@ -928,6 +941,71 @@ export class SSHRuntime implements Runtime {
     }
   }
 
+  /**
+   * Fetch and rebase on latest origin/<trunkBranch> on remote
+   * Best-effort operation - logs warnings but doesn't fail workspace initialization
+   */
+  private async pullLatestFromOrigin(
+    workspacePath: string,
+    trunkBranch: string,
+    initLogger: InitLogger,
+    abortSignal?: AbortSignal
+  ): Promise<void> {
+    try {
+      initLogger.logStep("Fetching latest from origin...");
+
+      // Fetch the trunk branch from origin
+      const fetchCmd = `git fetch origin ${shescape.quote(trunkBranch)}`;
+      const fetchStream = await this.exec(fetchCmd, {
+        cwd: workspacePath,
+        timeout: 120, // 2 minutes for network operation
+        abortSignal,
+      });
+
+      const fetchExitCode = await fetchStream.exitCode;
+      if (fetchExitCode !== 0) {
+        const fetchStderr = await streamToString(fetchStream.stderr);
+        initLogger.logStderr(`Warning: Failed to fetch latest (${fetchStderr}), continuing anyway`);
+        return;
+      }
+
+      initLogger.logStep("Rebasing on latest...");
+
+      // Attempt rebase on origin/<trunkBranch>
+      const rebaseCmd = `git rebase origin/${shescape.quote(trunkBranch)}`;
+      const rebaseStream = await this.exec(rebaseCmd, {
+        cwd: workspacePath,
+        timeout: 300, // 5 minutes for rebase
+        abortSignal,
+      });
+
+      const [rebaseStderr, rebaseExitCode] = await Promise.all([
+        streamToString(rebaseStream.stderr),
+        rebaseStream.exitCode,
+      ]);
+
+      if (rebaseExitCode !== 0 || rebaseStderr.includes("CONFLICT")) {
+        // Rebase has conflicts or failed - abort and warn
+        const abortCmd = "git rebase --abort";
+        const abortStream = await this.exec(abortCmd, {
+          cwd: workspacePath,
+          timeout: 30,
+          abortSignal,
+        });
+        await abortStream.exitCode;
+        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 renameWorkspace(
     projectPath: string,
     oldName: string,

src/node/services/ipcMain.ts

@@ -299,6 +299,7 @@ export class IpcMain {
       imageParts?: Array<{ url: string; mediaType: string }>;
       runtimeConfig?: RuntimeConfig;
       trunkBranch?: string;
+      pullLatest?: boolean;
     }
   ): Promise<
     | { success: true; workspaceId: string; metadata: FrontendWorkspaceMetadata }
@@ -373,7 +374,13 @@ export class IpcMain {
       const { branchName: finalBranchName, result: createResult } =
         await createWorkspaceWithCollisionRetry(
           runtime,
-          { projectPath, branchName, trunkBranch: recommendedTrunk, initLogger },
+          {
+            projectPath,
+            branchName,
+            trunkBranch: recommendedTrunk,
+            initLogger,
+            pullLatest: options.pullLatest,
+          },
           branchName
         );
 
@@ -426,6 +433,7 @@ export class IpcMain {
           trunkBranch: recommendedTrunk,
           workspacePath: createResult.workspacePath,
           initLogger,
+          pullLatest: options.pullLatest,
         })
         .catch((error: unknown) => {
           const errorMsg = error instanceof Error ? error.message : String(error);