@snappedly-tools/shipyard 0.2.0 → 0.3.0

package/dist/chunk-2GT3OPO5.js

@@ -0,0 +1,2620 @@
+import { toSessionTransferHandle, shellQuote } from './chunk-KMGNFXKN.js';
+import { existsSync, constants, statSync } from 'fs';
+import { mkdtemp, writeFile, chmod, mkdir, stat, copyFile, rm, readdir, 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 { 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';
+
+var Display = class extends Context.Tag("Display")() {
+};
+var SilentDisplay = {
+  layer: (ref) => Layer.succeed(Display, {
+    intro: (title) => Ref.update(ref, (entries) => [
+      ...entries,
+      { _tag: "intro", title }
+    ]),
+    status: (message, severity) => Ref.update(ref, (entries) => [
+      ...entries,
+      { _tag: "status", message, severity }
+    ]),
+    spinner: (message, effect) => Effect.flatMap(
+      Ref.update(ref, (entries) => [
+        ...entries,
+        { _tag: "spinner", message }
+      ]),
+      () => effect
+    ),
+    summary: (title, rows) => Ref.update(ref, (entries) => [
+      ...entries,
+      { _tag: "summary", title, rows }
+    ]),
+    taskLog: (title, effect) => {
+      const messages = [];
+      return Effect.flatMap(
+        effect((msg) => messages.push(msg)),
+        (result) => Effect.map(
+          Ref.update(ref, (entries) => [
+            ...entries,
+            {
+              _tag: "taskLog",
+              title,
+              messages: [...messages]
+            }
+          ]),
+          () => result
+        )
+      );
+    },
+    text: (message) => Ref.update(ref, (entries) => [
+      ...entries,
+      { _tag: "text", message }
+    ]),
+    textChunk: (chunk) => Ref.update(ref, (entries) => [
+      ...entries,
+      { _tag: "textChunk", message: chunk }
+    ]),
+    toolCall: (name, formattedArgs) => Ref.update(ref, (entries) => [
+      ...entries,
+      { _tag: "toolCall", name, formattedArgs }
+    ])
+  })
+};
+var FileDisplay = {
+  layer: (filePath) => Layer.scoped(
+    Display,
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const logFileIsSymlink = yield* fs.readLink(filePath).pipe(
+        Effect.map(() => true),
+        Effect.catchAll(() => Effect.succeed(false))
+      );
+      if (logFileIsSymlink) {
+        yield* Effect.die(
+          new Error(
+            `Refusing to write through symlinked log file: ${filePath}`
+          )
+        );
+      }
+      yield* fs.makeDirectory(dirname(filePath), { recursive: true, mode: 448 }).pipe(Effect.orDie);
+      const delimiter = `
+--- Run started: ${(/* @__PURE__ */ new Date()).toISOString()} ---
+`;
+      const file = yield* Effect.acquireRelease(
+        Effect.tryPromise(
+          () => open(
+            filePath,
+            constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW,
+            384
+          )
+        ).pipe(Effect.orDie),
+        (handle) => Effect.promise(() => handle.close()).pipe(Effect.orDie)
+      );
+      yield* Effect.tryPromise(async () => {
+        if (!(await file.stat()).isFile())
+          throw new Error("Log must be a regular file");
+        await file.chmod(384);
+        await file.appendFile(delimiter);
+      }).pipe(Effect.orDie);
+      let midLine = false;
+      const appendToLog = (line) => Effect.suspend(() => {
+        const prefix = midLine ? "\n" : "";
+        midLine = false;
+        return Effect.tryPromise(
+          () => file.appendFile(`${prefix}${line}
+`)
+        ).pipe(Effect.ignore);
+      });
+      const appendRaw = (chunk) => Effect.suspend(() => {
+        if (chunk.length === 0) return Effect.void;
+        midLine = !chunk.endsWith("\n");
+        return Effect.tryPromise(() => file.appendFile(chunk)).pipe(
+          Effect.ignore
+        );
+      });
+      return {
+        intro: () => Effect.void,
+        status: (message, _severity) => appendToLog(message.replace(/^\[[^\]]+\] /, "")),
+        spinner: (message, effect) => Effect.gen(function* () {
+          yield* appendToLog(`${message}...`);
+          const start = Date.now();
+          const result = yield* effect;
+          const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
+          yield* appendToLog(`${message} done (${elapsed}s)`);
+          return result;
+        }),
+        summary: (title, rows) => {
+          const lines = Object.entries(rows).map(([key, value]) => `  ${key}: ${value}`).join("\n");
+          return appendToLog(`${title}
+${lines}`);
+        },
+        taskLog: (title, effect) => Effect.gen(function* () {
+          yield* appendToLog(title);
+          const start = Date.now();
+          const messages = [];
+          const result = yield* effect((msg) => {
+            messages.push(msg);
+          });
+          const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
+          for (const msg of messages) {
+            yield* appendToLog(`  ${msg}`);
+          }
+          yield* appendToLog(`${title} done (${elapsed}s)`);
+          return result;
+        }),
+        text: (message) => appendToLog(message),
+        textChunk: (chunk) => appendRaw(chunk),
+        toolCall: (name, formattedArgs) => appendToLog(`${name}(${formattedArgs})`)
+      };
+    })
+  )
+};
+var severityToClack = {
+  info: clack.log.info,
+  success: clack.log.success,
+  warn: clack.log.warning,
+  error: clack.log.error
+};
+var terminalStyle = {
+  status: (message) => styleText("bold", message),
+  summaryTitle: (title) => styleText("bold", title),
+  summaryRow: (key, value) => `${styleText("bold", key)}: ${styleText("dim", value)}`,
+  toolCall: (text) => styleText("dim", text)
+};
+var ClackDisplay = {
+  layer: Layer.succeed(Display, {
+    intro: (title) => Effect.sync(() => clack.intro(styleText("inverse", ` ${title} `))),
+    status: (message, severity) => Effect.sync(
+      () => severityToClack[severity](terminalStyle.status(message))
+    ),
+    spinner: (message, effect) => Effect.acquireUseRelease(
+      Effect.sync(() => {
+        const s = clack.spinner();
+        s.start(message);
+        return s;
+      }),
+      () => effect,
+      (s, exit) => Effect.sync(() => {
+        if (exit._tag === "Success") {
+          s.stop(message);
+        } else {
+          s.stop(`${message} (failed)`);
+        }
+      })
+    ),
+    summary: (title, rows) => Effect.sync(() => {
+      const lines = Object.entries(rows).map(([key, value]) => terminalStyle.summaryRow(key, value)).join("\n");
+      clack.note(lines, terminalStyle.summaryTitle(title));
+    }),
+    taskLog: (title, effect) => Effect.acquireUseRelease(
+      Effect.sync(() => clack.taskLog({ title })),
+      (log2) => effect((msg) => log2.message(msg)),
+      (log2, exit) => Effect.sync(() => {
+        if (exit._tag === "Success") {
+          log2.success(title, { showLog: true });
+        } else {
+          log2.error(title, { showLog: true });
+        }
+      })
+    ),
+    text: (message) => Effect.sync(() => clack.log.message(message)),
+    textChunk: (chunk) => Effect.sync(() => clack.log.message(chunk)),
+    toolCall: (name, formattedArgs) => Effect.sync(
+      () => clack.log.step(terminalStyle.toolCall(`${name}(${formattedArgs})`))
+    )
+  })
+};
+var CwdError = class extends Data.TaggedError("CwdError") {
+};
+var resolveCwd = (cwd) => Effect.gen(function* () {
+  const resolved = cwd !== void 0 ? resolve(process.cwd(), cwd) : resolve(process.cwd());
+  const fs = yield* FileSystem.FileSystem;
+  const stat2 = yield* fs.stat(resolved).pipe(
+    Effect.mapError(
+      () => new CwdError({
+        message: `cwd does not exist: ${resolved}`,
+        cwd: resolved
+      })
+    )
+  );
+  if (stat2.type !== "Directory") {
+    return yield* new CwdError({
+      message: `cwd is not a directory: ${resolved}`,
+      cwd: resolved
+    });
+  }
+  return resolved;
+});
+
+// src/errors.ts
+var ExecError = class extends Data.TaggedError("ExecError") {
+};
+var ExecHostError = class extends Data.TaggedError("ExecHostError") {
+};
+var CopyError = class extends Data.TaggedError("CopyError") {
+};
+var DockerError = class extends Data.TaggedError("DockerError") {
+};
+var SyncError = class extends Data.TaggedError("SyncError") {
+};
+var WorktreeError = class extends Data.TaggedError("WorktreeError") {
+};
+var PromptError = class extends Data.TaggedError("PromptError") {
+};
+var AgentError = class extends Data.TaggedError("AgentError") {
+};
+var ConfigDirError = class extends Data.TaggedError("ConfigDirError") {
+};
+var InitError = class extends Data.TaggedError("InitError") {
+};
+var AgentIdleTimeoutError = class extends Data.TaggedError(
+  "AgentIdleTimeoutError"
+) {
+};
+var WorktreeTimeoutError = class extends Data.TaggedError(
+  "WorktreeTimeoutError"
+) {
+};
+var ContainerStartTimeoutError = class extends Data.TaggedError(
+  "ContainerStartTimeoutError"
+) {
+};
+var CopyToWorktreeTimeoutError = class extends Data.TaggedError(
+  "CopyToWorktreeTimeoutError"
+) {
+};
+var CopyToWorktreeError = class extends Data.TaggedError(
+  "CopyToWorktreeError"
+) {
+};
+var SyncInTimeoutError = class extends Data.TaggedError("SyncInTimeoutError") {
+};
+var HookTimeoutError = class extends Data.TaggedError("HookTimeoutError") {
+};
+var GitSetupTimeoutError = class extends Data.TaggedError(
+  "GitSetupTimeoutError"
+) {
+};
+var PromptExpansionTimeoutError = class extends Data.TaggedError(
+  "PromptExpansionTimeoutError"
+) {
+};
+var CommitCollectionTimeoutError = class extends Data.TaggedError(
+  "CommitCollectionTimeoutError"
+) {
+};
+var MergeToHostTimeoutError = class extends Data.TaggedError(
+  "MergeToHostTimeoutError"
+) {
+};
+var withTimeout = (timeoutMs, onTimeout) => (effect) => effect.pipe(
+  Effect.timeoutFail({
+    duration: Duration.millis(timeoutMs),
+    onTimeout
+  })
+);
+var SessionCaptureError = class extends Data.TaggedError(
+  "SessionCaptureError"
+) {
+};
+
+// src/runtimeNames.ts
+var PRODUCT_NAME = "Shipyard";
+var CLI_NAME = "shipyard";
+var RUNTIME_NAMESPACE = "shipyard";
+var CONFIG_DIR = ".shipyard";
+var LOGS_DIR = "logs";
+var WORKTREES_DIR = "worktrees";
+var PATCHES_DIR = "patches";
+var LOCKS_DIR = "locks";
+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 === "..")) {
+    throw new Error(`${label} must stay within its root: ${relativePath}`);
+  }
+};
+var assertSafePathSegment = (segment, label = "path segment") => {
+  assertSafeRelativePath(segment, label);
+  if (segment.includes("/") || segment.includes("\\")) {
+    throw new Error(`${label} must be a single filename: ${segment}`);
+  }
+};
+var resolveSafeRelativePath = (root, relativePath, label = "relative path") => {
+  assertSafeRelativePath(relativePath, label);
+  const rootPath = resolve(root);
+  const candidate = resolve(rootPath, relativePath);
+  const fromRoot = relative(rootPath, candidate);
+  if (fromRoot.length === 0 || fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot)) {
+    throw new Error(`${label} must stay within its root: ${relativePath}`);
+  }
+  return candidate;
+};
+var assertNoSymlinkComponents = async (root, target, label = "path") => {
+  const rootPath = resolve(root);
+  const targetPath = resolve(target);
+  const fromRoot = relative(rootPath, targetPath);
+  if (fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot)) {
+    throw new Error(`${label} escapes its root`);
+  }
+  let current = rootPath;
+  for (const part of fromRoot.split(sep).filter(Boolean)) {
+    current = join(current, part);
+    try {
+      const info = await lstat(current);
+      if (info.isSymbolicLink()) {
+        throw new Error(`${label} contains a symbolic link: ${current}`);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") break;
+      throw error;
+    }
+  }
+};
+var assertSafeGitWorktreePath = (path) => {
+  assertSafeRelativePath(path, "untracked path");
+  for (const component of path.split(/[\\/]/)) {
+    const normalized = component.replace(/[\u200c-\u200f\u202a-\u202e\u206a-\u206f\ufeff]/g, "").toLowerCase().split(":")[0].replace(/[ .]+$/, "");
+    if (normalized === ".git" || /^git~[0-9]+$/.test(normalized)) {
+      throw new Error(`Untracked path addresses Git metadata: ${path}`);
+    }
+  }
+};
+var MAX_BUFFER = 10 * 1024 * 1024;
+var SAFE_CONFIG = [
+  ["core.hooksPath", "/dev/null"],
+  ["core.fsmonitor", "false"],
+  ["core.pager", "cat"],
+  ["core.alternateRefsCommand", "false"],
+  ["commit.gpgSign", "false"],
+  ["tag.gpgSign", "false"],
+  ["gpg.program", "false"],
+  ["gpg.ssh.program", "false"],
+  ["gpg.ssh.defaultKeyCommand", "false"],
+  ["merge.autoEdit", "no"],
+  ["interactive.diffFilter", ""],
+  ["diff.external", ""],
+  ["maintenance.auto", "false"],
+  ["gc.auto", "0"],
+  ["submodule.recurse", "false"],
+  ["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) => {
+  execFile(
+    "git",
+    [...args],
+    {
+      cwd,
+      env: {
+        ...process.env,
+        ...options.env,
+        GIT_EDITOR: "true",
+        GIT_SEQUENCE_EDITOR: "true",
+        GIT_PAGER: "cat",
+        GIT_TERMINAL_PROMPT: "0"
+      },
+      maxBuffer: options.maxBuffer ?? MAX_BUFFER
+    },
+    (error, stdout, stderr) => {
+      if (!error) {
+        resolve6({ stdout, stderr, exitCode: 0 });
+        return;
+      }
+      if (typeof error.code === "number") {
+        resolve6({ stdout, stderr, exitCode: error.code });
+        return;
+      }
+      reject(error);
+    }
+  );
+});
+var configArgs = (entries) => entries.flatMap(([key, value]) => ["-c", `${key}=${value}`]);
+var commandDriverOverrides = async (cwd, options) => {
+  const result = await runGit(
+    ["config", "--null", "--name-only", "--get-regexp", COMMAND_CONFIG_PATTERN],
+    cwd,
+    options
+  );
+  if (result.exitCode === 1) return [];
+  if (result.exitCode !== 0) {
+    throw new Error(
+      result.stderr.trim() || "Failed to inspect Git configuration"
+    );
+  }
+  const overrides = /* @__PURE__ */ new Map();
+  for (const key of result.stdout.split("\0").filter(Boolean)) {
+    const filterMatch = /^(filter\..*)\.(clean|smudge|process|required)$/i.exec(
+      key
+    );
+    if (filterMatch) {
+      const section = filterMatch[1];
+      overrides.set(`${section}.clean`, "cat");
+      overrides.set(`${section}.smudge`, "cat");
+      overrides.set(`${section}.process`, "");
+      overrides.set(`${section}.required`, "false");
+      continue;
+    }
+    overrides.set(key, "false");
+  }
+  return configArgs([...overrides.entries()]);
+};
+var execHostGit = async (args, cwd, options = {}) => {
+  const driverArgs = await commandDriverOverrides(cwd, options);
+  const safeArgs = [...configArgs(SAFE_CONFIG), ...driverArgs, ...args];
+  const result = await runGit(safeArgs, cwd, options);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      result.stderr.trim() || `git ${args.join(" ")} failed with exit ${result.exitCode}`
+    );
+  }
+  return result.stdout;
+};
+
+// src/WorktreeManager.ts
+var WORKTREE_TIMEOUT_MS = 3e4;
+var NO_CONFIG_LOCK_FLAGS = [
+  "-c",
+  "branch.autoSetupMerge=false",
+  "-c",
+  "push.autoSetupRemote=false"
+];
+var formatTimestamp = (date) => {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+};
+var randomBranchSuffix = () => randomBytes(3).toString("hex");
+var sanitizeName = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "-");
+var execGit = (args, cwd) => Effect.tryPromise({
+  // Force the C locale so git emits English, machine-stable messages. Several
+  // callers match git's stderr (e.g. "invalid reference") to decide control
+  // flow; under a localized locale gettext translates those strings and the
+  // matches silently fail, breaking worktree creation (issue #595).
+  try: () => execHostGit(args, cwd, { env: { LC_ALL: "C" } }),
+  catch: (error) => new WorktreeError({
+    message: error instanceof Error ? error.message : String(error)
+  })
+});
+var generateTempBranchName = (name) => {
+  const ts = formatTimestamp(/* @__PURE__ */ new Date());
+  const suffix = randomBranchSuffix();
+  if (name) {
+    return `${RUNTIME_NAMESPACE}/${sanitizeName(name)}/${ts}-${suffix}`;
+  }
+  return `${RUNTIME_NAMESPACE}/${ts}-${suffix}`;
+};
+var getCurrentBranch = (repoDir) => execGit(["rev-parse", "--abbrev-ref", "HEAD"], repoDir).pipe(
+  Effect.map((output) => output.trim())
+);
+var normalizePath = (p) => {
+  const normalized = p.replace(/\\/g, "/");
+  if (process.platform === "darwin" && normalized.startsWith("/private/")) {
+    return normalized.slice("/private".length);
+  }
+  return normalized;
+};
+var findCollidingWorktree = (existing, branch, worktreePath) => existing.find((wt) => wt.branch === branch) ?? existing.find((wt) => normalizePath(wt.path) === normalizePath(worktreePath));
+var isManagedWorktreePath = (worktreePath, worktreesDir) => {
+  const candidate = normalizePath(worktreePath).replace(/\/+$/, "");
+  const root = normalizePath(worktreesDir).replace(/\/+$/, "");
+  return candidate === root || candidate.startsWith(`${root}/`);
+};
+var isOrphanedWorktreePath = (entryPath, activeWorktreePaths) => {
+  const normalizedEntry = normalizePath(entryPath);
+  for (const active of activeWorktreePaths) {
+    if (normalizePath(active) === normalizedEntry) return false;
+  }
+  return true;
+};
+var listWorktrees = (repoDir) => execGit(["worktree", "list", "--porcelain"], repoDir).pipe(
+  Effect.map((output) => {
+    const entries = [];
+    let currentPath = null;
+    let currentBranch = null;
+    for (const line of output.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        if (currentPath !== null) {
+          entries.push({ path: currentPath, branch: currentBranch });
+        }
+        currentPath = line.slice("worktree ".length).trim();
+        currentBranch = null;
+      } else if (line.startsWith("branch ")) {
+        currentBranch = line.slice("branch refs/heads/".length).trim();
+      }
+    }
+    if (currentPath !== null) {
+      entries.push({ path: currentPath, branch: currentBranch });
+    }
+    return entries;
+  })
+);
+var fastForwardFromOrigin = (worktreePath, branch) => Effect.gen(function* () {
+  const headRef = yield* execGit(
+    ["symbolic-ref", "--quiet", "HEAD"],
+    worktreePath
+  ).pipe(
+    Effect.map((s) => s.trim()),
+    Effect.orElseSucceed(() => "")
+  );
+  if (headRef !== `refs/heads/${branch}`) {
+    console.log(
+      `Reusing worktree at ${worktreePath} (branch '${branch}') \u2014 HEAD is not on '${branch}', skipping origin refresh`
+    );
+    return;
+  }
+  const fetchResult = yield* Effect.either(
+    execGit(
+      [...NO_CONFIG_LOCK_FLAGS, "fetch", "origin", branch],
+      worktreePath
+    )
+  );
+  if (fetchResult._tag === "Left") {
+    console.log(
+      `Could not fetch from origin (reusing worktree at ${worktreePath} as-is, branch '${branch}')`
+    );
+    return;
+  }
+  const before = yield* execGit(["rev-parse", "HEAD"], worktreePath).pipe(
+    Effect.map((s) => s.trim()),
+    Effect.orElseSucceed(() => "")
+  );
+  const mergeResult = yield* Effect.either(
+    execGit(
+      [...NO_CONFIG_LOCK_FLAGS, "merge", "--ff-only", `origin/${branch}`],
+      worktreePath
+    )
+  );
+  if (mergeResult._tag === "Left") {
+    console.log(
+      `Branch '${branch}' has diverged from origin (reusing worktree at ${worktreePath} as-is)`
+    );
+    return;
+  }
+  const after = yield* execGit(["rev-parse", "HEAD"], worktreePath).pipe(
+    Effect.map((s) => s.trim()),
+    Effect.orElseSucceed(() => "")
+  );
+  if (before && after && before !== after) {
+    console.log(
+      `Fast-forwarded worktree at ${worktreePath} (branch '${branch}') to origin/${branch}`
+    );
+  } else {
+    console.log(
+      `Reusing existing worktree at ${worktreePath} (branch '${branch}')`
+    );
+  }
+});
+var create = (repoDir, opts) => Effect.gen(function* () {
+  const configDir = join(repoDir, CONFIG_DIR);
+  const fs = yield* FileSystem.FileSystem;
+  const worktreesDir = join(configDir, WORKTREES_DIR);
+  yield* Effect.tryPromise({
+    try: () => assertNoSymlinkComponents(
+      configDir,
+      worktreesDir,
+      "Shipyard worktree directory"
+    ),
+    catch: (e) => new WorktreeError({
+      message: `Refusing symlinked Shipyard worktree directory: ${e instanceof Error ? e.message : String(e)}`
+    })
+  });
+  yield* fs.makeDirectory(worktreesDir, { recursive: true }).pipe(Effect.mapError((e) => new WorktreeError({ message: e.message })));
+  yield* Effect.tryPromise({
+    try: () => assertNoSymlinkComponents(
+      configDir,
+      worktreesDir,
+      "Shipyard worktree directory"
+    ),
+    catch: (e) => new WorktreeError({
+      message: `Refusing symlinked Shipyard worktree directory: ${e instanceof Error ? e.message : String(e)}`
+    })
+  });
+  let branch;
+  let worktreeName;
+  if (opts?.branch) {
+    branch = opts.branch;
+    yield* execGit(["check-ref-format", "--branch", branch], repoDir);
+    worktreeName = branch.replace(/\//g, "-");
+  } else {
+    const timestamp = formatTimestamp(/* @__PURE__ */ new Date());
+    const suffix = randomBranchSuffix();
+    if (opts?.name) {
+      const sanitized = sanitizeName(opts.name);
+      branch = `${RUNTIME_NAMESPACE}/${sanitized}/${timestamp}-${suffix}`;
+      worktreeName = `${RUNTIME_NAMESPACE}-${sanitized}-${timestamp}-${suffix}`;
+    } else {
+      branch = `${RUNTIME_NAMESPACE}/${timestamp}-${suffix}`;
+      worktreeName = `${RUNTIME_NAMESPACE}-${timestamp}-${suffix}`;
+    }
+  }
+  const worktreePath = join(worktreesDir, worktreeName);
+  const assertWorktreePathIsSafe = () => assertNoSymlinkComponents(configDir, worktreePath, "worktree path");
+  yield* Effect.tryPromise({
+    try: assertWorktreePathIsSafe,
+    catch: (e) => new WorktreeError({
+      message: `Refusing symlinked worktree path: ${e instanceof Error ? e.message : String(e)}`
+    })
+  });
+  if (opts?.branch) {
+    const existing = yield* listWorktrees(repoDir);
+    const collision = findCollidingWorktree(existing, branch, worktreePath);
+    if (collision) {
+      if (isManagedWorktreePath(collision.path, worktreesDir)) {
+        const dirty = yield* hasUncommittedChanges(collision.path);
+        if (dirty) {
+          console.warn(
+            `Reusing worktree at ${collision.path} (branch '${branch}') \u2014 worktree has uncommitted changes`
+          );
+        } else {
+          yield* fastForwardFromOrigin(collision.path, branch);
+        }
+        return { path: normalize(normalizePath(collision.path)), branch };
+      }
+      yield* Effect.fail(
+        new WorktreeError({
+          message: `Branch '${branch}' is already checked out in worktree at '${collision.path}'. Shipyard's branch and merge-to-head strategies run the agent in a git worktree under .shipyard/worktrees/, and git refuses to check out the same branch in two worktrees at once (HEAD would become ambiguous). Pick a different branch, or switch the main working tree to a different branch before re-running.`
+        })
+      );
+    }
+    yield* execGit(
+      [...NO_CONFIG_LOCK_FLAGS, "worktree", "add", worktreePath, branch],
+      repoDir
+    ).pipe(
+      Effect.catchAll((e) => {
+        if (e.message.includes("invalid reference")) {
+          return execGit(
+            [
+              ...NO_CONFIG_LOCK_FLAGS,
+              "worktree",
+              "add",
+              "-b",
+              branch,
+              worktreePath,
+              opts?.baseBranch ?? "HEAD"
+            ],
+            repoDir
+          );
+        }
+        return Effect.fail(e);
+      })
+    );
+  } else {
+    yield* execGit(
+      [
+        ...NO_CONFIG_LOCK_FLAGS,
+        "worktree",
+        "add",
+        "-b",
+        branch,
+        worktreePath,
+        "HEAD"
+      ],
+      repoDir
+    ).pipe(
+      Effect.catchAll((e) => {
+        if (e.message.includes("already checked out") || e.message.includes("already exists")) {
+          return Effect.fail(
+            new WorktreeError({
+              message: `Branch '${branch}' is already checked out in another worktree. Use a different branch name, or wait for the other run to finish.`
+            })
+          );
+        }
+        return Effect.fail(e);
+      })
+    );
+  }
+  yield* Effect.tryPromise({
+    try: assertWorktreePathIsSafe,
+    catch: (e) => new WorktreeError({
+      message: `Refusing symlinked worktree path: ${e instanceof Error ? e.message : String(e)}`
+    })
+  });
+  return { path: worktreePath, branch };
+}).pipe(
+  withTimeout(
+    WORKTREE_TIMEOUT_MS,
+    () => new WorktreeTimeoutError({
+      message: `Worktree creation timed out after ${WORKTREE_TIMEOUT_MS}ms`,
+      timeoutMs: WORKTREE_TIMEOUT_MS,
+      path: repoDir,
+      operation: "create"
+    })
+  )
+);
+var hasUncommittedChanges = (worktreePath) => execGit(["status", "--porcelain"], worktreePath).pipe(
+  Effect.map((output) => output.trim().length > 0)
+);
+var remove = (worktreePath) => {
+  const candidate = resolve(worktreePath);
+  const repoDir = resolve(candidate, "..", "..", "..");
+  const worktreesDir = resolve(repoDir, ".shipyard", WORKTREES_DIR);
+  if (!isManagedWorktreePath(candidate, worktreesDir) || candidate === worktreesDir) {
+    return Effect.fail(
+      new WorktreeError({
+        message: `Refusing to remove worktree outside ${worktreesDir}: ${worktreePath}`
+      })
+    );
+  }
+  return Effect.tryPromise({
+    try: () => assertNoSymlinkComponents(worktreesDir, candidate, "worktree path"),
+    catch: (e) => new WorktreeError({
+      message: `Refusing symlinked worktree path: ${e instanceof Error ? e.message : String(e)}`
+    })
+  }).pipe(
+    Effect.andThen(
+      execGit(["worktree", "remove", "--force", candidate], repoDir)
+    ),
+    Effect.asVoid
+  );
+};
+var pruneStale = (repoDir) => Effect.gen(function* () {
+  const configDir = join(repoDir, CONFIG_DIR);
+  const fs = yield* FileSystem.FileSystem;
+  yield* execGit(["worktree", "prune"], repoDir);
+  const worktreesDir = join(configDir, WORKTREES_DIR);
+  const configDirIsSymlink = yield* fs.readLink(configDir).pipe(
+    Effect.map(() => true),
+    Effect.catchAll(() => Effect.succeed(false))
+  );
+  const worktreesDirIsSymlink = yield* fs.readLink(worktreesDir).pipe(
+    Effect.map(() => true),
+    Effect.catchAll(() => Effect.succeed(false))
+  );
+  if (configDirIsSymlink || worktreesDirIsSymlink) return;
+  const entries = yield* fs.readDirectory(worktreesDir).pipe(
+    Effect.map((es) => es),
+    Effect.catchSome(
+      (e) => e._tag === "SystemError" && e.reason === "NotFound" ? Option.some(Effect.succeed(null)) : Option.none()
+    ),
+    Effect.mapError((e) => new WorktreeError({ message: e.message }))
+  );
+  if (entries === null) return;
+  const realWorktreesDir = yield* fs.realPath(worktreesDir).pipe(Effect.catchAll(() => Effect.succeed(worktreesDir)));
+  const worktreeList = yield* execGit(
+    ["worktree", "list", "--porcelain"],
+    repoDir
+  );
+  const activeWorktreePaths = new Set(
+    worktreeList.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.slice("worktree ".length).trim())
+  );
+  for (const entry of entries) {
+    const entryPath = join(realWorktreesDir, entry);
+    const entryIsSymlink = yield* fs.readLink(entryPath).pipe(
+      Effect.map(() => true),
+      Effect.catchAll(() => Effect.succeed(false))
+    );
+    if (entryIsSymlink) continue;
+    const isDir = yield* fs.stat(entryPath).pipe(
+      Effect.map((s) => s.type === "Directory"),
+      Effect.catchAll(() => Effect.succeed(false))
+    );
+    if (isDir && isOrphanedWorktreePath(entryPath, activeWorktreePaths)) {
+      yield* fs.remove(entryPath, { recursive: true, force: true }).pipe(
+        Effect.mapError(
+          (e) => new WorktreeError({
+            message: `Failed to remove ${entryPath}: ${e.message}`
+          })
+        )
+      );
+    }
+  }
+}).pipe(
+  withTimeout(
+    WORKTREE_TIMEOUT_MS,
+    () => new WorktreeTimeoutError({
+      message: `Worktree prune timed out after ${WORKTREE_TIMEOUT_MS}ms`,
+      timeoutMs: WORKTREE_TIMEOUT_MS,
+      path: repoDir,
+      operation: "prune"
+    })
+  )
+);
+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 {
+        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
+var buildRecoveryMessage = (input) => {
+  const { patchDir, failedStep, hasCommits, hasDiff, hasUntracked, branch } = input;
+  const cmdPatchDir = branch ? `../../${patchDir}` : patchDir;
+  const steps = [];
+  if (hasCommits)
+    steps.push({ key: "commits", label: "committed changes", has: true });
+  if (hasDiff)
+    steps.push({ key: "diff", label: "uncommitted changes", has: true });
+  if (hasUntracked)
+    steps.push({ key: "untracked", label: "untracked files", has: true });
+  const failedIndex = steps.findIndex((s) => s.key === failedStep);
+  const failedStepInfo = steps[failedIndex];
+  const stepNumber = failedIndex + 1;
+  const lines = [];
+  lines.push(
+    `Patch application failed at step ${stepNumber} (${failedStepInfo.label}).`
+  );
+  lines.push("");
+  if (branch) {
+    lines.push("Set up worktree, then resolve:");
+    lines.push(
+      formatCommandBlock([
+        `git worktree add .shipyard/worktree ${branch}`,
+        `cd .shipyard/worktree`
+      ])
+    );
+    lines.push("");
+  }
+  if (failedStep === "commits") {
+    lines.push("Resolve conflicts, then continue with:");
+    lines.push(`  git am --continue`);
+    const remaining = buildRemainingCommands(
+      cmdPatchDir,
+      steps.slice(failedIndex + 1)
+    );
+    if (remaining.length > 0) {
+      lines.push("");
+      lines.push("After all commits are applied, run the remaining steps:");
+      lines.push(formatCommandBlock(remaining));
+    }
+  } else {
+    const remaining = buildRemainingCommands(
+      cmdPatchDir,
+      steps.slice(failedIndex)
+    );
+    if (remaining.length > 0) {
+      lines.push("Run the remaining steps:");
+      lines.push(formatCommandBlock(remaining));
+    }
+  }
+  if (steps.slice(failedIndex).some((step) => step.key === "untracked")) {
+    lines.push("");
+    lines.push(
+      "The untracked-file command includes dotfiles and does not overwrite existing paths; review skipped conflicts manually."
+    );
+  }
+  return lines.join("\n");
+};
+var buildRemainingCommands = (patchDir, steps) => {
+  const commands = [];
+  for (const step of steps) {
+    if (!step.has) continue;
+    if (step.key === "commits") {
+      commands.push(`git am --3way ${patchDir}/*.patch`);
+    } else if (step.key === "diff") {
+      commands.push(`git apply ${patchDir}/changes.patch`);
+    } else if (step.key === "untracked") {
+      commands.push(`cp -Rn ${patchDir}/untracked/. .`);
+    }
+  }
+  return commands;
+};
+var formatCommandBlock = (commands) => {
+  if (commands.length === 1) {
+    return `  ${commands[0]}`;
+  }
+  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({
+    message: `Host command failed: git ${args.join(" ")}
+${e instanceof Error ? e.message : String(e)}`
+  })
+});
+var execOk = (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)}`
+  })
+}).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 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)}`
+  })
+});
+var isEmptyPatch = (patchPath) => Effect.tryPromise({
+  try: async () => {
+    const info = await stat(patchPath);
+    if (info.size === 0) return true;
+    const content = await readFile(patchPath, "utf-8");
+    return !content.includes("diff --git");
+  },
+  catch: (e) => new SyncError({
+    message: `Failed to check patch ${patchPath}: ${e instanceof Error ? e.message : String(e)}`
+  })
+});
+var createPatchDir = (hostRepoDir) => Effect.tryPromise({
+  try: async () => {
+    const now = /* @__PURE__ */ new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    const base = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+    const patchesRoot = join(hostRepoDir, CONFIG_DIR, PATCHES_DIR);
+    await assertNoSymlinkComponents(
+      hostRepoDir,
+      patchesRoot,
+      "patch directory"
+    );
+    await mkdir(patchesRoot, { recursive: true, mode: 448 });
+    await assertNoSymlinkComponents(
+      hostRepoDir,
+      patchesRoot,
+      "patch directory"
+    );
+    let dirName = base;
+    let counter = 0;
+    while (existsSync(join(patchesRoot, dirName))) {
+      counter++;
+      dirName = `${base}-${counter}`;
+    }
+    const patchDir = join(patchesRoot, dirName);
+    await mkdir(patchDir, { recursive: true, mode: 448 });
+    await assertNoSymlinkComponents(hostRepoDir, patchDir, "patch directory");
+    return patchDir;
+  },
+  catch: (e) => new SyncError({
+    message: `Failed to create patch directory: ${e instanceof Error ? e.message : String(e)}`
+  })
+});
+var countCommitsToSync = (sandbox, cwd, hostHead) => Effect.gen(function* () {
+  const baseResult = yield* sandbox.exec(`git rev-parse --verify --quiet ${shellQuote(SYNC_BASE_REF)}`, {
+    cwd
+  }).pipe(
+    Effect.catchAll(
+      () => Effect.succeed({
+        stdout: "",
+        stderr: "",
+        exitCode: 1
+      })
+    )
+  );
+  const base = baseResult.exitCode === 0 && baseResult.stdout.trim().length > 0 ? baseResult.stdout.trim() : hostHead;
+  const countResult = yield* sandbox.exec(`git rev-list ${shellQuote(`${base}..HEAD`)} --count`, { cwd }).pipe(
+    Effect.catchAll(
+      () => Effect.succeed({
+        stdout: "0",
+        stderr: "",
+        exitCode: 1
+      })
+    )
+  );
+  if (countResult.exitCode !== 0) return 0;
+  const parsed = parseInt(countResult.stdout.trim(), 10);
+  return Number.isNaN(parsed) ? 0 : parsed;
+});
+var syncOut = (hostRepoDir, handle) => Effect.gen(function* () {
+  const worktreePath = handle.worktreePath;
+  const hostHead = (yield* execHostGit2(
+    ["rev-parse", "HEAD"],
+    hostRepoDir
+  )).trim();
+  const sandboxHead = (yield* execOk(handle, "git rev-parse HEAD", {
+    cwd: worktreePath
+  })).stdout.trim();
+  const baseRefResult = yield* execSandbox(
+    handle,
+    `git rev-parse --verify --quiet ${shellQuote(SYNC_BASE_REF)}`,
+    { cwd: worktreePath }
+  );
+  const base = baseRefResult.exitCode === 0 && baseRefResult.stdout.trim().length > 0 ? baseRefResult.stdout.trim() : hostHead;
+  const hasCommits = base !== sandboxHead;
+  const diffResult = yield* execOk(handle, "git diff --binary HEAD", {
+    cwd: worktreePath
+  }).pipe(
+    Effect.mapError(
+      (error) => new SyncError({
+        message: `Failed to inspect sandbox diff: ${error.message}`
+      })
+    )
+  );
+  const hasDiff = diffResult.stdout.trim().length > 0;
+  const lsFilesResult = yield* execOk(
+    handle,
+    "git ls-files --others --exclude-standard -z",
+    { cwd: worktreePath }
+  ).pipe(
+    Effect.mapError(
+      (error) => new SyncError({
+        message: `Failed to inspect sandbox untracked files: ${error.message}`
+      })
+    )
+  );
+  const hasUntracked = lsFilesResult.stdout.length > 0;
+  const untrackedFiles = hasUntracked ? lsFilesResult.stdout.split("\0").filter((f) => f.length > 0) : [];
+  yield* Effect.try({
+    try: () => untrackedFiles.forEach(assertSafeGitWorktreePath),
+    catch: (error) => new SyncError({ message: String(error) })
+  });
+  if (!hasCommits && !hasDiff && !hasUntracked) {
+    return;
+  }
+  const patchDir = yield* createPatchDir(hostRepoDir);
+  const relativePatchDir = join(CONFIG_DIR, PATCHES_DIR, basename(patchDir));
+  const nonEmptyPatches = [];
+  if (hasCommits) {
+    const mkTempResult = yield* execOk(
+      handle,
+      `mktemp -d -t ${RUNTIME_NAMESPACE}-patches-XXXXXX`
+    );
+    const sandboxPatchDir = mkTempResult.stdout.trim();
+    try {
+      yield* execOk(
+        handle,
+        `git format-patch ${shellQuote(`${base}..HEAD`)} -o ${shellQuote(sandboxPatchDir)}`,
+        { cwd: worktreePath }
+      );
+      const lsResult = yield* execOk(
+        handle,
+        `find ${shellQuote(sandboxPatchDir)} -maxdepth 1 -type f -print0`
+      );
+      const patchPaths = lsResult.stdout.split("\0").filter((path) => path.length > 0).sort((left, right) => left.localeCompare(right));
+      const patchPrefix = `${sandboxPatchDir.replace(/\/+$/, "")}/`;
+      for (const sandboxPatchPath of patchPaths) {
+        if (!sandboxPatchPath.startsWith(patchPrefix)) {
+          return yield* Effect.fail(
+            new SyncError({
+              message: `Sandbox returned a patch outside its patch directory: ${sandboxPatchPath}`
+            })
+          );
+        }
+        const patchName = sandboxPatchPath.slice(patchPrefix.length);
+        try {
+          assertSafePathSegment(patchName, "patch filename");
+        } catch (error) {
+          return yield* Effect.fail(
+            new SyncError({
+              message: `Refusing unsafe patch filename ${patchName}: ${error instanceof Error ? error.message : String(error)}`
+            })
+          );
+        }
+        const hostPatchPath = join(patchDir, patchName);
+        yield* Effect.tryPromise({
+          try: async () => {
+            await assertNoSymlinkComponents(
+              hostRepoDir,
+              hostPatchPath,
+              "patch path"
+            );
+            await handle.copyFileOut(sandboxPatchPath, hostPatchPath);
+            await assertNoSymlinkComponents(
+              hostRepoDir,
+              hostPatchPath,
+              "patch path"
+            );
+          },
+          catch: (e) => new SyncError({
+            message: `Failed to copy patch ${patchName}: ${e instanceof Error ? e.message : String(e)}`
+          })
+        });
+        if (!(yield* isEmptyPatch(hostPatchPath))) {
+          nonEmptyPatches.push(hostPatchPath);
+        }
+      }
+    } finally {
+      yield* execSandbox(handle, `rm -rf ${shellQuote(sandboxPatchDir)}`);
+    }
+  }
+  if (hasDiff) {
+    const diffPath = join(patchDir, "changes.patch");
+    yield* Effect.tryPromise({
+      try: async () => {
+        await assertNoSymlinkComponents(hostRepoDir, diffPath, "diff patch");
+        await writeFile(diffPath, diffResult.stdout, { mode: 384 });
+        await chmod(diffPath, 384);
+      },
+      catch: (e) => new SyncError({
+        message: `Failed to write diff patch: ${e instanceof Error ? e.message : String(e)}`
+      })
+    });
+  }
+  if (hasUntracked) {
+    const untrackedDir = join(patchDir, "untracked");
+    for (const relPath of untrackedFiles) {
+      let hostFilePath;
+      try {
+        assertSafeGitWorktreePath(relPath);
+        hostFilePath = resolveSafeRelativePath(
+          untrackedDir,
+          relPath,
+          "untracked path"
+        );
+      } catch (error) {
+        return yield* Effect.fail(
+          new SyncError({
+            message: `Refusing unsafe untracked path ${relPath}: ${error instanceof Error ? error.message : String(error)}`
+          })
+        );
+      }
+      const sandboxFilePath = posix.join(worktreePath, relPath);
+      const quotedSandboxFilePath = shellQuote(sandboxFilePath);
+      const modeResult = yield* execOk(
+        handle,
+        `mode=$(stat -c '%a' -- ${quotedSandboxFilePath} 2>/dev/null || stat -f '%Lp' ${quotedSandboxFilePath}) && printf '%s\\n' "$mode"`
+      );
+      const sandboxMode = Number.parseInt(modeResult.stdout.trim(), 8);
+      if (!Number.isInteger(sandboxMode) || sandboxMode < 0) {
+        return yield* Effect.fail(
+          new SyncError({
+            message: `Failed to read mode for untracked file ${relPath}`
+          })
+        );
+      }
+      yield* Effect.tryPromise({
+        try: async () => {
+          await mkdir(dirname(hostFilePath), {
+            recursive: true,
+            mode: 448
+          });
+          await assertNoSymlinkComponents(
+            hostRepoDir,
+            hostFilePath,
+            "untracked path"
+          );
+          await handle.copyFileOut(sandboxFilePath, hostFilePath);
+          await chmod(hostFilePath, sandboxMode & 511);
+          await assertNoSymlinkComponents(
+            hostRepoDir,
+            hostFilePath,
+            "untracked path"
+          );
+        },
+        catch: (e) => new SyncError({
+          message: `Failed to save untracked file ${relPath}: ${e instanceof Error ? e.message : String(e)}`
+        })
+      });
+    }
+  }
+  let failedStep;
+  if (nonEmptyPatches.length > 0) {
+    yield* Effect.either(
+      execHostGit2(["am", "--abort"], hostRepoDir)
+    );
+    const applyResult = yield* Effect.either(
+      execHostGit2(["am", "--3way", ...nonEmptyPatches], hostRepoDir)
+    );
+    if (applyResult._tag === "Left") {
+      failedStep = "commits";
+    }
+  }
+  if (!failedStep && hasDiff) {
+    const diffPath = join(patchDir, "changes.patch");
+    const applyResult = yield* Effect.either(
+      execHostGit2(["apply", diffPath], hostRepoDir)
+    );
+    if (applyResult._tag === "Left") {
+      failedStep = "diff";
+    }
+  }
+  if (!failedStep && hasUntracked) {
+    const copyResult = yield* Effect.either(
+      Effect.tryPromise({
+        try: async () => {
+          const untrackedDir = join(patchDir, "untracked");
+          for (const relPath of untrackedFiles) {
+            const srcPath = resolveSafeRelativePath(
+              untrackedDir,
+              relPath,
+              "untracked path"
+            );
+            const destPath = resolveSafeRelativePath(
+              hostRepoDir,
+              relPath,
+              "untracked path"
+            );
+            await mkdir(dirname(destPath), { recursive: true, mode: 448 });
+            await assertNoSymlinkComponents(
+              hostRepoDir,
+              srcPath,
+              "saved untracked path"
+            );
+            await assertNoSymlinkComponents(
+              hostRepoDir,
+              destPath,
+              "untracked path"
+            );
+            const sourceMode = (await stat(srcPath)).mode & 511;
+            await copyFile(srcPath, destPath, constants.COPYFILE_EXCL);
+            await chmod(destPath, sourceMode);
+          }
+        },
+        catch: (e) => new SyncError({
+          message: `Failed to copy untracked files: ${e instanceof Error ? e.message : String(e)}`
+        })
+      })
+    );
+    if (copyResult._tag === "Left") {
+      failedStep = "untracked";
+    }
+  }
+  if (hasCommits && failedStep !== "commits") {
+    yield* execOk(
+      handle,
+      `git update-ref ${shellQuote(SYNC_BASE_REF)} ${shellQuote(sandboxHead)}`,
+      {
+        cwd: worktreePath
+      }
+    );
+  }
+  if (failedStep) {
+    const msg = buildRecoveryMessage({
+      patchDir: relativePatchDir,
+      failedStep,
+      hasCommits: nonEmptyPatches.length > 0,
+      hasDiff,
+      hasUntracked
+    });
+    console.error(`
+${msg}`);
+    const description = failedStep === "commits" ? "committed changes" : failedStep === "diff" ? "uncommitted changes" : "untracked files";
+    return yield* Effect.fail(
+      new SyncError({
+        message: `Failed to sync ${description}; recovery artifacts preserved at ${relativePatchDir}`
+      })
+    );
+  } else {
+    yield* Effect.tryPromise({
+      try: async () => {
+        await assertNoSymlinkComponents(
+          hostRepoDir,
+          patchDir,
+          "patch directory"
+        );
+        await rm(patchDir, { recursive: true, force: true });
+        const patchesRoot = join(hostRepoDir, CONFIG_DIR, PATCHES_DIR);
+        try {
+          const remaining = await readdir(patchesRoot);
+          if (remaining.length === 0) {
+            await assertNoSymlinkComponents(
+              hostRepoDir,
+              patchesRoot,
+              "patch directory"
+            );
+            await rm(patchesRoot, {
+              recursive: true,
+              force: true
+            });
+          }
+        } catch {
+        }
+      },
+      catch: () => new SyncError({ message: "Failed to clean up patch directory" })
+    });
+  }
+});
+
+// src/SandboxLifecycle.ts
+var GIT_SETUP_TIMEOUT_MS = 1e4;
+var HOOK_TIMEOUT_MS = 6e4;
+var COMMIT_COLLECTION_TIMEOUT_MS = 3e4;
+var MERGE_TO_HOST_TIMEOUT_MS = 3e4;
+var GIT_SETUP_MAX_RETRIES = 2;
+var GIT_SETUP_RETRY_DELAY_MS = 250;
+var TRANSIENT_EXEC_EXIT_CODES = /* @__PURE__ */ new Set([126, 137]);
+var isTransientExecError = (err) => err._tag === "ExecError" && err.exitCode !== void 0 && TRANSIENT_EXEC_EXIT_CODES.has(err.exitCode);
+var execOk2 = (sandbox, command, options) => Effect.flatMap(
+  sandbox.exec(command, options),
+  (result) => result.exitCode !== 0 ? Effect.fail(
+    new ExecError({
+      command,
+      exitCode: result.exitCode,
+      message: `Command failed (exit ${result.exitCode}): ${command}
+${result.stderr}`
+    })
+  ) : Effect.succeed(result)
+);
+var execOkWithGitTimeout = (sandbox, command, gitSetupTimeoutMs, options) => execOk2(sandbox, command, options).pipe(
+  withTimeout(
+    gitSetupTimeoutMs,
+    () => new GitSetupTimeoutError({
+      message: `Git command timed out after ${gitSetupTimeoutMs}ms: ${command}`,
+      timeoutMs: gitSetupTimeoutMs,
+      command
+    })
+  ),
+  // Each attempt is bounded by its own timeout (above); retry only transient
+  // exec races, so a genuine git error or a hung exec still fails fast.
+  Effect.retry({
+    while: isTransientExecError,
+    times: GIT_SETUP_MAX_RETRIES,
+    schedule: Schedule.spaced(Duration.millis(GIT_SETUP_RETRY_DELAY_MS))
+  })
+);
+var execAsync = promisify(exec);
+var runHostHooks = (hooks, cwd, signal) => Effect.gen(function* () {
+  for (const hook of hooks) {
+    const timeout = hook.timeoutMs ?? HOOK_TIMEOUT_MS;
+    yield* Effect.tryPromise({
+      try: () => execAsync(hook.command, { cwd, signal }),
+      catch: (err) => new ExecError({
+        command: hook.command,
+        message: `Host hook failed: ${hook.command}
+${err instanceof Error ? err.message : String(err)}`
+      })
+    }).pipe(
+      withTimeout(
+        timeout,
+        () => new HookTimeoutError({
+          message: `Host hook '${hook.command}' timed out after ${timeout}ms`,
+          timeoutMs: timeout,
+          command: hook.command
+        })
+      )
+    );
+  }
+});
+var withSandboxLifecycle = (options, sandbox, work) => Effect.gen(function* () {
+  const display = yield* Display;
+  const { hostRepoDir, sandboxRepoDir, hooks, branch, hostWorktreePath } = options;
+  const gitSetupTimeoutMs = options.timeouts?.gitSetupMs ?? GIT_SETUP_TIMEOUT_MS;
+  const commitCollectionTimeoutMs = options.timeouts?.commitCollectionMs ?? COMMIT_COLLECTION_TIMEOUT_MS;
+  const mergeToHostTimeoutMs = options.timeouts?.mergeToHostMs ?? MERGE_TO_HOST_TIMEOUT_MS;
+  const signal = options.signal ?? new AbortController().signal;
+  const hostCurrentBranch = !branch ? yield* Effect.promise(async () => {
+    return (await execHostGit(
+      ["rev-parse", "--abbrev-ref", "HEAD"],
+      hostRepoDir
+    )).trim();
+  }) : null;
+  const [hostGitName, hostGitEmail] = yield* Effect.promise(async () => {
+    const [nameResult, emailResult] = await Promise.all([
+      execHostGit(["config", "user.name"], hostRepoDir).then((stdout) => stdout.trim()).catch(() => ""),
+      execHostGit(["config", "user.email"], hostRepoDir).then((stdout) => stdout.trim()).catch(() => "")
+    ]);
+    return [nameResult, emailResult];
+  });
+  const hostSideWorktreePath = hostWorktreePath ?? sandboxRepoDir;
+  let resolvedBranch = "";
+  yield* display.taskLog(
+    "Setting up sandbox",
+    (message) => Effect.gen(function* () {
+      yield* execOkWithGitTimeout(
+        sandbox,
+        `git config --global --add safe.directory ${shellQuote(sandboxRepoDir)}`,
+        gitSetupTimeoutMs
+      );
+      if (hostGitName) {
+        yield* execOkWithGitTimeout(
+          sandbox,
+          `git config --global user.name ${shellQuote(hostGitName)}`,
+          gitSetupTimeoutMs
+        );
+      }
+      if (hostGitEmail) {
+        yield* execOkWithGitTimeout(
+          sandbox,
+          `git config --global user.email ${shellQuote(hostGitEmail)}`,
+          gitSetupTimeoutMs
+        );
+      }
+      resolvedBranch = (yield* execOkWithGitTimeout(
+        sandbox,
+        "git rev-parse --abbrev-ref HEAD",
+        gitSetupTimeoutMs,
+        { cwd: sandboxRepoDir }
+      )).stdout.trim();
+      const sandboxHooks = hooks?.sandbox?.onSandboxReady;
+      const hostOnSandboxReady = hooks?.host?.onSandboxReady;
+      if (sandboxHooks?.length) {
+        for (const hook of sandboxHooks) {
+          message(hook.command);
+        }
+      }
+      if (hostOnSandboxReady?.length) {
+        for (const hook of hostOnSandboxReady) {
+          message(`[host] ${hook.command}`);
+        }
+      }
+      const abortDeferred = yield* Deferred.make();
+      let abortCleanup = null;
+      if (signal.aborted) {
+        yield* Deferred.fail(
+          abortDeferred,
+          new ExecError({
+            command: "abort",
+            message: `Aborted: ${signal.reason}`
+          })
+        );
+      } else {
+        const onAbort = () => {
+          Effect.runPromise(
+            Deferred.fail(
+              abortDeferred,
+              new ExecError({
+                command: "abort",
+                message: `Aborted: ${signal.reason}`
+              })
+            )
+          ).catch(() => {
+          });
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        abortCleanup = () => signal.removeEventListener("abort", onAbort);
+      }
+      const sandboxHookEffects = (sandboxHooks ?? []).map((hook) => {
+        const timeout = hook.timeoutMs ?? HOOK_TIMEOUT_MS;
+        return Effect.raceFirst(
+          execOk2(sandbox, hook.command, {
+            cwd: sandboxRepoDir,
+            sudo: hook.sudo
+          }).pipe(
+            withTimeout(
+              timeout,
+              () => new HookTimeoutError({
+                message: `Hook '${hook.command}' timed out after ${timeout}ms`,
+                timeoutMs: timeout,
+                command: hook.command
+              })
+            )
+          ),
+          Deferred.await(abortDeferred)
+        );
+      });
+      const hostHookEffects = (hostOnSandboxReady ?? []).map((hook) => {
+        const timeout = hook.timeoutMs ?? HOOK_TIMEOUT_MS;
+        return Effect.tryPromise({
+          try: () => execAsync(hook.command, {
+            cwd: hostSideWorktreePath,
+            signal
+          }),
+          catch: (err) => new ExecError({
+            command: hook.command,
+            message: `Host hook failed: ${hook.command}
+${err instanceof Error ? err.message : String(err)}`
+          })
+        }).pipe(
+          withTimeout(
+            timeout,
+            () => new HookTimeoutError({
+              message: `Host hook '${hook.command}' timed out after ${timeout}ms`,
+              timeoutMs: timeout,
+              command: hook.command
+            })
+          )
+        );
+      });
+      const allOnSandboxReady = [...sandboxHookEffects, ...hostHookEffects];
+      yield* (allOnSandboxReady.length > 0 ? Effect.all(allOnSandboxReady, { concurrency: "unbounded" }) : Effect.void).pipe(Effect.ensuring(Effect.sync(() => abortCleanup?.())));
+    })
+  );
+  const targetBranch = branch ?? resolvedBranch;
+  const baseHead = yield* Effect.promise(async () => {
+    return (await execHostGit(["rev-parse", "HEAD"], hostSideWorktreePath)).trim();
+  });
+  const result = yield* work({ sandbox, sandboxRepoDir, baseHead });
+  if (options.applyToHost) {
+    const commitCount = yield* countCommitsToSync(
+      sandbox,
+      sandboxRepoDir,
+      baseHead
+    );
+    yield* display.taskLog(
+      commitCount > 0 ? `Syncing ${commitCount} commit${commitCount !== 1 ? "s" : ""} to host` : "No commits to sync out",
+      () => options.applyToHost()
+    );
+  }
+  let commits;
+  let finalBranch;
+  if (hostCurrentBranch !== null) {
+    const hasNewCommits = yield* Effect.promise(async () => {
+      try {
+        const stdout = await execHostGit(
+          ["rev-list", `${baseHead}..HEAD`, "--count"],
+          hostSideWorktreePath
+        );
+        return parseInt(stdout.trim(), 10) > 0;
+      } catch {
+        return false;
+      }
+    });
+    if (!options.keepSourceBranch) {
+      if (options.applyToHost) {
+        yield* Effect.tryPromise({
+          try: () => execHostGit(["checkout", "--detach"], hostSideWorktreePath),
+          catch: (error) => new SyncError({
+            message: `Failed to detach host worktree: ${String(error)}`
+          })
+        });
+      } else {
+        yield* execOk2(sandbox, "git checkout --detach", {
+          cwd: sandboxRepoDir
+        });
+      }
+    }
+    if (hasNewCommits) {
+      yield* display.taskLog(
+        `Merging to ${hostCurrentBranch}`,
+        () => Effect.tryPromise({
+          try: async () => {
+            try {
+              await execHostGit(["merge", "--", resolvedBranch], hostRepoDir);
+            } catch {
+              throw new Error(
+                `Merge of '${resolvedBranch}' onto '${hostCurrentBranch}' failed. The temporary branch '${resolvedBranch}' has been preserved. To retry: git merge ${resolvedBranch}, then clean up: git branch -D ${resolvedBranch}`
+              );
+            }
+          },
+          catch: (e) => new SyncError({
+            message: String(e instanceof Error ? e.message : e)
+          })
+        }).pipe(
+          withTimeout(
+            mergeToHostTimeoutMs,
+            () => new MergeToHostTimeoutError({
+              message: `Merge of '${resolvedBranch}' to '${hostCurrentBranch}' timed out after ${mergeToHostTimeoutMs}ms`,
+              timeoutMs: mergeToHostTimeoutMs,
+              sourceBranch: resolvedBranch,
+              targetBranch: hostCurrentBranch
+            })
+          )
+        )
+      );
+    }
+    if (!options.keepSourceBranch) {
+      yield* Effect.promise(
+        () => execHostGit(
+          ["branch", "-D", "--", resolvedBranch],
+          hostRepoDir
+        ).catch(() => {
+        })
+      );
+    }
+    commits = yield* display.taskLog(
+      "Collecting commits",
+      () => Effect.promise(async () => {
+        try {
+          const stdout = await execHostGit(
+            ["rev-list", `${baseHead}..HEAD`, "--reverse"],
+            hostRepoDir
+          );
+          const lines = stdout.trim();
+          if (!lines) return [];
+          return lines.split("\n").map((sha) => ({ sha }));
+        } catch {
+          return [];
+        }
+      }).pipe(
+        withTimeout(
+          commitCollectionTimeoutMs,
+          () => new CommitCollectionTimeoutError({
+            message: `Commit collection timed out after ${commitCollectionTimeoutMs}ms`,
+            timeoutMs: commitCollectionTimeoutMs
+          })
+        )
+      )
+    );
+    finalBranch = hostCurrentBranch;
+  } else {
+    commits = yield* display.taskLog(
+      "Collecting commits",
+      () => Effect.promise(async () => {
+        try {
+          const stdout = await execHostGit(
+            [
+              "rev-list",
+              `${baseHead}..refs/heads/${targetBranch}`,
+              "--reverse"
+            ],
+            hostRepoDir
+          );
+          const lines = stdout.trim();
+          if (!lines) return [];
+          return lines.split("\n").map((sha) => ({ sha }));
+        } catch {
+          return [];
+        }
+      }).pipe(
+        withTimeout(
+          commitCollectionTimeoutMs,
+          () => new CommitCollectionTimeoutError({
+            message: `Commit collection timed out after ${commitCollectionTimeoutMs}ms`,
+            timeoutMs: commitCollectionTimeoutMs
+          })
+        )
+      )
+    );
+    finalBranch = targetBranch;
+  }
+  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 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)}`
+  })
+}).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 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
+      });
+      yield* Effect.tryPromise({
+        try: () => handle.exec(`rm -rf ${shellQuote(sandboxTmpDir)}`),
+        catch: () => new SyncError({ message: "Failed to clean up sandbox temp dir" })
+      });
+      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 rawMounts = [
+      {
+        hostPath: options.worktreeOrRepoPath,
+        sandboxPath: options.repoDir
+      },
+      ...options.gitMounts
+    ];
+    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 {
+            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,
+    Effect.gen(function* () {
+      const {
+        env,
+        hostRepoDir,
+        copyToWorktree: copyPaths,
+        name,
+        sandboxProvider,
+        branchStrategy,
+        hooks,
+        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(() => {
+            console.error(
+              "[shipyard] Warning: failed to prune stale worktrees:",
+              e.message
+            );
+          })
+        ),
+        Effect.andThen(
+          branch ? create(hostRepoDir, { branch, baseBranch }) : create(hostRepoDir, { name })
+        ),
+        Effect.provideService(FileSystem.FileSystem, fileSystem)
+      );
+      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(),
+              (worktreeInfo) => (hooks?.host?.onWorktreeReady?.length ? runHostHooks(
+                hooks.host.onWorktreeReady,
+                worktreeInfo.path,
+                signal
+              ) : Effect.void).pipe(
+                Effect.andThen(
+                  Effect.acquireUseRelease(
+                    startSandbox({
+                      provider: sandboxProvider,
+                      hostRepoDir: worktreeInfo.path,
+                      sourceRepoDir: hostRepoDir,
+                      env,
+                      copyPaths
+                    }),
+                    ({ sandbox, worktreePath, handle }) => makeEffect(
+                      {
+                        hostWorktreePath: worktreeInfo.path,
+                        sandboxRepoPath: worktreePath,
+                        bindMountHandle: toSessionTransferHandle(handle),
+                        applyToHost: () => syncOut(
+                          worktreeInfo.path,
+                          handle
+                        )
+                      },
+                      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 (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})` : "")
+    );
+  }
+  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 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`
+      });
+      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.`
+      );
+    }
+    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.`
+      );
+    }
+  }
+};
+
+// 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();
+  };
+};
+
+export { AgentError, AgentIdleTimeoutError, CLI_NAME, CONFIG_DIR, ClackDisplay, ConfigDirError, CwdError, Display, DockerError, ExecHostError, FileDisplay, InitError, LOCKS_DIR, LOGS_DIR, PRODUCT_NAME, PromptError, PromptExpansionTimeoutError, SANDBOX_REPO_DIR, SandboxConfig, SandboxFactory, SessionCaptureError, SilentDisplay, WorktreeDockerSandboxFactory, assertIsolatedWorkspaceMounts, assertNoSymlinkComponents, copyToWorktree, create, defaultImageName, formatVolumeMount, generateTempBranchName, getCurrentBranch, hasUncommittedChanges, makeSandboxFromHandle, patchGitMountsForWindows, processFileMountParents, pruneStale, registerShutdown, remove, resolveCwd, resolveGitMounts, resolveUserMounts, runHostHooks, startSandbox, syncOut, withSandboxLifecycle };
+//# sourceMappingURL=chunk-2GT3OPO5.js.map
+//# sourceMappingURL=chunk-2GT3OPO5.js.map