🤖 fix: retry bundle creation on transient SSH failures (#1254)

## Problem

The "pack-objects died" error occurs intermittently during `git bundle
create` when SSH connections drop during transfer.

## Solution

Wrap the entire `syncProjectToRemote` call with retry logic at the
`initWorkspace` level rather than retrying just the bundle step.

**Benefits:**
- Single retry point (no extra helper method)
- Catches failures in any sync step, not just bundle creation  
- Cleans up partial remote state before retry
- Simpler and more maintainable

Retries up to 3 times for transient errors:
- `pack-objects died`
- `Connection reset`
- `Connection closed`
- `Broken pipe`

Uses linear backoff (1s, 2s) between attempts.

---
_Generated with `mux` • Model: `anthropic:claude-opus-4-5` • Thinking:
`high`_

Author: ammar-agent

src/node/runtime/SSHRuntime.ts

@@ -640,7 +640,6 @@ export class SSHRuntime implements Runtime {
       initLogger.logStep(`Creating git bundle...`);
 
       await new Promise<void>((resolve, reject) => {
-        // Check if aborted before spawning
         if (abortSignal?.aborted) {
           reject(new Error("Bundle creation aborted"));
           return;
@@ -933,18 +932,48 @@ export class SSHRuntime implements Runtime {
     const { projectPath, branchName, trunkBranch, workspacePath, initLogger, abortSignal } = params;
 
     try {
-      // 1. Sync project to remote (opportunistic rsync with scp fallback)
+      // 1. Sync project to remote with retry for transient SSH failures
+      // Errors like "pack-objects died" occur when SSH drops mid-transfer
       initLogger.logStep("Syncing project files to remote...");
-      try {
-        await this.syncProjectToRemote(projectPath, workspacePath, initLogger, abortSignal);
-      } catch (error) {
-        const errorMsg = getErrorMessage(error);
-        initLogger.logStderr(`Failed to sync project: ${errorMsg}`);
-        initLogger.logComplete(-1);
-        return {
-          success: false,
-          error: `Failed to sync project: ${errorMsg}`,
-        };
+      const maxSyncAttempts = 3;
+      for (let attempt = 1; attempt <= maxSyncAttempts; attempt++) {
+        try {
+          await this.syncProjectToRemote(projectPath, workspacePath, initLogger, abortSignal);
+          break;
+        } catch (error) {
+          const errorMsg = getErrorMessage(error);
+          const isRetryable =
+            errorMsg.includes("pack-objects died") ||
+            errorMsg.includes("Connection reset") ||
+            errorMsg.includes("Connection closed") ||
+            errorMsg.includes("Broken pipe");
+
+          if (!isRetryable || attempt === maxSyncAttempts) {
+            initLogger.logStderr(`Failed to sync project: ${errorMsg}`);
+            initLogger.logComplete(-1);
+            return {
+              success: false,
+              error: `Failed to sync project: ${errorMsg}`,
+            };
+          }
+
+          // Clean up partial remote state before retry
+          log.info(`Sync failed (attempt ${attempt}/${maxSyncAttempts}), will retry: ${errorMsg}`);
+          try {
+            const rmStream = await this.exec(`rm -rf ${shescape.quote(workspacePath)}`, {
+              cwd: "~",
+              timeout: 30,
+            });
+            await rmStream.exitCode;
+          } catch {
+            // Ignore cleanup errors
+          }
+
+          initLogger.logStep(
+            `Sync failed, retrying (attempt ${attempt + 1}/${maxSyncAttempts})...`
+          );
+          await new Promise((r) => setTimeout(r, attempt * 1000));
+        }
       }
       initLogger.logStep("Files synced successfully");