🤖 feat: always pull latest when creating workspaces

Automatically fetch and rebase on origin/<trunk> when creating new
workspaces. This ensures workspaces start with the latest changes.

Backend changes:
- LocalRuntime: fetch and rebase after worktree creation
- SSHRuntime: fetch and rebase after branch checkout

Error handling is best-effort - the init log informs users of status:
- Success: 'Rebased on latest origin successfully'
- Fetch fail: 'Note: Could not fetch from origin (...), using local branch state'
- Rebase fail: 'Note: Rebase skipped (...), using local branch state'

Failures never block workspace creation.

_Generated with `mux`_

Author: ibetitsmike

src/node/runtime/LocalRuntime.ts

@@ -365,6 +365,9 @@ export class LocalRuntime implements Runtime {
 
       initLogger.logStep("Worktree created successfully");
 
+      // Pull latest from origin (best-effort, non-blocking on failure)
+      await this.pullLatestFromOrigin(workspacePath, trunkBranch, initLogger);
+
       return { success: true, workspacePath };
     } catch (error) {
       return {
@@ -374,6 +377,49 @@ export class LocalRuntime implements Runtime {
     }
   }
 
+  /**
+   * Fetch and rebase on latest origin/<trunkBranch>
+   * Best-effort operation - logs status but doesn't fail workspace creation
+   */
+  private async pullLatestFromOrigin(
+    workspacePath: string,
+    trunkBranch: string,
+    initLogger: InitLogger
+  ): Promise<void> {
+    try {
+      initLogger.logStep(`Fetching latest from origin/${trunkBranch}...`);
+
+      // 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>
+      try {
+        using rebaseProc = execAsync(`git -C "${workspacePath}" rebase "origin/${trunkBranch}"`);
+        await rebaseProc.result;
+        initLogger.logStep("Rebased on latest origin 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(`Note: Rebase skipped (${errorMsg}), using local branch state`);
+      }
+    } catch (error) {
+      // Fetch failed - log and continue (common for repos without remote)
+      const errorMsg = getErrorMessage(error);
+      initLogger.logStderr(
+        `Note: Could not fetch from origin (${errorMsg}), using local branch state`
+      );
+    }
+  }
+
   async initWorkspace(params: WorkspaceInitParams): Promise<WorkspaceInitResult> {
     const { projectPath, workspacePath, initLogger } = params;
 

src/node/runtime/SSHRuntime.ts

@@ -906,7 +906,10 @@ export class SSHRuntime implements Runtime {
       }
       initLogger.logStep("Branch checked out successfully");
 
-      // 3. Run .mux/init hook if it exists
+      // 3. Pull latest from origin (best-effort, non-blocking on failure)
+      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 +931,75 @@ export class SSHRuntime implements Runtime {
     }
   }
 
+  /**
+   * Fetch and rebase on latest origin/<trunkBranch> on remote
+   * Best-effort operation - logs status 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/${trunkBranch}...`);
+
+      // 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(
+          `Note: Could not fetch from origin (${fetchStderr}), using local branch state`
+        );
+        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(
+          `Note: Rebase skipped (${rebaseStderr || "conflicts"}), using local branch state`
+        );
+      } else {
+        initLogger.logStep("Rebased on latest origin successfully");
+      }
+    } catch (error) {
+      // Non-fatal: log and continue
+      const errorMsg = getErrorMessage(error);
+      initLogger.logStderr(
+        `Note: Could not fetch from origin (${errorMsg}), using local branch state`
+      );
+    }
+  }
+
   async renameWorkspace(
     projectPath: string,
     oldName: string,