@snappedly-tools/shipyard 0.7.0 → 0.9.0

package/dist/{chunk-FDYOTN55.js → chunk-57EEKW3R.js}

@@ -1,15 +1,15 @@
-import { toSessionTransferHandle, shellQuote } from './chunk-KMGNFXKN.js';
-import { existsSync, constants, lstatSync, realpathSync, statSync } from 'fs';
-import { mkdtemp, writeFile, chmod, mkdir, stat, copyFile, rm, readdir, lstat, readFile, open } from 'fs/promises';
+import { existsSync, constants } from 'fs';
+import { writeFile, chmod, mkdir, stat, copyFile, rm, readdir, mkdtemp, lstat, readFile, open } from 'fs/promises';
 import * as clack from '@clack/prompts';
 import { FileSystem } from '@effect/platform';
-import { join, basename, posix, dirname, resolve, normalize, relative, sep, isAbsolute } from 'path';
+import { posix, join, basename, dirname, resolve, relative, sep, isAbsolute, normalize } from 'path';
 import { Context, Layer, Effect, Data, Exit, Duration, Option, Ref, Deferred, Schedule } from 'effect';
 import { styleText, promisify } from 'util';
-import { tmpdir, homedir } from 'os';
 import { randomBytes } from 'crypto';
 import { exec, execFile } from 'child_process';
+import { tmpdir } from 'os';
 
+// src/Display.ts
 var Display = class extends Context.Tag("Display")() {
 };
 var SilentDisplay = {
@@ -31,12 +31,21 @@ var SilentDisplay = {
     ),
     progress: (title, effect) => Effect.gen(function* () {
       const updates = [];
-      const result = yield* effect((update) => updates.push(update));
+      const report = Object.assign(
+        (update) => {
+          updates.push(update);
+        },
+        { pause: () => {
+        }, resume: () => {
+        } }
+      );
+      const exit = yield* Effect.exit(effect(report));
       yield* Ref.update(ref, (entries) => [
         ...entries,
         { _tag: "progress", title, updates: [...updates] }
       ]);
-      return result;
+      if (Exit.isFailure(exit)) return yield* Effect.failCause(exit.cause);
+      return exit.value;
     }),
     summary: (title, rows) => Ref.update(ref, (entries) => [
       ...entries,
@@ -140,7 +149,15 @@ var FileDisplay = {
           yield* appendToLog(`${title}...`);
           const start = Date.now();
           const updates = [];
-          const result = yield* effect((update) => updates.push(update));
+          const report = Object.assign(
+            (update) => {
+              updates.push(update);
+            },
+            { pause: () => {
+            }, resume: () => {
+            } }
+          );
+          const result = yield* effect(report);
           for (const update of updates) {
             yield* appendToLog(
               `  ${update.message} (${update.current}/${update.total})`
@@ -211,25 +228,39 @@ var ClackDisplay = {
     ),
     progress: (title, effect) => Effect.acquireUseRelease(
       Effect.sync(() => {
-        const progress2 = clack.progress({ max: 100 });
+        const progress2 = clack.progress({ max: 100, withGuide: false });
         let percent = 0;
+        let currentMessage = title;
+        let paused = false;
         progress2.start(title);
-        const report = (update) => {
+        const report = ((update) => {
           const total = Math.max(1, update.total);
           const current = Math.min(total, Math.max(0, update.current));
           const nextPercent = Math.round(current / total * 100);
           const message = `${update.message} (${current}/${total})`;
+          currentMessage = message;
           if (nextPercent > percent) {
             progress2.advance(nextPercent - percent, message);
           } else {
             progress2.message(message);
           }
           percent = nextPercent;
+        });
+        report.pause = () => {
+          if (paused) return;
+          progress2.clear();
+          paused = true;
+        };
+        report.resume = () => {
+          if (!paused) return;
+          progress2.start(currentMessage);
+          paused = false;
         };
         return { progress: progress2, report };
       }),
       ({ report }) => effect(report),
-      ({ progress: progress2 }, exit) => Effect.sync(() => {
+      ({ progress: progress2, report }, exit) => Effect.sync(() => {
+        report.resume();
         if (exit._tag === "Success") {
           progress2.stop(`${title} complete`);
         } else {
@@ -259,6 +290,67 @@ var ClackDisplay = {
     )
   })
 };
+
+// src/SandboxProvider.ts
+var createIsolatedSandboxProvider = (config) => ({
+  tag: "isolated",
+  name: config.name,
+  env: config.env ?? {},
+  create: config.create
+});
+var toSessionTransferHandle = (handle) => handle === void 0 ? void 0 : "copyFileIn" in handle ? handle : {
+  worktreePath: handle.worktreePath,
+  exec: (command, options) => handle.exec(command, options),
+  interactiveExec: handle.interactiveExec?.bind(handle),
+  copyFileIn: (source, destination) => handle.copyIn(source, destination),
+  copyFileOut: (source, destination) => handle.copyFileOut(source, destination),
+  close: () => handle.close()
+};
+
+// src/shutdownRegistry.ts
+var teardownCallbacks = /* @__PURE__ */ new Set();
+var listenersInstalled = false;
+var runTeardowns = () => {
+  for (const teardown of teardownCallbacks) {
+    try {
+      teardown();
+    } catch {
+    }
+  }
+};
+var handleExit = () => {
+  runTeardowns();
+};
+var handleSignal = () => {
+  detachListeners();
+  runTeardowns();
+  process.exit(1);
+};
+var attachListeners = () => {
+  if (listenersInstalled) return;
+  listenersInstalled = true;
+  process.on("exit", handleExit);
+  process.on("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+};
+var detachListeners = () => {
+  if (!listenersInstalled) return;
+  listenersInstalled = false;
+  process.removeListener("exit", handleExit);
+  process.removeListener("SIGINT", handleSignal);
+  process.removeListener("SIGTERM", handleSignal);
+};
+var registerShutdown = (teardown) => {
+  teardownCallbacks.add(teardown);
+  attachListeners();
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    teardownCallbacks.delete(teardown);
+    if (teardownCallbacks.size === 0) detachListeners();
+  };
+};
 var CwdError = class extends Data.TaggedError("CwdError") {
 };
 var resolveCwd = (cwd) => Effect.gen(function* () {
@@ -280,8 +372,6 @@ var resolveCwd = (cwd) => Effect.gen(function* () {
   }
   return resolved;
 });
-
-// src/errors.ts
 var ExecError = class extends Data.TaggedError("ExecError") {
 };
 var ExecHostError = class extends Data.TaggedError("ExecHostError") {
@@ -364,10 +454,7 @@ var WORKTREES_DIR = "worktrees";
 var PATCHES_DIR = "patches";
 var LOCKS_DIR = "locks";
 var RUNNER_DIR = "runner";
-var RUNNER_SANDBOX_MASK_DIR = "runner-sandbox-mask";
-var PARENT_GIT_SANDBOX_DIR = "/.shipyard-parent-git";
 var SYNC_BASE_REF = "refs/shipyard/sync-base";
-var CONTAINER_NAME_PREFIX = "shipyard-";
 var WINDOWS_DRIVE_PATH = /^[A-Za-z]:/;
 var assertSafeRelativePath = (relativePath, label = "relative path") => {
   if (relativePath.length === 0 || relativePath.includes("\0") || isAbsolute(relativePath) || WINDOWS_DRIVE_PATH.test(relativePath) || relativePath.startsWith("\\\\") || relativePath.split(/[\\/]/).some((part) => part === "..")) {
@@ -440,7 +527,7 @@ var SAFE_CONFIG = [
   ["checkout.recurseSubmodules", "false"]
 ];
 var COMMAND_CONFIG_PATTERN = "^(filter\\..*\\.(clean|smudge|process|required)|merge\\..*\\.driver|diff\\..*\\.(command|textconv)|difftool\\..*\\.cmd|mergetool\\..*\\.cmd)$";
-var runGit = (args, cwd, options = {}) => new Promise((resolve6, reject) => {
+var runGit = (args, cwd, options = {}) => new Promise((resolve4, reject) => {
   execFile(
     "git",
     [...args],
@@ -458,11 +545,11 @@ var runGit = (args, cwd, options = {}) => new Promise((resolve6, reject) => {
     },
     (error, stdout, stderr) => {
       if (!error) {
-        resolve6({ stdout, stderr, exitCode: 0 });
+        resolve4({ stdout, stderr, exitCode: 0 });
         return;
       }
       if (typeof error.code === "number") {
-        resolve6({ stdout, stderr, exitCode: error.code });
+        resolve4({ stdout, stderr, exitCode: error.code });
         return;
       }
       reject(error);
@@ -869,6 +956,14 @@ var pruneStale = (repoDir) => Effect.gen(function* () {
     })
   )
 );
+
+// src/shellQuote.ts
+var shellQuote = (value) => {
+  if (value.includes("\0")) {
+    throw new Error("Cannot quote a string containing a NUL byte");
+  }
+  return `'${value.replaceAll("'", "'\\''")}'`;
+};
 var PROTECTED_RUNNER_PATH = `${CONFIG_DIR}/${RUNNER_DIR}`;
 var pathKey = (value) => value.normalize("NFC").toLocaleLowerCase("en-US");
 var SAFE_RUNNER_ENV_KEYS = /* @__PURE__ */ new Set([
@@ -900,121 +995,14 @@ var assertExcludesRepositoryRunner = (relativePath) => {
     );
   }
 };
-var assertSafeRepositoryRunnerDirectories = (repoDir) => {
-  const runnerDir = join(repoDir, CONFIG_DIR, RUNNER_DIR);
-  const maskDir = join(repoDir, CONFIG_DIR, RUNNER_SANDBOX_MASK_DIR);
-  for (const [name, path] of [
-    ["repository runner", runnerDir],
-    ["repository runner sandbox mask", maskDir]
-  ]) {
-    const stat2 = lstatSync(path);
-    if (stat2.isSymbolicLink() || !stat2.isDirectory()) {
-      throw new Error(
-        `The protected ${name} path must be a real directory: ${path}`
-      );
-    }
-  }
-  if (pathKey(realpathSync(runnerDir)) === pathKey(realpathSync(maskDir))) {
-    throw new Error(
-      "The protected repository runner and sandbox mask paths must be distinct directories."
-    );
-  }
-};
-var assertProtectedDirectoryIdentities = async (runnerDir, maskDir, inspect) => {
+var assertProtectedDirectoryIdentities = async (runnerDir, inspect) => {
   if (!inspect) return;
   const runner = await inspect(runnerDir);
-  const mask = await inspect(maskDir);
   if (!runner.directory || runner.symbolicLink) {
     throw new Error(
       `The protected repository runner path must be a real directory: ${runnerDir}`
     );
   }
-  if (!mask.directory || mask.symbolicLink) {
-    throw new Error(
-      `The protected repository runner sandbox mask path must be a real directory: ${maskDir}`
-    );
-  }
-  if (pathKey(runner.realPath) === pathKey(mask.realPath)) {
-    throw new Error(
-      "The protected repository runner and sandbox mask paths must be distinct directories."
-    );
-  }
-};
-
-// src/CopyToWorktree.ts
-var COPY_TO_WORKTREE_TIMEOUT_MS = 6e4;
-var getCopyOnWriteFlags = (platform) => platform === "darwin" ? ["-cR"] : ["-R", "--reflink=auto"];
-var copyToWorktree = (paths, hostRepoDir, worktreePath, timeoutMs) => {
-  const effectiveTimeout = timeoutMs ?? COPY_TO_WORKTREE_TIMEOUT_MS;
-  return Effect.gen(function* () {
-    const cowFlags = getCopyOnWriteFlags(process.platform);
-    for (const relativePath of paths) {
-      let src;
-      let dest;
-      try {
-        assertExcludesRepositoryRunner(relativePath);
-        src = resolveSafeRelativePath(hostRepoDir, relativePath, "copy path");
-        dest = resolveSafeRelativePath(worktreePath, relativePath, "copy path");
-      } catch (error) {
-        return yield* Effect.fail(
-          new CopyToWorktreeError({
-            message: `Refusing unsafe copy path ${relativePath}: ${error instanceof Error ? error.message : String(error)}`,
-            path: relativePath,
-            stderr: error instanceof Error ? error.message : String(error),
-            exitCode: null
-          })
-        );
-      }
-      if (!existsSync(src)) {
-        continue;
-      }
-      yield* Effect.tryPromise({
-        try: async () => {
-          await assertNoSymlinkComponents(hostRepoDir, src, "copy source");
-          await assertNoSymlinkComponents(worktreePath, dest, "copy target");
-        },
-        catch: (error) => new CopyToWorktreeError({
-          message: `Refusing symlinked copy path ${relativePath}: ${error instanceof Error ? error.message : String(error)}`,
-          path: relativePath,
-          stderr: error instanceof Error ? error.message : String(error),
-          exitCode: null
-        })
-      });
-      yield* Effect.async((resume) => {
-        execFile("cp", [...cowFlags, src, dest], (error) => {
-          if (error) {
-            execFile("cp", ["-R", src, dest], (fallbackError, _, stderr) => {
-              if (fallbackError) {
-                resume(
-                  Effect.fail(
-                    new CopyToWorktreeError({
-                      message: `Failed to copy ${relativePath} to worktree: ${stderr || fallbackError.message}`,
-                      path: relativePath,
-                      stderr: stderr || fallbackError.message,
-                      exitCode: typeof fallbackError.code === "number" ? fallbackError.code : null
-                    })
-                  )
-                );
-              } else {
-                resume(Effect.succeed(void 0));
-              }
-            });
-          } else {
-            resume(Effect.succeed(void 0));
-          }
-        });
-      });
-    }
-  }).pipe(
-    withTimeout(
-      effectiveTimeout,
-      () => new CopyToWorktreeTimeoutError({
-        message: `Copying files to worktree timed out after ${effectiveTimeout}ms`,
-        timeoutMs: effectiveTimeout,
-        paths
-      })
-    )
-  );
 };
 
 // src/RecoveryMessage.ts
@@ -1096,22 +1084,21 @@ var formatCommandBlock = (commands) => {
   }
   return commands.map((cmd, i) => i < commands.length - 1 ? `  ${cmd} && \\` : `  ${cmd}`).join("\n");
 };
-
-// src/syncOut.ts
 var execHostGit2 = (args, cwd) => Effect.tryPromise({
   try: () => execHostGit(args, cwd),
-  catch: (e) => new SyncError({
+  catch: (error) => new SyncError({
     message: `Host command failed: git ${args.join(" ")}
-${e instanceof Error ? e.message : String(e)}`
+${error instanceof Error ? error.message : String(error)}`
   })
 });
-var execOk = (handle, command, options) => Effect.tryPromise({
+var execSandbox = (handle, command, options) => Effect.tryPromise({
   try: () => handle.exec(command, options),
-  catch: (e) => new SyncError({
+  catch: (error) => new SyncError({
     message: `Sandbox exec failed: ${command}
-${e instanceof Error ? e.message : String(e)}`
+${error instanceof Error ? error.message : String(error)}`
   })
-}).pipe(
+});
+var execOk = (handle, command, options) => execSandbox(handle, command, options).pipe(
   Effect.flatMap(
     (result) => result.exitCode !== 0 ? Effect.fail(
       new SyncError({
@@ -1121,13 +1108,8 @@ ${result.stderr}`
     ) : Effect.succeed(result)
   )
 );
-var execSandbox = (handle, command, options) => Effect.tryPromise({
-  try: () => handle.exec(command, options),
-  catch: (e) => new SyncError({
-    message: `Sandbox exec failed: ${command}
-${e instanceof Error ? e.message : String(e)}`
-  })
-});
+
+// src/syncOut.ts
 var isEmptyPatch = (patchPath) => Effect.tryPromise({
   try: async () => {
     const info = await stat(patchPath);
@@ -1524,8 +1506,6 @@ ${msg}`);
     });
   }
 });
-
-// src/SandboxLifecycle.ts
 var GIT_SETUP_TIMEOUT_MS = 1e4;
 var HOOK_TIMEOUT_MS = 6e4;
 var COMMIT_COLLECTION_TIMEOUT_MS = 3e4;
@@ -1859,401 +1839,75 @@ ${err instanceof Error ? err.message : String(err)}`
   }
   return { result, branch: finalBranch, commits };
 });
-var execHostGit3 = (args, cwd) => Effect.tryPromise({
-  try: () => execHostGit(args, cwd),
-  catch: (e) => new SyncError({
-    message: `Host command failed: git ${args.join(" ")}
-${e instanceof Error ? e.message : String(e)}`
+var makeSandboxFromHandle = (handle) => ({
+  exec: (command, options) => Effect.tryPromise({
+    try: () => handle.exec(command, options),
+    catch: (e) => new ExecError({
+      command,
+      message: `exec failed: ${e instanceof Error ? e.message : String(e)}`
+    })
+  }),
+  copyIn: (hostPath, sandboxPath) => Effect.tryPromise({
+    try: () => handle.copyIn(hostPath, sandboxPath),
+    catch: (e) => new CopyError({
+      message: `copyIn failed: ${e instanceof Error ? e.message : String(e)}`
+    })
+  }),
+  copyFileOut: (sandboxPath, hostPath) => Effect.tryPromise({
+    try: () => handle.copyFileOut(sandboxPath, hostPath),
+    catch: (e) => new CopyError({
+      message: `copyFileOut failed: ${e instanceof Error ? e.message : String(e)}`
+    })
   })
 });
-var execOk3 = (handle, command, options) => Effect.tryPromise({
-  try: () => handle.exec(command, options),
-  catch: (e) => new SyncError({
-    message: `Sandbox exec failed: ${command}
-${e instanceof Error ? e.message : String(e)}`
+var SANDBOX_REPO_DIR = "/home/agent/workspace";
+var SandboxFactory = class extends Context.Tag("SandboxFactory")() {
+};
+var SandboxConfig = class extends Context.Tag("SandboxConfig")() {
+};
+var printWorktreePreservedMessage = (worktreePath, reason) => {
+  console.error(`
+${reason}`);
+  console.error(`  To review: cd ${worktreePath}`);
+  console.error(`  To clean up: git worktree remove --force ${worktreePath}`);
+};
+var cleanupWorktree = (worktreePath, exit) => hasUncommittedChanges(worktreePath).pipe(
+  Effect.catchAll(() => Effect.succeed(false)),
+  Effect.flatMap((isDirty) => {
+    if (isDirty) {
+      printWorktreePreservedMessage(
+        worktreePath,
+        Exit.isSuccess(exit) ? `Run succeeded but worktree has uncommitted changes at ${worktreePath}` : `Worktree preserved at ${worktreePath}`
+      );
+      return Effect.succeed(worktreePath);
+    }
+    if (!Exit.isSuccess(exit)) {
+      console.error(`
+Worktree removed (no uncommitted changes)`);
+    }
+    return remove(worktreePath).pipe(
+      Effect.map(() => void 0)
+    );
   })
-}).pipe(
-  Effect.flatMap(
-    (result) => result.exitCode !== 0 ? Effect.fail(
-      new SyncError({
-        message: `Sandbox command failed (exit ${result.exitCode}): ${command}
-${result.stderr}`
-      })
-    ) : Effect.succeed(result)
-  )
 );
-var syncIn = (hostRepoDir, handle) => Effect.gen(function* () {
-  const protectedRunnerPath = `${CONFIG_DIR}/${RUNNER_DIR}`;
-  const runnerObjects = yield* execHostGit3(
-    ["rev-list", "--objects", "--all", "--", protectedRunnerPath],
-    hostRepoDir
-  );
-  if (runnerObjects.trim().length > 0) {
-    return yield* Effect.fail(
-      new SyncError({
-        message: `Refusing to copy repository history into the sandbox because it contains protected repository runner files under ${protectedRunnerPath}. Remove those files from all refs before retrying.`
-      })
-    );
-  }
-  const branch = (yield* execHostGit3(
-    ["rev-parse", "--abbrev-ref", "HEAD"],
-    hostRepoDir
-  )).trim();
-  const bundleDir = yield* Effect.tryPromise({
-    try: () => mkdtemp(join(tmpdir(), `${RUNTIME_NAMESPACE}-bundle-`)),
-    catch: (e) => new SyncError({
-      message: `Failed to create temp dir: ${e instanceof Error ? e.message : String(e)}`
-    })
-  });
-  const bundleHostPath = join(bundleDir, "repo.bundle");
-  yield* Effect.ensuring(
-    Effect.gen(function* () {
-      yield* execHostGit3(
-        ["bundle", "create", bundleHostPath, "--all"],
-        hostRepoDir
-      );
-      const mkTempResult = yield* execOk3(
-        handle,
-        `mktemp -d -t ${RUNTIME_NAMESPACE}-XXXXXX`
-      );
-      const sandboxTmpDir = mkTempResult.stdout.trim();
-      const bundleSandboxPath = `${sandboxTmpDir}/repo.bundle`;
-      yield* Effect.tryPromise({
-        try: () => handle.copyIn(bundleHostPath, bundleSandboxPath),
-        catch: (e) => new SyncError({
-          message: `Failed to copy bundle into sandbox: ${e instanceof Error ? e.message : String(e)}`
-        })
-      });
-      const worktreePath = handle.worktreePath;
-      yield* execOk3(
-        handle,
-        `git clone ${shellQuote(bundleSandboxPath)} ${shellQuote(`${worktreePath}_clone`)}`
-      );
-      yield* execOk3(
-        handle,
-        `rm -rf ${shellQuote(worktreePath)} && mv ${shellQuote(`${worktreePath}_clone`)} ${shellQuote(worktreePath)}`
-      );
-      yield* execOk3(handle, `git checkout ${shellQuote(branch)}`, {
-        cwd: worktreePath
+var attachPreservedPath = (path, e) => {
+  if (path !== void 0) {
+    if (e instanceof AgentIdleTimeoutError) {
+      return new AgentIdleTimeoutError({
+        message: e.message,
+        timeoutMs: e.timeoutMs,
+        preservedWorktreePath: path
       });
-      yield* Effect.tryPromise({
-        try: () => handle.exec(`rm -rf ${shellQuote(sandboxTmpDir)}`),
-        catch: () => new SyncError({ message: "Failed to clean up sandbox temp dir" })
+    }
+    if (e instanceof AgentError) {
+      return new AgentError({
+        message: e.message,
+        preservedWorktreePath: path
       });
-      const hostHead = (yield* execHostGit3(
-        ["rev-parse", "HEAD"],
-        hostRepoDir
-      )).trim();
-      const sandboxHead = (yield* execOk3(handle, "git rev-parse HEAD", {
-        cwd: worktreePath
-      })).stdout.trim();
-      if (hostHead !== sandboxHead) {
-        yield* Effect.fail(
-          new SyncError({
-            message: `HEAD mismatch after sync-in: host=${hostHead} sandbox=${sandboxHead}`
-          })
-        );
-      }
-    }),
-    // Clean up host-side bundle temp dir (runs regardless of success/failure)
-    Effect.promise(() => rm(bundleDir, { recursive: true, force: true }))
-  );
-  return { branch };
-});
-
-// src/startSandbox.ts
-var CONTAINER_START_TIMEOUT_MS = 12e4;
-var SYNC_IN_TIMEOUT_MS = 12e4;
-var COPY_PATHS_TIMEOUT_MS = 12e4;
-var startSandbox = (options) => {
-  if (options.provider.tag === "bind-mount") {
-    return startBindMountSandbox(options);
-  }
-  if (options.provider.tag === "none") {
-    return startNoSandbox(options);
-  }
-  return startIsolatedSandbox(options);
-};
-var startNoSandbox = (options) => Effect.tryPromise({
-  try: () => options.provider.create({
-    worktreePath: options.worktreeOrRepoPath,
-    env: options.env
-  }),
-  catch: (e) => new WorktreeError({
-    message: `Provider '${options.provider.name}' create failed: ${e instanceof Error ? e.message : String(e)}`
-  })
-}).pipe(
-  Effect.map((handle) => ({
-    handle,
-    sandbox: makeSandboxFromHandle(handle),
-    worktreePath: handle.worktreePath
-  }))
-);
-var startBindMountSandbox = (options) => Effect.tryPromise({
-  try: () => {
-    const usesRunnerMask = options.worktreeOrRepoPath === options.hostRepoDir && existsSync(join(options.hostRepoDir, CONFIG_DIR, RUNNER_DIR)) && existsSync(
-      join(options.hostRepoDir, CONFIG_DIR, RUNNER_SANDBOX_MASK_DIR)
-    );
-    if (usesRunnerMask) {
-      assertSafeRepositoryRunnerDirectories(options.hostRepoDir);
-    }
-    const rawMounts = [
-      {
-        hostPath: options.worktreeOrRepoPath,
-        sandboxPath: options.repoDir
-      },
-      ...options.gitMounts,
-      ...usesRunnerMask ? [
-        {
-          hostPath: join(
-            options.hostRepoDir,
-            CONFIG_DIR,
-            RUNNER_SANDBOX_MASK_DIR
-          ),
-          sandboxPath: posix.join(
-            options.repoDir,
-            CONFIG_DIR,
-            RUNNER_DIR
-          ),
-          readonly: true
-        }
-      ] : []
-    ];
-    const mounts = normalizeMounts(
-      rawMounts,
-      options.worktreeOrRepoPath,
-      SANDBOX_REPO_DIR
-    );
-    const worktreePath = process.platform === "win32" ? options.worktreeOrRepoPath.replace(/\\/g, "/") : options.worktreeOrRepoPath;
-    return options.provider.create({
-      worktreePath,
-      hostRepoPath: options.hostRepoDir,
-      mounts,
-      env: options.env
-    });
-  },
-  catch: (e) => new WorktreeError({
-    message: `Provider '${options.provider.name}' create failed: ${e instanceof Error ? e.message : String(e)}`
-  })
-}).pipe(
-  Effect.map((handle) => ({
-    handle,
-    sandbox: makeSandboxFromHandle(handle),
-    worktreePath: handle.worktreePath
-  })),
-  withTimeout(
-    CONTAINER_START_TIMEOUT_MS,
-    () => new ContainerStartTimeoutError({
-      message: `Sandbox container start timed out after ${CONTAINER_START_TIMEOUT_MS}ms`,
-      timeoutMs: CONTAINER_START_TIMEOUT_MS
-    })
-  )
-);
-var startIsolatedSandbox = (options) => Effect.gen(function* () {
-  const handle = yield* Effect.tryPromise({
-    try: () => options.provider.create({
-      env: options.env,
-      hostRepoPath: options.sourceRepoDir ?? options.hostRepoDir
-    }),
-    catch: (e) => new WorktreeError({
-      message: `Isolated provider '${options.provider.name}' setup failed: ${e instanceof Error ? e.message : String(e)}`
-    })
-  }).pipe(
-    withTimeout(
-      CONTAINER_START_TIMEOUT_MS,
-      () => new ContainerStartTimeoutError({
-        message: `Isolated sandbox container start timed out after ${CONTAINER_START_TIMEOUT_MS}ms`,
-        timeoutMs: CONTAINER_START_TIMEOUT_MS
-      })
-    )
-  );
-  return yield* Effect.gen(function* () {
-    yield* syncIn(options.hostRepoDir, handle).pipe(
-      withTimeout(
-        SYNC_IN_TIMEOUT_MS,
-        () => new SyncInTimeoutError({
-          message: `Sync-in timed out after ${SYNC_IN_TIMEOUT_MS}ms`,
-          timeoutMs: SYNC_IN_TIMEOUT_MS
-        })
-      )
-    );
-    if (options.copyPaths && options.copyPaths.length > 0) {
-      const pathsToCopy = options.copyPaths;
-      yield* Effect.gen(function* () {
-        for (const relativePath of pathsToCopy) {
-          let hostPath;
-          let sandboxPath;
-          try {
-            assertExcludesRepositoryRunner(relativePath);
-            hostPath = resolveSafeRelativePath(
-              options.sourceRepoDir ?? options.hostRepoDir,
-              relativePath,
-              "copy path"
-            );
-            resolveSafeRelativePath(
-              handle.worktreePath,
-              relativePath,
-              "copy path"
-            );
-            sandboxPath = posix.join(handle.worktreePath, relativePath);
-          } catch (error) {
-            return yield* Effect.fail(
-              new WorktreeError({
-                message: `Refusing unsafe copy path ${relativePath}: ${error instanceof Error ? error.message : String(error)}`
-              })
-            );
-          }
-          if (!existsSync(hostPath)) {
-            continue;
-          }
-          yield* Effect.tryPromise({
-            try: async () => {
-              await assertNoSymlinkComponents(
-                options.sourceRepoDir ?? options.hostRepoDir,
-                hostPath,
-                "copy source"
-              );
-            },
-            catch: (error) => new WorktreeError({
-              message: `Refusing symlinked copy path ${relativePath}: ${error instanceof Error ? error.message : String(error)}`
-            })
-          });
-          yield* Effect.tryPromise({
-            try: () => handle.copyIn(hostPath, sandboxPath),
-            catch: (e) => new WorktreeError({
-              message: `Failed to copy ${relativePath} into sandbox: ${e instanceof Error ? e.message : String(e)}`
-            })
-          });
-        }
-      }).pipe(
-        withTimeout(
-          COPY_PATHS_TIMEOUT_MS,
-          () => new CopyToWorktreeTimeoutError({
-            message: `Copying paths to worktree timed out after ${COPY_PATHS_TIMEOUT_MS}ms`,
-            timeoutMs: COPY_PATHS_TIMEOUT_MS,
-            paths: pathsToCopy
-          })
-        )
-      );
-    }
-    return {
-      handle,
-      sandbox: makeSandboxFromHandle(handle),
-      worktreePath: handle.worktreePath
-    };
-  }).pipe(Effect.onError(() => Effect.promise(() => handle.close())));
-});
-
-// src/SandboxFactory.ts
-var getCopyIn = (handle) => {
-  if ("copyIn" in handle) {
-    return (hostPath, sandboxPath) => Effect.tryPromise({
-      try: () => handle.copyIn(hostPath, sandboxPath),
-      catch: (e) => new CopyError({
-        message: `copyIn failed: ${e instanceof Error ? e.message : String(e)}`
-      })
-    });
-  }
-  if ("copyFileIn" in handle) {
-    return (hostPath, sandboxPath) => Effect.tryPromise({
-      try: () => handle.copyFileIn(hostPath, sandboxPath),
-      catch: (e) => new CopyError({
-        message: `copyFileIn failed: ${e instanceof Error ? e.message : String(e)}`
-      })
-    });
-  }
-  return () => Effect.fail(
-    new CopyError({
-      message: "copyIn is not supported for this sandbox provider"
-    })
-  );
-};
-var makeSandboxFromHandle = (handle) => ({
-  exec: (command, options) => Effect.tryPromise({
-    try: () => handle.exec(command, options),
-    catch: (e) => new ExecError({
-      command,
-      message: `exec failed: ${e instanceof Error ? e.message : String(e)}`
-    })
-  }),
-  copyIn: getCopyIn(handle),
-  copyFileOut: "copyFileOut" in handle ? (sandboxPath, hostPath) => Effect.tryPromise({
-    try: () => handle.copyFileOut(sandboxPath, hostPath),
-    catch: (e) => new CopyError({
-      message: `copyFileOut failed: ${e instanceof Error ? e.message : String(e)}`
-    })
-  }) : () => Effect.fail(
-    new CopyError({
-      message: "copyFileOut is not supported for this sandbox provider"
-    })
-  )
-});
-var SANDBOX_REPO_DIR = "/home/agent/workspace";
-var SandboxFactory = class extends Context.Tag("SandboxFactory")() {
-};
-var SandboxConfig = class extends Context.Tag("SandboxConfig")() {
-};
-var printWorktreePreservedMessage = (worktreePath, reason) => {
-  console.error(`
-${reason}`);
-  console.error(`  To review: cd ${worktreePath}`);
-  console.error(`  To clean up: git worktree remove --force ${worktreePath}`);
-};
-var cleanupWorktree = (worktreePath, exit) => hasUncommittedChanges(worktreePath).pipe(
-  Effect.catchAll(() => Effect.succeed(false)),
-  Effect.flatMap((isDirty) => {
-    if (isDirty) {
-      printWorktreePreservedMessage(
-        worktreePath,
-        Exit.isSuccess(exit) ? `Run succeeded but worktree has uncommitted changes at ${worktreePath}` : `Worktree preserved at ${worktreePath}`
-      );
-      return Effect.succeed(worktreePath);
-    }
-    if (!Exit.isSuccess(exit)) {
-      console.error(`
-Worktree removed (no uncommitted changes)`);
-    }
-    return remove(worktreePath).pipe(
-      Effect.map(() => void 0)
-    );
-  })
-);
-var attachPreservedPath = (path, e) => {
-  if (path !== void 0) {
-    if (e instanceof AgentIdleTimeoutError) {
-      return new AgentIdleTimeoutError({
-        message: e.message,
-        timeoutMs: e.timeoutMs,
-        preservedWorktreePath: path
-      });
-    }
-    if (e instanceof AgentError) {
-      return new AgentError({
-        message: e.message,
-        preservedWorktreePath: path
-      });
-    }
+    }
   }
   return e;
 };
-var resolveGitMounts = (gitPath) => Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const stat2 = yield* fs.stat(gitPath);
-  if (stat2.type === "Directory") {
-    return [{ hostPath: gitPath, sandboxPath: gitPath }];
-  }
-  const content = (yield* fs.readFileString(gitPath)).trim();
-  const match = content.match(/^gitdir:\s*(.+)$/);
-  if (!match) {
-    return [{ hostPath: gitPath, sandboxPath: gitPath }];
-  }
-  const gitdirPath = match[1];
-  const parentGitDir = resolve(gitdirPath, "..", "..");
-  return [
-    { hostPath: gitPath, sandboxPath: gitPath },
-    { hostPath: parentGitDir, sandboxPath: parentGitDir }
-  ];
-});
 var WorktreeDockerSandboxFactory = {
   layer: Layer.effect(
     SandboxFactory,
@@ -2269,11 +1923,9 @@ var WorktreeDockerSandboxFactory = {
         signal,
         timeouts
       } = yield* SandboxConfig;
-      const isHeadMode = branchStrategy.type === "head";
       const branch = branchStrategy.type === "branch" ? branchStrategy.branch : void 0;
       const baseBranch = branchStrategy.type === "branch" ? branchStrategy.baseBranch : void 0;
       const fileSystem = yield* FileSystem.FileSystem;
-      const display = yield* Display;
       const pruneAndCreate = () => pruneStale(hostRepoDir).pipe(
         Effect.catchAll(
           (e) => Effect.sync(() => {
@@ -2290,100 +1942,7 @@ var WorktreeDockerSandboxFactory = {
       );
       return {
         withSandbox: (makeEffect) => {
-          if (sandboxProvider.tag === "none") {
-            let preservedPath;
-            if (isHeadMode) {
-              return (hooks?.host?.onWorktreeReady?.length ? runHostHooks(
-                hooks.host.onWorktreeReady,
-                hostRepoDir,
-                signal
-              ) : Effect.void).pipe(
-                Effect.andThen(
-                  Effect.acquireUseRelease(
-                    startSandbox({
-                      provider: sandboxProvider,
-                      hostRepoDir,
-                      env,
-                      worktreeOrRepoPath: hostRepoDir
-                    }),
-                    ({ sandbox, worktreePath }) => makeEffect(
-                      {
-                        hostWorktreePath: hostRepoDir,
-                        sandboxRepoPath: worktreePath
-                      },
-                      sandbox
-                    ),
-                    ({ handle }) => Effect.tryPromise({
-                      try: () => handle.close(),
-                      catch: () => void 0
-                    }).pipe(Effect.orDie)
-                  ).pipe(
-                    Effect.map((value) => ({
-                      value,
-                      preservedWorktreePath: void 0
-                    }))
-                  )
-                )
-              );
-            }
-            return Effect.acquireUseRelease(
-              pruneAndCreate(),
-              (worktreeInfo) => (copyPaths && copyPaths.length > 0 ? display.spinner(
-                "Copying to worktree",
-                copyToWorktree(
-                  copyPaths,
-                  hostRepoDir,
-                  worktreeInfo.path,
-                  timeouts?.copyToWorktreeMs
-                )
-              ) : Effect.succeed(void 0)).pipe(
-                Effect.andThen(
-                  hooks?.host?.onWorktreeReady?.length ? runHostHooks(
-                    hooks.host.onWorktreeReady,
-                    worktreeInfo.path,
-                    signal
-                  ) : Effect.void
-                ),
-                Effect.andThen(
-                  Effect.acquireUseRelease(
-                    startSandbox({
-                      provider: sandboxProvider,
-                      hostRepoDir,
-                      env,
-                      worktreeOrRepoPath: worktreeInfo.path
-                    }),
-                    ({ sandbox, worktreePath }) => makeEffect(
-                      {
-                        hostWorktreePath: worktreeInfo.path,
-                        sandboxRepoPath: worktreePath
-                      },
-                      sandbox
-                    ),
-                    ({ handle }) => Effect.tryPromise({
-                      try: () => handle.close(),
-                      catch: () => void 0
-                    }).pipe(Effect.orDie)
-                  )
-                )
-              ),
-              (worktreeInfo, exit) => cleanupWorktree(worktreeInfo.path, exit).pipe(
-                Effect.tap((p) => {
-                  preservedPath = p;
-                }),
-                Effect.asVoid,
-                Effect.orDie
-              )
-            ).pipe(
-              Effect.map((value) => ({
-                value,
-                preservedWorktreePath: preservedPath
-              })),
-              Effect.mapError(
-                (e) => attachPreservedPath(preservedPath, e)
-              )
-            );
-          }
-          if (sandboxProvider.tag === "isolated") {
+          {
             let preservedPath;
             return Effect.acquireUseRelease(
               pruneAndCreate(),
@@ -2399,13 +1958,14 @@ var WorktreeDockerSandboxFactory = {
                       hostRepoDir: worktreeInfo.path,
                       sourceRepoDir: hostRepoDir,
                       env,
-                      copyPaths
+                      copyPaths,
+                      copyTimeoutMs: timeouts?.copyToWorktreeMs
                     }),
                     ({ sandbox, worktreePath, handle }) => makeEffect(
                       {
                         hostWorktreePath: worktreeInfo.path,
                         sandboxRepoPath: worktreePath,
-                        bindMountHandle: toSessionTransferHandle(handle),
+                        sessionTransferHandle: toSessionTransferHandle(handle),
                         applyToHost: () => syncOut(
                           worktreeInfo.path,
                           handle
@@ -2437,374 +1997,191 @@ var WorktreeDockerSandboxFactory = {
               )
             );
           }
-          if (isHeadMode) {
-            const gitPath = join(hostRepoDir, ".git");
-            return (hooks?.host?.onWorktreeReady?.length ? runHostHooks(hooks.host.onWorktreeReady, hostRepoDir, signal) : Effect.void).pipe(
-              Effect.andThen(resolveGitMounts(gitPath)),
-              Effect.provideService(FileSystem.FileSystem, fileSystem),
-              Effect.mapError(
-                (e) => new WorktreeError({
-                  message: `Failed to resolve git mounts: ${e}`
-                })
-              ),
-              Effect.flatMap(
-                (gitMounts) => (
-                  // Patch git mounts for Windows worktree compatibility (ADR-0006)
-                  patchGitMountsForWindows(
-                    gitMounts,
-                    hostRepoDir,
-                    SANDBOX_REPO_DIR
-                  )
-                )
-              ),
-              Effect.flatMap(
-                (gitMounts) => Effect.acquireUseRelease(
-                  startSandbox({
-                    provider: sandboxProvider,
-                    hostRepoDir,
-                    env,
-                    worktreeOrRepoPath: hostRepoDir,
-                    gitMounts,
-                    repoDir: SANDBOX_REPO_DIR
-                  }),
-                  // Use
-                  ({ sandbox, worktreePath, handle }) => makeEffect(
-                    {
-                      hostWorktreePath: hostRepoDir,
-                      sandboxRepoPath: worktreePath,
-                      bindMountHandle: handle
-                    },
-                    sandbox
-                  ),
-                  // Release
-                  ({ handle }) => Effect.tryPromise({
-                    try: () => handle.close(),
-                    catch: () => void 0
-                  }).pipe(Effect.orDie)
-                ).pipe(
-                  Effect.map((value) => ({
-                    value,
-                    preservedWorktreePath: void 0
-                  }))
-                )
-              )
-            );
-          }
-          let preservedWorktreePath;
-          return Effect.acquireUseRelease(
-            // Acquire: prune stale worktrees (best-effort), then create the worktree.
-            pruneAndCreate(),
-            // Use: copy files, run host hooks, resolve+patch git mounts, then start
-            // the sandbox under a nested acquireUseRelease.
-            (worktreeInfo) => (copyPaths && copyPaths.length > 0 ? display.spinner(
-              "Copying to worktree",
-              copyToWorktree(
-                copyPaths,
-                hostRepoDir,
-                worktreeInfo.path,
-                timeouts?.copyToWorktreeMs
-              )
-            ) : Effect.succeed(void 0)).pipe(
-              Effect.andThen(
-                hooks?.host?.onWorktreeReady?.length ? runHostHooks(
-                  hooks.host.onWorktreeReady,
-                  worktreeInfo.path,
-                  signal
-                ) : Effect.void
-              ),
-              Effect.andThen(
-                resolveGitMounts(join(hostRepoDir, ".git")).pipe(
-                  Effect.provideService(FileSystem.FileSystem, fileSystem),
-                  Effect.mapError(
-                    (e) => new WorktreeError({
-                      message: `Failed to resolve git mounts: ${e}`
-                    })
-                  )
-                )
-              ),
-              // Patch git mounts for Windows worktree compatibility (ADR-0006)
-              Effect.flatMap(
-                (gitMounts) => patchGitMountsForWindows(
-                  gitMounts,
-                  worktreeInfo.path,
-                  SANDBOX_REPO_DIR
-                )
-              ),
-              Effect.flatMap(
-                (gitMounts) => Effect.acquireUseRelease(
-                  // sandboxProvider is guaranteed bind-mount here
-                  // (isolated providers return early above)
-                  startSandbox({
-                    provider: sandboxProvider,
-                    hostRepoDir,
-                    env,
-                    worktreeOrRepoPath: worktreeInfo.path,
-                    gitMounts,
-                    repoDir: SANDBOX_REPO_DIR
-                  }),
-                  ({ sandbox, worktreePath, handle }) => makeEffect(
-                    {
-                      hostWorktreePath: worktreeInfo.path,
-                      sandboxRepoPath: worktreePath,
-                      bindMountHandle: handle
-                    },
-                    sandbox
-                  ),
-                  ({ handle }) => Effect.tryPromise({
-                    try: () => handle.close(),
-                    catch: () => void 0
-                  }).pipe(Effect.orDie)
-                )
-              )
-            ),
-            // Release: remove or preserve the worktree based on dirty state.
-            (worktreeInfo, exit) => cleanupWorktree(worktreeInfo.path, exit).pipe(
-              Effect.tap((p) => {
-                preservedWorktreePath = p;
-              }),
-              Effect.asVoid,
-              Effect.orDie
-            )
-          ).pipe(
-            Effect.map((value) => ({
-              value,
-              preservedWorktreePath
-            })),
-            Effect.mapError(
-              (e) => attachPreservedPath(preservedWorktreePath, e)
-            )
-          );
         }
       };
     })
   )
 };
-
-// src/mountUtils.ts
-var defaultImageName = (repoDir) => {
-  const dirName = repoDir.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "local";
-  const sanitized = dirName.toLowerCase().replace(/[^a-z0-9_.-]/g, "-");
-  return `${RUNTIME_NAMESPACE}:${sanitized || "local"}`;
-};
-var expandTilde = (p, homeDirPath) => {
-  const home = homeDirPath ?? homedir();
-  if (p === "~") return home;
-  if (p.startsWith("~/") || p.startsWith("~\\")) return home + "/" + p.slice(2);
-  return p;
-};
-var resolveHostPath = (hostPath) => {
-  const expanded = expandTilde(hostPath);
-  return isAbsolute(expanded) ? expanded : resolve(process.cwd(), expanded);
-};
-var resolveSandboxPath = (sandboxPath, sandboxHomedir) => {
-  const hasTilde = sandboxPath === "~" || sandboxPath.startsWith("~/") || sandboxPath.startsWith("~\\");
-  if (hasTilde && sandboxHomedir === void 0) {
-    throw new Error(
-      `sandboxPath "${sandboxPath}" contains a tilde but the provider has no sandboxHomedir set`
-    );
-  }
-  const expanded = hasTilde ? expandTilde(sandboxPath, sandboxHomedir) : sandboxPath;
-  return isAbsolute(expanded) ? resolve(expanded) : resolve(SANDBOX_REPO_DIR, expanded);
-};
-var resolveUserMounts = (mounts, sandboxHomedir) => mounts.map((m) => {
-  const resolvedHostPath = resolveHostPath(m.hostPath);
-  if (!existsSync(resolvedHostPath)) {
-    throw new Error(
-      `Mount hostPath does not exist: ${m.hostPath}` + (m.hostPath !== resolvedHostPath ? ` (resolved to ${resolvedHostPath})` : "")
+var syncIn = (hostRepoDir, handle) => Effect.gen(function* () {
+  const protectedRunnerPath = `${CONFIG_DIR}/${RUNNER_DIR}`;
+  const runnerObjects = yield* execHostGit2(
+    ["rev-list", "--objects", "--all", "--", protectedRunnerPath],
+    hostRepoDir
+  );
+  if (runnerObjects.trim().length > 0) {
+    return yield* Effect.fail(
+      new SyncError({
+        message: `Refusing to copy repository history into the sandbox because it contains protected repository runner files under ${protectedRunnerPath}. Remove those files from all refs before retrying.`
+      })
     );
   }
-  return {
-    hostPath: resolvedHostPath,
-    sandboxPath: resolveSandboxPath(m.sandboxPath, sandboxHomedir),
-    ...m.readonly ? { readonly: true } : {}
-  };
-});
-var normalizeMounts = (mounts, worktreeHostPath, sandboxRepoDir, platform = process.platform) => {
-  if (platform !== "win32") return mounts;
-  const normalizedWorktree = worktreeHostPath.replace(/\\/g, "/");
-  return mounts.map((m) => {
-    const hostPath = m.hostPath.replace(/\\/g, "/");
-    let sandboxPath = m.sandboxPath;
-    if (/^[A-Za-z]:[/\\]/.test(sandboxPath) || sandboxPath.includes("\\")) {
-      const normalizedSandboxPath = sandboxPath.replace(/\\/g, "/");
-      if (normalizedSandboxPath.startsWith(normalizedWorktree + "/")) {
-        const relativeSuffix = normalizedSandboxPath.slice(
-          normalizedWorktree.length
-        );
-        sandboxPath = sandboxRepoDir + relativeSuffix;
-      } else if (normalizedSandboxPath === normalizedWorktree) {
-        sandboxPath = sandboxRepoDir;
-      } else {
-        sandboxPath = normalizedSandboxPath;
-      }
-    }
-    return { ...m, hostPath, sandboxPath };
-  });
-};
-var parseGitdirPath = (gitdirPath) => {
-  const normalized = gitdirPath.replace(/\\/g, "/").replace(/\/+$/, "");
-  const segments = normalized.split("/");
-  const worktreeName = segments.pop();
-  segments.pop();
-  const parentGitDir = segments.join("/");
-  return { worktreeName, parentGitDir };
-};
-var patchGitMountsForWindows = (gitMounts, worktreeHostPath, sandboxRepoDir, readFile2, statFile, platform = process.platform) => Effect.gen(function* () {
-  if (platform !== "win32") return gitMounts;
-  const _readFile = readFile2 ?? (async (p) => {
-    const { readFile: rf } = await import('fs/promises');
-    return rf(p, "utf-8");
-  });
-  const _statFile = statFile ?? (async (p) => {
-    const { stat: stat2 } = await import('fs/promises');
-    const s = await stat2(p);
-    return s.isDirectory() ? "directory" : "file";
-  });
-  const gitEntryPath = join(worktreeHostPath, ".git");
-  const gitEntryType = yield* Effect.tryPromise({
-    try: () => _statFile(gitEntryPath),
-    catch: () => null
-  }).pipe(Effect.catchAll(() => Effect.succeed(null)));
-  if (gitEntryType === null) return gitMounts;
-  if (gitEntryType === "directory") return gitMounts;
-  const content = yield* Effect.tryPromise({
-    try: () => _readFile(gitEntryPath),
-    catch: () => null
-  }).pipe(
-    Effect.map((s) => s.trim()),
-    Effect.catchAll(() => Effect.succeed(null))
-  );
-  if (content === null) return gitMounts;
-  const match = content.match(/^gitdir:\s*(.+)$/);
-  if (!match) return gitMounts;
-  const gitdirPath = match[1];
-  const { parentGitDir, worktreeName } = parseGitdirPath(gitdirPath);
-  const correctedGitdir = `${PARENT_GIT_SANDBOX_DIR}/worktrees/${worktreeName}`;
-  const tempDir = yield* Effect.tryPromise({
-    try: () => mkdtemp(join(tmpdir(), `${CONTAINER_NAME_PREFIX}git-`)),
-    catch: (e) => new WorktreeError({
-      message: `Failed to create temp dir for git override: ${e instanceof Error ? e.message : String(e)}`
-    })
-  });
-  const tempGitFile = join(tempDir, "git-override");
-  yield* Effect.tryPromise({
-    try: () => writeFile(tempGitFile, `gitdir: ${correctedGitdir}
-`),
-    catch: (e) => new WorktreeError({
-      message: `Failed to write git override file: ${e instanceof Error ? e.message : String(e)}`
+  const branch = (yield* execHostGit2(
+    ["rev-parse", "--abbrev-ref", "HEAD"],
+    hostRepoDir
+  )).trim();
+  const bundleDir = yield* Effect.tryPromise({
+    try: () => mkdtemp(join(tmpdir(), `${RUNTIME_NAMESPACE}-bundle-`)),
+    catch: (e) => new SyncError({
+      message: `Failed to create temp dir: ${e instanceof Error ? e.message : String(e)}`
     })
   });
-  const normalizedParentGitDir = parentGitDir.replace(/\\/g, "/");
-  const gitFileHostPath = gitEntryPath.replace(/\\/g, "/");
-  const correctedMounts = [];
-  let replacedGitFile = false;
-  for (const m of gitMounts) {
-    const normalizedHostPath = m.hostPath.replace(/\\/g, "/");
-    if (normalizedHostPath === normalizedParentGitDir) {
-      correctedMounts.push({ ...m, sandboxPath: PARENT_GIT_SANDBOX_DIR });
-    } else if (normalizedHostPath === gitFileHostPath) {
-      correctedMounts.push({
-        ...m,
-        hostPath: tempGitFile,
-        sandboxPath: `${sandboxRepoDir}/.git`
+  const bundleHostPath = join(bundleDir, "repo.bundle");
+  yield* Effect.ensuring(
+    Effect.gen(function* () {
+      yield* execHostGit2(
+        ["bundle", "create", bundleHostPath, "--all"],
+        hostRepoDir
+      );
+      const mkTempResult = yield* execOk(
+        handle,
+        `mktemp -d -t ${RUNTIME_NAMESPACE}-XXXXXX`
+      );
+      const sandboxTmpDir = mkTempResult.stdout.trim();
+      const bundleSandboxPath = `${sandboxTmpDir}/repo.bundle`;
+      yield* Effect.tryPromise({
+        try: () => handle.copyIn(bundleHostPath, bundleSandboxPath),
+        catch: (e) => new SyncError({
+          message: `Failed to copy bundle into sandbox: ${e instanceof Error ? e.message : String(e)}`
+        })
       });
-      replacedGitFile = true;
-    } else {
-      correctedMounts.push(m);
-    }
-  }
-  if (!replacedGitFile) {
-    correctedMounts.push({
-      hostPath: tempGitFile,
-      sandboxPath: `${sandboxRepoDir}/.git`
-    });
-  }
-  return correctedMounts;
-});
-var formatVolumeMount = (mount, selinuxLabel) => {
-  const base = `${mount.hostPath}:${mount.sandboxPath}`;
-  const options = [mount.readonly ? "ro" : void 0, selinuxLabel || void 0].filter((option) => option !== void 0).join(",");
-  return options ? `${base}:${options}` : base;
-};
-var processFileMountParents = (mounts, sandboxHomedir, statFn = statSync) => {
-  const parentDirs = /* @__PURE__ */ new Set();
-  for (const mount of mounts) {
-    let isFile;
-    try {
-      isFile = statFn(mount.hostPath).isFile();
-    } catch {
-      continue;
-    }
-    if (!isFile) continue;
-    const parentDir = resolve(dirname(mount.sandboxPath));
-    const homeDir = resolve(sandboxHomedir);
-    if (parentDir === homeDir) continue;
-    const fromHome = relative(homeDir, parentDir);
-    if (fromHome === ".." || fromHome.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(fromHome)) {
-      throw new Error(
-        `Cannot mount file to '${mount.sandboxPath}': parent directory '${parentDir}' is outside the sandbox home directory ('${homeDir}'). Mount the parent directory instead, or rebuild the image with '${parentDir}' pre-created.`
+      const worktreePath = handle.worktreePath;
+      yield* execOk(
+        handle,
+        `git clone ${shellQuote(bundleSandboxPath)} ${shellQuote(`${worktreePath}_clone`)}`
       );
-    }
-    parentDirs.add(parentDir);
-  }
-  return [...parentDirs];
-};
-var assertIsolatedWorkspaceMounts = (mounts) => {
-  for (const mount of mounts) {
-    const path = posix.resolve(mount.sandboxPath);
-    if (path === "/" || path === SANDBOX_REPO_DIR || path.startsWith(`${SANDBOX_REPO_DIR}/`) || SANDBOX_REPO_DIR.startsWith(`${path}/`)) {
-      throw new Error(
-        `Mount overlaps the isolated workspace: ${mount.sandboxPath}. Mount outside ${SANDBOX_REPO_DIR} or use copyToWorktree.`
+      yield* execOk(
+        handle,
+        `rm -rf ${shellQuote(worktreePath)} && mv ${shellQuote(`${worktreePath}_clone`)} ${shellQuote(worktreePath)}`
       );
-    }
-  }
-};
+      yield* execOk(handle, `git checkout ${shellQuote(branch)}`, {
+        cwd: worktreePath
+      });
+      yield* Effect.tryPromise({
+        try: () => handle.exec(`rm -rf ${shellQuote(sandboxTmpDir)}`),
+        catch: () => new SyncError({ message: "Failed to clean up sandbox temp dir" })
+      });
+      const hostHead = (yield* execHostGit2(
+        ["rev-parse", "HEAD"],
+        hostRepoDir
+      )).trim();
+      const sandboxHead = (yield* execOk(handle, "git rev-parse HEAD", {
+        cwd: worktreePath
+      })).stdout.trim();
+      if (hostHead !== sandboxHead) {
+        yield* Effect.fail(
+          new SyncError({
+            message: `HEAD mismatch after sync-in: host=${hostHead} sandbox=${sandboxHead}`
+          })
+        );
+      }
+    }),
+    // Clean up host-side bundle temp dir (runs regardless of success/failure)
+    Effect.promise(() => rm(bundleDir, { recursive: true, force: true }))
+  );
+  return { branch };
+});
 
-// src/shutdownRegistry.ts
-var teardownCallbacks = /* @__PURE__ */ new Set();
-var listenersInstalled = false;
-var runTeardowns = () => {
-  for (const teardown of teardownCallbacks) {
-    try {
-      teardown();
-    } catch {
+// src/startSandbox.ts
+var CONTAINER_START_TIMEOUT_MS = 12e4;
+var SYNC_IN_TIMEOUT_MS = 12e4;
+var COPY_PATHS_TIMEOUT_MS = 6e4;
+var startSandbox = (options) => Effect.gen(function* () {
+  const handle = yield* Effect.tryPromise({
+    try: () => options.provider.create({
+      env: options.env,
+      hostRepoPath: options.sourceRepoDir ?? options.hostRepoDir
+    }),
+    catch: (e) => new WorktreeError({
+      message: `Isolated provider '${options.provider.name}' setup failed: ${e instanceof Error ? e.message : String(e)}`
+    })
+  }).pipe(
+    withTimeout(
+      CONTAINER_START_TIMEOUT_MS,
+      () => new ContainerStartTimeoutError({
+        message: `Isolated sandbox container start timed out after ${CONTAINER_START_TIMEOUT_MS}ms`,
+        timeoutMs: CONTAINER_START_TIMEOUT_MS
+      })
+    )
+  );
+  return yield* Effect.gen(function* () {
+    yield* syncIn(options.hostRepoDir, handle).pipe(
+      withTimeout(
+        SYNC_IN_TIMEOUT_MS,
+        () => new SyncInTimeoutError({
+          message: `Sync-in timed out after ${SYNC_IN_TIMEOUT_MS}ms`,
+          timeoutMs: SYNC_IN_TIMEOUT_MS
+        })
+      )
+    );
+    if (options.copyPaths && options.copyPaths.length > 0) {
+      const pathsToCopy = options.copyPaths;
+      const copySourceDir = options.copySourceDir ?? options.sourceRepoDir ?? options.hostRepoDir;
+      const copyTimeoutMs = options.copyTimeoutMs ?? COPY_PATHS_TIMEOUT_MS;
+      yield* Effect.gen(function* () {
+        for (const relativePath of pathsToCopy) {
+          let hostPath;
+          let sandboxPath;
+          try {
+            assertExcludesRepositoryRunner(relativePath);
+            hostPath = resolveSafeRelativePath(
+              copySourceDir,
+              relativePath,
+              "copy path"
+            );
+            resolveSafeRelativePath(
+              handle.worktreePath,
+              relativePath,
+              "copy path"
+            );
+            sandboxPath = posix.join(handle.worktreePath, relativePath);
+          } catch (error) {
+            return yield* Effect.fail(
+              new WorktreeError({
+                message: `Refusing unsafe copy path ${relativePath}: ${error instanceof Error ? error.message : String(error)}`
+              })
+            );
+          }
+          if (!existsSync(hostPath)) {
+            continue;
+          }
+          yield* Effect.tryPromise({
+            try: async () => {
+              await assertNoSymlinkComponents(
+                copySourceDir,
+                hostPath,
+                "copy source"
+              );
+            },
+            catch: (error) => new WorktreeError({
+              message: `Refusing symlinked copy path ${relativePath}: ${error instanceof Error ? error.message : String(error)}`
+            })
+          });
+          yield* Effect.tryPromise({
+            try: () => handle.copyIn(hostPath, sandboxPath),
+            catch: (e) => new WorktreeError({
+              message: `Failed to copy ${relativePath} into sandbox: ${e instanceof Error ? e.message : String(e)}`
+            })
+          });
+        }
+      }).pipe(
+        withTimeout(
+          copyTimeoutMs,
+          () => new CopyToWorktreeTimeoutError({
+            message: `Copying paths to sandbox timed out after ${copyTimeoutMs}ms`,
+            timeoutMs: copyTimeoutMs,
+            paths: pathsToCopy
+          })
+        )
+      );
     }
-  }
-};
-var handleExit = () => {
-  runTeardowns();
-};
-var handleSignal = () => {
-  detachListeners();
-  runTeardowns();
-  process.exit(1);
-};
-var attachListeners = () => {
-  if (listenersInstalled) return;
-  listenersInstalled = true;
-  process.on("exit", handleExit);
-  process.on("SIGINT", handleSignal);
-  process.on("SIGTERM", handleSignal);
-};
-var detachListeners = () => {
-  if (!listenersInstalled) return;
-  listenersInstalled = false;
-  process.removeListener("exit", handleExit);
-  process.removeListener("SIGINT", handleSignal);
-  process.removeListener("SIGTERM", handleSignal);
-};
-var registerShutdown = (teardown) => {
-  teardownCallbacks.add(teardown);
-  attachListeners();
-  let active = true;
-  return () => {
-    if (!active) return;
-    active = false;
-    teardownCallbacks.delete(teardown);
-    if (teardownCallbacks.size === 0) detachListeners();
-  };
-};
+    return {
+      handle,
+      sandbox: makeSandboxFromHandle(handle),
+      worktreePath: handle.worktreePath
+    };
+  }).pipe(Effect.onError(() => Effect.promise(() => handle.close())));
+});
 
-export { ACTIVATION_LABEL, AgentError, AgentIdleTimeoutError, CLI_NAME, CONFIG_DIR, ClackDisplay, ConfigDirError, CwdError, Display, DockerError, ExecHostError, FileDisplay, InitError, LOCKS_DIR, LOGS_DIR, PRODUCT_NAME, PromptError, PromptExpansionTimeoutError, RUNNER_DIR, RUNNER_SANDBOX_MASK_DIR, SANDBOX_REPO_DIR, SandboxConfig, SandboxFactory, SessionCaptureError, SilentDisplay, WorktreeDockerSandboxFactory, assertIsolatedWorkspaceMounts, assertNoSymlinkComponents, assertProtectedDirectoryIdentities, copyToWorktree, create, defaultImageName, formatVolumeMount, generateTempBranchName, getCurrentBranch, hasUncommittedChanges, makeSandboxFromHandle, patchGitMountsForWindows, processFileMountParents, pruneStale, registerShutdown, remove, repositoryRunnerEnvironment, resolveCwd, resolveGitMounts, resolveUserMounts, runHostHooks, startSandbox, syncOut, withSandboxLifecycle };
-//# sourceMappingURL=chunk-FDYOTN55.js.map
-//# sourceMappingURL=chunk-FDYOTN55.js.map
+export { ACTIVATION_LABEL, AgentError, AgentIdleTimeoutError, CLI_NAME, CONFIG_DIR, ClackDisplay, ConfigDirError, CopyToWorktreeError, CopyToWorktreeTimeoutError, CwdError, Display, DockerError, ExecHostError, FileDisplay, InitError, LOCKS_DIR, LOGS_DIR, PRODUCT_NAME, PromptError, PromptExpansionTimeoutError, RUNNER_DIR, RUNTIME_NAMESPACE, SANDBOX_REPO_DIR, SandboxConfig, SandboxFactory, SessionCaptureError, SilentDisplay, WorktreeDockerSandboxFactory, assertExcludesRepositoryRunner, assertNoSymlinkComponents, assertProtectedDirectoryIdentities, create, createIsolatedSandboxProvider, generateTempBranchName, getCurrentBranch, hasUncommittedChanges, makeSandboxFromHandle, pruneStale, registerShutdown, remove, repositoryRunnerEnvironment, resolveCwd, resolveSafeRelativePath, runHostHooks, shellQuote, startSandbox, syncOut, toSessionTransferHandle, withSandboxLifecycle, withTimeout };
+//# sourceMappingURL=chunk-57EEKW3R.js.map
+//# sourceMappingURL=chunk-57EEKW3R.js.map